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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
1,582 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(std::string string) {
std::regex regex(R"(^[a-z]$|^([a-z]).*\1$)");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("abba") == "Valid");
assert(func0("a") == "Valid");
assert(func0("abcd") == "Invalid");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
mov ... | _Z5func0NSt7__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
x... | 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,[0x1185f4]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,... | /* func0(std::string) */
long * func0(long *param_1,int8 *param_2)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
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;
local_30 = *(lo... |
1,583 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| std::string func0(std::string string) {
std::regex regex(R"(^[a-z]$|^([a-z]).*\1$)");
if (std::regex_search(string, regex))
return "Valid";
else
return "Invalid";
}
| int main() {
assert(func0("abba") == "Valid");
assert(func0("a") == "Valid");
assert(func0("abcd") == "Invalid");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
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
mov ... | _Z5func0NSt7__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
cal... | 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,[0x11a635]
PXOR XMM0,XMM0
LEA RDI,[RSP + 0x110]
MOV R8D,0x10
MOV RCX,R14
LEA RSI,[RD... | /* func0(std::string) */
long * func0(long *param_1,ulong *param_2)
{
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;
uint *puVar14;
_Match_mode _Var15;
long ... |
1,584 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov -0x14(%rbp),%eax
cmp -0x18(%rbp),%eax
jle 118a <_Z5func0iii+0x41>
mov -0x14(%rbp),%eax
cmp -0x1c(%rbp),%eax
jge 1172 <_Z5func0iii+0x29>
mov -0x14(%rbp),%eax
mov ... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov eax, [rbp+var_14]
cmp eax, [rbp+var_18]
jle short loc_118A
mov eax, [rbp+var_14]
cmp eax, [rbp+var_1C]
jge short loc_1172
mov eax, [rbp+var_14]
mov [rbp+var... | long long func0(signed int a1, signed int a2, signed int a3)
{
if ( a1 <= a2 )
{
if ( a1 <= a3 )
{
if ( a2 >= a3 )
return (unsigned int)a3;
else
return (unsigned int)a2;
}
else
{
return (unsigned int)a1;
}
}
else if ( a1 >= a3 )
{
if ( a2 <= a3 )
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x18]
JLE 0x0010118a
MOV EAX,dword ptr [RBP + -0x14]
CMP EAX,dword ptr [RBP + -0x1c]
JGE 0x00101172
MOV EAX,dword ptr [RBP + -0x14... | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
int local_c;
local_c = param_1;
if (param_2 < param_1) {
if ((param_3 <= param_1) && (local_c = param_3, param_3 < param_2)) {
local_c = param_2;
}
}
else if ((param_1 <= param_3) && (local_c = param_3, param_2 < pa... |
1,585 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 113f <_Z5func0iii+0x16>
cmp %edx,%edi
jl 114a <_Z5func0iii+0x21>
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
retq
cmp %edx,%edi
jg 114a <_Z5func0iii+0x21>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
| _Z5func0iii:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_113E
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_113E:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned ... | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x0010113e
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_0010113e:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <=... |
1,586 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <_Z5func0iii+0x10>
cmp %edx,%edi
jge 1160 <_Z5func0iii+0x20>
retq
cmp %edx,%edi
jg 114e <_Z5func0iii+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
r... | _Z5func0iii:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned ... | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <=... |
1,587 | func0 |
#include <assert.h>
| int func0(int a, int b, int c) {
int median;
if (a > b) {
if (a < c) {
median = a;
} else if (b > c) {
median = b;
} else {
median = c;
}
} else {
if (a > c) {
median = a;
} else if (b < c) {
... | int main() {
assert(func0(25, 55, 65) == 55);
assert(func0(20, 10, 30) == 20);
assert(func0(15, 45, 75) == 45);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
mov %edi,%eax
cmp %esi,%edi
jle 1150 <_Z5func0iii+0x10>
cmp %edx,%edi
jge 1160 <_Z5func0iii+0x20>
retq
cmp %edx,%edi
jg 114e <_Z5func0iii+0xe>
cmp %edx,%esi
mov %edx,%eax
cmovle %esi,%eax
retq
nopl 0x0(%rax)
cmp %edx,%esi
mov %edx,%eax
cmovge %esi,%eax
r... | _Z5func0iii:
endbr64
mov eax, edi
cmp edi, esi
jle short loc_1158
cmp esi, edx
cmovl esi, edx
cmp edi, edx
cmovge eax, esi
retn
loc_1158:
cmp esi, edx
cmovg esi, edx
cmp edi, edx
cmovle eax, esi
retn | long long func0(signed int a1, signed int a2, signed int a3)
{
long long result; // rax
result = (unsigned int)a1;
if ( a1 <= a2 )
{
if ( a2 > a3 )
a2 = a3;
if ( a1 <= a3 )
return (unsigned int)a2;
}
else
{
if ( a2 < a3 )
a2 = a3;
if ( a1 >= a3 )
return (unsigned ... | func0:
ENDBR64
MOV EAX,EDI
CMP EDI,ESI
JLE 0x00101158
CMP ESI,EDX
CMOVL ESI,EDX
CMP EDI,EDX
CMOVGE EAX,ESI
RET
LAB_00101158:
CMP ESI,EDX
CMOVG ESI,EDX
CMP EDI,EDX
CMOVLE EAX,ESI
RET | /* func0(int, int, int) */
int func0(int param_1,int param_2,int param_3)
{
if (param_2 < param_1) {
if (param_2 < param_3) {
param_2 = param_3;
}
if (param_3 <= param_1) {
param_1 = param_2;
}
return param_1;
}
if (param_3 < param_2) {
param_2 = param_3;
}
if (param_1 <=... |
1,588 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <variant>
| int func0(const std::vector<std::variant<int, std::string>>& nums) {
int total_sum = 0;
for (const auto& el : nums) {
if (std::holds_alternative<int>(el)) {
int num = std::abs(std::get<int>(el));
while (num > 0) {
total_sum += num % 10;
num ... | int main() {
assert(func0({10,2,56}) == 14);
assert(func0({10, 20, 4, 5, "b", 70, "a"}) == 19);
assert(func0({10, 20, -4, 5, -70}) == 19);
return 0;
}
| O0 | cpp | func0(std::vector<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x90,%rsp
mov %rdi,-0x88(... | _Z5func0RKSt6vectorISt7variantIJiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaIS7_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 90h
mov [rbp+var_88], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov [rbp+var_70], 0
mov rax, [rbp+var_88]
mov [rbp+var_48], rax
mov ... | long long func0(long long a1)
{
int v1; // eax
long long v2; // rax
char v4; // [rsp+1Fh] [rbp-71h]
unsigned int v5; // [rsp+20h] [rbp-70h]
int i; // [rsp+24h] [rbp-6Ch]
long long v7; // [rsp+28h] [rbp-68h] BYREF
long long v8; // [rsp+30h] [rbp-60h] BYREF
long long v9; // [rsp+38h] [rbp-58h] BYREF
_Q... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x90
MOV qword ptr [RBP + -0x88],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x70],0x0
MOV RAX,qword ptr [RBP + -0x88]
MOV qword ptr [RBP + -0x48],RAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001033dc
MOV qword pt... | /* func0(std::vector<std::variant<int, std::string >, std::allocator<std::variant<int, std::string >
> > const&) */
int func0(vector *param_1)
{
bool bVar1;
int *piVar2;
string *psVar3;
char *pcVar4;
long in_FS_OFFSET;
int local_78;
int local_74;
int8 local_70;
int8 local_68;
int8 local_60;
i... |
1,589 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <variant>
| int func0(const std::vector<std::variant<int, std::string>>& nums) {
int total_sum = 0;
for (const auto& el : nums) {
if (std::holds_alternative<int>(el)) {
int num = std::abs(std::get<int>(el));
while (num > 0) {
total_sum += num % 10;
num ... | int main() {
assert(func0({10,2,56}) == 14);
assert(func0({10, 20, 4, 5, "b", 70, "a"}) == 19);
assert(func0({10, 20, -4, 5, -70}) == 19);
return 0;
}
| O1 | cpp | func0(std::vector<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp... | _Z5func0RKSt6vectorISt7variantIJiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaIS7_EE:
endbr64
push r12
push rbp
push rbx
sub rsp, 30h
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
mov rbx, [rdi]
mov r12, [rdi+8]
cmp r12, rbx
jz loc_13BC
mov ebp, 0
jmp ... | long long func0(_QWORD *a1)
{
_QWORD *v1; // rbx
_QWORD *v2; // r12
unsigned int v3; // ebp
int v4; // edx
int v5; // ecx
char v6; // al
char *v7; // rax
void *v9; // [rsp+0h] [rbp-48h] BYREF
long long v10; // [rsp+8h] [rbp-40h]
_QWORD v11[7]; // [rsp+10h] [rbp-38h] BYREF
v11[3] = __readfsqword(... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
CMP R12,RBX
JZ 0x001013bc
MOV EBP,0x0
JMP 0x0010133f
LAB_001012fc:
MOV EAX,dword ptr [RBX]
MOV EDX,EAX
NEG EDX
CMOVS EDX,EAX
TEST EDX,EDX
JL... | /* func0(std::vector<std::variant<int, std::string >, std::allocator<std::variant<int, std::string >
> > const&) */
int func0(vector *param_1)
{
int iVar1;
int *piVar2;
bool bVar3;
int iVar4;
long *plVar5;
int *piVar6;
int iVar7;
long in_FS_OFFSET;
long *local_48;
long local_40;
long local_38... |
1,590 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <variant>
| int func0(const std::vector<std::variant<int, std::string>>& nums) {
int total_sum = 0;
for (const auto& el : nums) {
if (std::holds_alternative<int>(el)) {
int num = std::abs(std::get<int>(el));
while (num > 0) {
total_sum += num % 10;
num ... | int main() {
assert(func0({10,2,56}) == 14);
assert(func0({10, 20, 4, 5, "b", 70, "a"}) == 19);
assert(func0({10, 20, -4, 5, -70}) == 19);
return 0;
}
| O2 | cpp | func0(std::vector<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&):
endbr64
push %r14
push %r13
push %r12
xor %r12d,%r12d
push %rb... | _Z5func0RKSt6vectorISt7variantIJiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaIS7_EE:
endbr64
push r14
push r13
push r12
push rbp
push rbx
xor ebx, ebx
sub rsp, 30h
mov rbp, [rdi]
mov r13, [rdi+8]
mov rax, fs:28h
mov [rsp+58h+var_30], rax
xor eax, eax
cmp r13, r... | long long func0(_QWORD *a1)
{
unsigned int v1; // ebx
_QWORD *v2; // rbp
_QWORD *v3; // r13
char v4; // al
unsigned int v5; // edx
long long v7; // rdx
char *v8; // rdx
unsigned int v9; // eax
void *v10; // [rsp+0h] [rbp-58h] BYREF
long long v11; // [rsp+8h] [rbp-50h]
_QWORD v12[9]; // [rsp+10h] ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x30
MOV RBP,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
CMP R13,RBP
JZ 0x0010190a
MOV R12D,0xcccccccd
JMP 0x001018cd
LAB_001018c0:
CMP AL,0x1
JZ 0x00101930
LAB_001018... | /* func0(std::vector<std::variant<int, std::string >, std::allocator<std::variant<int, std::string >
> > const&) */
int func0(vector *param_1)
{
uint uVar1;
uint *puVar2;
uint uVar3;
long *plVar4;
int iVar5;
uint *puVar6;
long in_FS_OFFSET;
long *local_58;
long local_50;
long local_48 [3];
lo... |
1,591 | func0 |
#include <vector>
#include <string>
#include <cassert>
#include <variant>
| int func0(const std::vector<std::variant<int, std::string>>& nums) {
int total_sum = 0;
for (const auto& el : nums) {
if (std::holds_alternative<int>(el)) {
int num = std::abs(std::get<int>(el));
while (num > 0) {
total_sum += num % 10;
num ... | int main() {
assert(func0({10,2,56}) == 14);
assert(func0({10, 20, 4, 5, "b", 70, "a"}) == 19);
assert(func0({10, 20, -4, 5, -70}) == 19);
return 0;
}
| O3 | cpp | func0(std::vector<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::variant<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
xor %r12d,%r12... | _Z5func0RKSt6vectorISt7variantIJiNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEEESaIS7_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
xor ebx, ebx
sub rsp, 58h
mov rbp, [rdi]
mov r13, [rdi+8]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
cm... | long long func0(long long *a1)
{
unsigned int v1; // ebx
long long v2; // rbp
long long v3; // r13
char v4; // al
unsigned int v5; // edx
size_t v7; // r15
_BYTE *v8; // rcx
_QWORD *v9; // rax
__int8 *v10; // rdx
const __m128i *v11; // rax
__m128i v12; // xmm3
__m128i si128; // xmm6
unsigned ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
XOR EBX,EBX
SUB RSP,0x58
MOV RBP,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
CMP R13,RBP
JZ 0x00101a8a
MOV R12D,0xcccccccd
JMP 0x00101a4d
LAB_00101a40:
CMP AL,0x1
JZ 0x00101ab0
L... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::variant<int, std::string >, std::allocator<std::variant<int, std::string >
> > const&) */
int func0(vector *param_1)
{
int (*pauVar1) [16];
uint *puVar2;
int *__src;
int auVar3 [14];
int auVar4 ... |
1,592 | func0 |
#include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) ^ std::get<0>(test_tup2),
std::get<1>(test_tup1) ^ std::get<1>(test_tup2),
std::get<2>(test_tup1) ^ std:... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(15, 6, 5, 10));
assert(func0(std::make_tuple(11, 5, 7, 10), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(13, 6, 3, 14));
assert(func0(std::make_tuple(12, 6, 8, 11), std::make_tuple(7, 4, 5, 6)) == s... | O0 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%rax
mov %ra... | _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_40]
mov rdi, rax
call _ZSt3getILm3EJiiiiEERKNSt13tupl... | long long func0(long long a1, long long a2, long long a3)
{
int v3; // ebx
int v4; // ebx
int v5; // ebx
int v6; // ebx
int v9; // [rsp+28h] [rbp-28h] BYREF
int v10; // [rsp+2Ch] [rbp-24h] BYREF
int v11; // [rsp+30h] [rbp-20h] BYREF
int v12; // [rsp+34h] [rbp-1Ch] BYREF
unsigned long long v13; // [rs... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
CALL 0x001015f7
MOV EBX,dword ptr [RAX]
MOV RAX,qw... | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
tuple * func0(tuple *param_1,tuple *param_2)
{
uint uVar1;
type *ptVar2;
type *ptVar3;
type *ptVar4;
type *ptVar5;
tuple *in_RDX;
long in_FS_OFFSET;
uint local_30;
uint local_2c;
uint local_28;
uint local_2... |
1,593 | func0 |
#include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) ^ std::get<0>(test_tup2),
std::get<1>(test_tup1) ^ std::get<1>(test_tup2),
std::get<2>(test_tup1) ^ std:... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(15, 6, 5, 10));
assert(func0(std::make_tuple(11, 5, 7, 10), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(13, 6, 3, 14));
assert(func0(std::make_tuple(12, 6, 8, 11), std::make_tuple(7, 4, 5, 6)) == s... | O1 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
mov %rdi,%rax
mov 0x4(%rsi),%r8d
xor 0x4(%rdx),%r8d
mov 0x8(%rsi),%edi
xor 0x8(%rdx),%edi
mov 0xc(%rsi),%ecx
xor 0xc(%rdx),%ecx
mov (%rsi),%esi
xor (%rdx),%esi
mov %esi,(%rax)
mov %r8d,0x4(%rax)... | _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
mov rax, rdi
mov r8d, [rsi+4]
xor r8d, [rdx+4]
mov edi, [rsi+8]
xor edi, [rdx+8]
mov ecx, [rsi+0Ch]
xor ecx, [rdx+0Ch]
mov esi, [rsi]
xor esi, [rdx]
mov [rax], esi
mov [rax+4], r8d
mov [rax+8], edi
mov [rax+0Ch], ecx
retn | int * func0(int *a1, _DWORD *a2, _DWORD *a3)
{
int *result; // rax
int v4; // r8d
int v5; // edi
int v6; // ecx
result = a1;
v4 = a3[1] ^ a2[1];
v5 = a3[2] ^ a2[2];
v6 = a3[3] ^ a2[3];
*result = *a3 ^ *a2;
result[1] = v4;
result[2] = v5;
result[3] = v6;
return result;
} | func0:
ENDBR64
MOV RAX,RDI
MOV R8D,dword ptr [RSI + 0x4]
XOR R8D,dword ptr [RDX + 0x4]
MOV EDI,dword ptr [RSI + 0x8]
XOR EDI,dword ptr [RDX + 0x8]
MOV ECX,dword ptr [RSI + 0xc]
XOR ECX,dword ptr [RDX + 0xc]
MOV ESI,dword ptr [RSI]
XOR ESI,dword ptr [RDX]
MOV dword ptr [RAX],ESI
MOV dword ptr [RAX + 0x4],R8D
MOV dword p... | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
void func0(tuple *param_1,tuple *param_2)
{
uint uVar1;
uint uVar2;
uint uVar3;
uint uVar4;
uint uVar5;
uint uVar6;
uint *in_RDX;
uVar1 = *(uint *)(param_2 + 4);
uVar2 = in_RDX[1];
uVar3 = *(uint *)(param_... |
1,594 | func0 |
#include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) ^ std::get<0>(test_tup2),
std::get<1>(test_tup1) ^ std::get<1>(test_tup2),
std::get<2>(test_tup1) ^ std:... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(15, 6, 5, 10));
assert(func0(std::make_tuple(11, 5, 7, 10), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(13, 6, 3, 14));
assert(func0(std::make_tuple(12, 6, 8, 11), std::make_tuple(7, 4, 5, 6)) == s... | O2 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
mov 0x8(%rsi),%rcx
mov %rdi,%rax
mov 0x8(%rdx),%rdi
mov (%rsi),%rsi
xor (%rdx),%rsi
xor %rdi,%rcx
mov %rsi,(%rax)
mov %rcx,0x8(%rax)
retq
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
movdqu xmm1, xmmword ptr [rdx]
mov rax, rdi
pxor xmm0, xmm1
movups xmmword ptr [rdi], xmm0
retn | __m128i * func0(__m128i *a1, const __m128i *a2, const __m128i *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_xor_si128(_mm_loadu_si128(a2), _mm_loadu_si128(a3));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOVDQU XMM1,xmmword ptr [RDX]
MOV RAX,RDI
PXOR XMM0,XMM1
MOVUPS xmmword ptr [RDI],XMM0
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
tuple * func0(tuple *param_1,tuple *param_2)
{
ulong uVar1;
ulong uVar2;
ulong *in_RDX;
uVar1 = *(ulong *)(param_2 + 8);
uVar2 = in_RDX[1];
*(ulong *)param_1 = *(ulong *)param_2 ^ *in_RDX;
*(ulong *)(param_1 + 8... |
1,595 | func0 |
#include <tuple>
#include <vector>
#include <cassert>
| std::tuple<int, int, int, int> func0(const std::tuple<int, int, int, int>& test_tup1, const std::tuple<int, int, int, int>& test_tup2) {
return std::make_tuple(
std::get<0>(test_tup1) ^ std::get<0>(test_tup2),
std::get<1>(test_tup1) ^ std::get<1>(test_tup2),
std::get<2>(test_tup1) ^ std:... | int main() {
assert(func0(std::make_tuple(10, 4, 6, 9), std::make_tuple(5, 2, 3, 3)) == std::make_tuple(15, 6, 5, 10));
assert(func0(std::make_tuple(11, 5, 7, 10), std::make_tuple(6, 3, 4, 4)) == std::make_tuple(13, 6, 3, 14));
assert(func0(std::make_tuple(12, 6, 8, 11), std::make_tuple(7, 4, 5, 6)) == s... | O3 | cpp | func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&):
endbr64
movdqu (%rsi),%xmm0
movdqu (%rdx),%xmm1
mov %rdi,%rax
pxor %xmm1,%xmm0
movups %xmm0,(%rdi)
retq
nopw 0x0(%rax,%rax,1)
| _Z5func0RKSt5tupleIJiiiiEES2_:
endbr64
movdqu xmm0, xmmword ptr [rsi]
movdqu xmm1, xmmword ptr [rdx]
mov rax, rdi
pxor xmm0, xmm1
movups xmmword ptr [rdi], xmm0
retn | __m128i * func0(__m128i *a1, const __m128i *a2, const __m128i *a3)
{
__m128i *result; // rax
result = a1;
*a1 = _mm_xor_si128(_mm_loadu_si128(a2), _mm_loadu_si128(a3));
return result;
} | func0:
ENDBR64
MOVDQU XMM0,xmmword ptr [RSI]
MOVDQU XMM1,xmmword ptr [RDX]
MOV RAX,RDI
PXOR XMM0,XMM1
MOVUPS xmmword ptr [RDI],XMM0
RET | /* func0(std::tuple<int, int, int, int> const&, std::tuple<int, int, int, int> const&) */
tuple * func0(tuple *param_1,tuple *param_2)
{
ulong uVar1;
ulong uVar2;
ulong *in_RDX;
uVar1 = *(ulong *)(param_2 + 8);
uVar2 = in_RDX[1];
*(ulong *)param_1 = *(ulong *)param_2 ^ *in_RDX;
*(ulong *)(param_1 + 8... |
1,596 | func0 |
#include <cassert>
#include <vector>
#include <utility>
#include <algorithm>
#include <set>
| int func0(const std::vector<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> unique_pairs;
for(auto sub : test_list){
if(sub.first > sub.second){
std::swap(sub.first, sub.second);
}
unique_pairs.emplace(sub);
}
return unique_pairs.size();
}
... | int main() {
assert(func0({{3, 4}, {1, 2}, {4, 3}, {5, 6}}) == 3);
assert(func0({{4, 15}, {2, 3}, {5, 4}, {6, 7}}) == 4);
assert(func0({{5, 16}, {2, 3}, {6, 5}, {6, 9}}) == 4);
return 0;
}
| O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x50(%rbp),%rax
mov %rax,%rdi
callq 186c <_ZNSt3setISt4pairIiiESt4le... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
call _ZNSt3setISt4pairIiiESt4lessIS1_ESaIS1_EEC2Ev; std::set<std::pair<int,int... | long long func0(long long a1)
{
unsigned int v1; // ebx
long long v3; // [rsp+10h] [rbp-70h] BYREF
_QWORD v4[2]; // [rsp+18h] [rbp-68h] BYREF
long long v5; // [rsp+28h] [rbp-58h] BYREF
_BYTE v6[56]; // [rsp+30h] [rbp-50h] BYREF
unsigned long long v7; // [rsp+68h] [rbp-18h]
v7 = __readfsqword(0x28u);
s... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x0010181c
MOV RAX,qword ptr [RBP + -0x78]
MOV qword ptr [RBP + -0x60],RAX
MOV RAX,qword ptr [RBP + -0x60]
MOV RDI,RAX
... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
int4 func0(vector *param_1)
{
int8 uVar1;
bool bVar2;
int4 uVar3;
int8 *puVar4;
long in_FS_OFFSET;
int8 local_78;
int8 local_70;
vector<std::pair<int,int>,std::allocator<std::pair<int,int>>> *local_68;
int8 l... |
1,597 | func0 |
#include <cassert>
#include <vector>
#include <utility>
#include <algorithm>
#include <set>
| int func0(const std::vector<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> unique_pairs;
for(auto sub : test_list){
if(sub.first > sub.second){
std::swap(sub.first, sub.second);
}
unique_pairs.emplace(sub);
}
return unique_pairs.size();
}
... | int main() {
assert(func0({{3, 4}, {1, 2}, {4, 3}, {5, 6}}) == 3);
assert(func0({{4, 15}, {2, 3}, {5, 4}, {6, 7}}) == 4);
assert(func0({{5, 16}, {2, 3}, {6, 5}, {6, 9}}) == 4);
return 0;
}
| O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
movl $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
lea 0x18(%rsp),%rax
mov %rax,0x28(%rsp)
mov %rax,0x30(%... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
mov [rsp+68h+var_50], 0
mov [rsp+68h+var_48], 0
lea rax, [rsp+68h+var_50]
mov [rsp+68h+var_40], rax
mov [rsp+68h+var_38], rax
mov ... | long long func0(unsigned long long **a1)
{
unsigned long long *v1; // rbx
unsigned long long *v2; // rbp
unsigned long long v3; // rax
unsigned long long v4; // rsi
unsigned int v5; // ebx
unsigned long long v7; // [rsp+8h] [rbp-60h] BYREF
char v8[8]; // [rsp+10h] [rbp-58h] BYREF
int v9; // [rsp+18h] [... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
LEA RAX,[RSP + 0x18]
MOV qword ptr [RSP + 0x28],RAX
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],0x0
MOV RBX,qword ptr ... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
ulong func0(vector *param_1)
{
int8 *puVar1;
ulong uVar2;
int8 *puVar3;
int iVar4;
long in_FS_OFFSET;
int8 local_60;
_Rb_tree<std::pair<int,int>,std::pair<int,int>,std::_Identity<std::pair<int,int>>,std::less<std... |
1,598 | func0 |
#include <cassert>
#include <vector>
#include <utility>
#include <algorithm>
#include <set>
| int func0(const std::vector<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> unique_pairs;
for(auto sub : test_list){
if(sub.first > sub.second){
std::swap(sub.first, sub.second);
}
unique_pairs.emplace(sub);
}
return unique_pairs.size();
}
... | int main() {
assert(func0({{3, 4}, {1, 2}, {4, 3}, {5, 6}}) == 3);
assert(func0({{4, 15}, {2, 3}, {5, 4}, {6, 7}}) == 4);
assert(func0({{5, 16}, {2, 3}, {6, 5}, {6, 9}}) == 4);
return 0;
}
| O2 | cpp | func0(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 $0x58,%rsp
mov (%rdi),%rbp
mov 0x8(%rdi),%r15
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x18(%rsp),%r14
movl $0x... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rbx, [rdi]
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+78h+var_30], rax
xor eax, eax
lea rax, [rsp+78h+var_60]
lea r13, [rsp+78h+var_70]
mov [rsp+78h+var_60], 0
mov [rs... | long long func0(unsigned long long **a1)
{
unsigned long long *v1; // rbx
unsigned long long *v2; // rbp
_QWORD *v3; // rbx
unsigned int v4; // ebp
void *v5; // rdi
unsigned long long v7; // [rsp+8h] [rbp-70h] BYREF
char v8[8]; // [rsp+10h] [rbp-68h] BYREF
int v9; // [rsp+18h] [rbp-60h] BYREF
void *v... | func0:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00101440
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101182
MOV RDI,RBX
LAB_0010117d:
CALL 0x00101150
LAB_00101182:
CALL 0x00101140 | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,
_Rb_tree_node *param_10,long param_11)
{
long in_FS_OFFSET;
... |
1,599 | func0 |
#include <cassert>
#include <vector>
#include <utility>
#include <algorithm>
#include <set>
| int func0(const std::vector<std::pair<int, int>>& test_list) {
std::set<std::pair<int, int>> unique_pairs;
for(auto sub : test_list){
if(sub.first > sub.second){
std::swap(sub.first, sub.second);
}
unique_pairs.emplace(sub);
}
return unique_pairs.size();
}
... | int main() {
assert(func0({{3, 4}, {1, 2}, {4, 3}, {5, 6}}) == 3);
assert(func0({{4, 15}, {2, 3}, {5, 4}, {6, 7}}) == 4);
assert(func0({{5, 16}, {2, 3}, {6, 5}, {6, 9}}) == 4);
return 0;
}
| O3 | cpp | func0(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 $0x58,%rsp
mov (%rdi),%rbp
mov 0x8(%rdi),%r15
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x18(%rsp),%r14
movl $0x... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov r13, [rdi]
mov r15, [rdi+8]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
lea r14, [rsp+88h+var_70]
mov [rsp+88h+var_70], 0
mov [rsp+88h+... | long long func0(int **a1, int *a2)
{
int *v2; // r13
int *v3; // r15
int v4; // r12d
int v5; // ebp
_DWORD *v6; // rax
int *v7; // rbx
_DWORD *v8; // r8
int *v9; // rax
char v10; // cl
int v11; // edx
_BOOL8 v12; // rdi
int *v13; // rdx
_QWORD *v14; // rbx
unsigned int v15; // ebp
void *v... | func0:
MOV RDI,qword ptr [RSP + 0x20]
CALL 0x00101440
MOV RAX,qword ptr [RSP + 0x48]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101182
MOV RDI,RBX
LAB_0010117d:
CALL 0x00101150
LAB_00101182:
CALL 0x00101140 | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) [clone
.cold] */
void func0(vector *param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,
_Rb_tree_node *param_10,long param_11)
{
long in_FS_OFFSET;
... |
1,600 | func0 |
#include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::vector<std::tuple<int, int>> func0(const std::vector<std::tuple<int, int>>& test_tup1, const std::vector<std::tuple<int, int>>& test_tup2) {
std::vector<std::tuple<int, int>> res;
for (size_t i = 0; i < test_tup1.size(); ++i) {
int a = std::get<0>(test_tup1[i]) + std::get<0>(test_tup2[i]);
... | int main() {
assert((func0({{1, 3}, {4, 5}, {2, 9}, {1, 10}}, {{6, 7}, {3, 9}, {1, 1}, {7, 3}}) == std::vector<std::tuple<int, int>>{{7, 10}, {7, 14}, {3, 10}, {8, 13}}));
assert((func0({{2, 4}, {5, 6}, {3, 10}, {2, 11}}, {{7, 8}, {4, 10}, {2, 2}, {8, 4}}) == std::vector<std::tuple<int, int>>{{9, 12}, {9, 16}... | O0 | cpp | func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&, std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mov %fs... | _Z5func0RKSt6vectorISt5tupleIJiiEESaIS1_EES5_:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorISt... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rax
int v4; // ebx
long long v5; // rax
long long v6; // rax
int v7; // ebx
long long v8; // rax
unsigned long long v9; // rax
int v12; // [rsp+20h] [rbp-30h] BYREF
int v13; // [rsp+24h] [rbp-2Ch] BYREF
unsigned long long ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101e0a
MOV qword ptr [RBP + -0x28],0x0
JM... | /* func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&,
std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
tuple *ptVar2;
type *ptVar3;
type *ptVar4;
ulong uVar5;
vector<std... |
1,601 | func0 |
#include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::vector<std::tuple<int, int>> func0(const std::vector<std::tuple<int, int>>& test_tup1, const std::vector<std::tuple<int, int>>& test_tup2) {
std::vector<std::tuple<int, int>> res;
for (size_t i = 0; i < test_tup1.size(); ++i) {
int a = std::get<0>(test_tup1[i]) + std::get<0>(test_tup2[i]);
... | int main() {
assert((func0({{1, 3}, {4, 5}, {2, 9}, {1, 10}}, {{6, 7}, {3, 9}, {1, 1}, {7, 3}}) == std::vector<std::tuple<int, int>>{{7, 10}, {7, 14}, {3, 10}, {8, 13}}));
assert((func0({{2, 4}, {5, 6}, {3, 10}, {2, 11}}, {{7, 8}, {4, 10}, {2, 2}, {8, 4}}) == std::vector<std::tuple<int, int>>{{9, 12}, {9, 16}... | O1 | cpp | func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&, std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor... | _Z5func0RKSt6vectorISt5tupleIJiiEESaIS1_EES5_:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rbx, rdi
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rax, [rsi... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v3; // rax
unsigned long long v6; // rbp
_DWORD *v7; // rax
_DWORD *v8; // rdx
int v9; // ecx
int v10; // edx
int *v11; // rsi
_DWORD v13[2]; // [rsp+0h] [rbp-38h] BYREF
unsigned long long v14; // [rsp+8h] [rbp-30h]
v14 = __readfsqwo... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RAX,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RAX
JZ 0x001012c6
MOV R12,RSI
... | /* func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&,
std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
long lVar1;
int *piVar2;
long *in_RDX;
int *piVar3;
ulong uVar4;
long in_FS_O... |
1,602 | func0 |
#include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::vector<std::tuple<int, int>> func0(const std::vector<std::tuple<int, int>>& test_tup1, const std::vector<std::tuple<int, int>>& test_tup2) {
std::vector<std::tuple<int, int>> res;
for (size_t i = 0; i < test_tup1.size(); ++i) {
int a = std::get<0>(test_tup1[i]) + std::get<0>(test_tup2[i]);
... | int main() {
assert((func0({{1, 3}, {4, 5}, {2, 9}, {1, 10}}, {{6, 7}, {3, 9}, {1, 1}, {7, 3}}) == std::vector<std::tuple<int, int>>{{7, 10}, {7, 14}, {3, 10}, {8, 13}}));
assert((func0({{2, 4}, {5, 6}, {3, 10}, {2, 11}}, {{7, 8}, {4, 10}, {2, 2}, {8, 4}}) == std::vector<std::tuple<int, int>>{{9, 12}, {9, 16}... | O2 | cpp | func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&, std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&):
endbr64
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor... | _Z5func0RKSt6vectorISt5tupleIJiiEESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
long long v6; // rcx
long long v7; // rsi
long long v8; // rbx
long long v9; // rsi
_QWORD v11[7]; // [rsp+0h] [rbp-38h] BYREF
v11[1] = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017d0
MOV R12,R... | /* func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&,
std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int8 uVar1;
int8 uVar2;
int *piVar3;
long *in_RDX;
long lVar4;
ulong uVar5;
... |
1,603 | func0 |
#include <iostream>
#include <vector>
#include <tuple>
#include <assert.h>
| std::vector<std::tuple<int, int>> func0(const std::vector<std::tuple<int, int>>& test_tup1, const std::vector<std::tuple<int, int>>& test_tup2) {
std::vector<std::tuple<int, int>> res;
for (size_t i = 0; i < test_tup1.size(); ++i) {
int a = std::get<0>(test_tup1[i]) + std::get<0>(test_tup2[i]);
... | int main() {
assert((func0({{1, 3}, {4, 5}, {2, 9}, {1, 10}}, {{6, 7}, {3, 9}, {1, 1}, {7, 3}}) == std::vector<std::tuple<int, int>>{{7, 10}, {7, 14}, {3, 10}, {8, 13}}));
assert((func0({{2, 4}, {5, 6}, {3, 10}, {2, 11}}, {{7, 8}, {4, 10}, {2, 2}, {8, 4}}) == std::vector<std::tuple<int, int>>{{9, 12}, {9, 16}... | O3 | cpp | func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&, std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&):
endbr64
push %r14
pxor %xmm0,%xmm0
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %fs:0x28,%rax
mov ... | _Z5func0RKSt6vectorISt5tupleIJiiEESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
mov r13, rdx
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
movups xmmword ptr [rdi], xmm0
mov rdx, [rsi]
mov qword ptr... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdx
long long v6; // rcx
long long v7; // rsi
long long v8; // rbx
long long v9; // rsi
_QWORD v11[7]; // [rsp+0h] [rbp-38h] BYREF
v11[1] = __readfsqword(0x28u);
*(_OWORD *)a1 = 0LL;
v4 = *a2;
*(_QWORD *)(a1 + 16) = 0LL;
... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
MOV R13,RDX
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOVUPS xmmword ptr [RDI],XMM0
MOV RDX,qword ptr [RSI]
MOV qword ptr [RDI + 0x10],0x0
CMP qword ptr [RSI + 0x8],RDX
JZ 0x001017f0
MOV R12,R... | /* func0(std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&,
std::vector<std::tuple<int, int>, std::allocator<std::tuple<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int8 uVar1;
int8 uVar2;
int *piVar3;
long *in_RDX;
long lVar4;
ulong uVar5;
... |
1,604 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n, int r, int p) {
std::vector<int> C(r+1, 0);
C[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = std::min(i, r); j > 0; --j) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %esi,-0x48(%rbp)
mov %edx,-0x4c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x39(%rbp),%rax
mov %rax,%rdi
callq 145a <_ZNSaIiEC1Ev>
movl $0x0,-0x38(%rbp)
mov ... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 58h
mov [rbp+var_54], edi
mov [rbp+var_58], esi
mov [rbp+var_5C], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_41]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_40], 0
mov eax, [rb... | long long func0(int a1, int a2, int a3)
{
int v3; // ebx
int v4; // ebx
unsigned int v5; // ebx
int v8; // [rsp+8h] [rbp-58h] BYREF
int v9; // [rsp+Ch] [rbp-54h]
char v10; // [rsp+1Fh] [rbp-41h] BYREF
int i; // [rsp+20h] [rbp-40h] BYREF
int j; // [rsp+24h] [rbp-3Ch]
char *v13; // [rsp+28h] [rbp-38h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x58
MOV dword ptr [RBP + -0x54],EDI
MOV dword ptr [RBP + -0x58],ESI
MOV dword ptr [RBP + -0x5c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x41]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x40],0x0
... | /* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int iVar1;
int iVar2;
int4 uVar3;
int4 *puVar4;
int *piVar5;
long in_FS_OFFSET;
int local_60;
int local_5c;
allocator local_49;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_... |
1,605 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n, int r, int p) {
std::vector<int> C(r+1, 0);
C[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = std::min(i, r); j > 0; --j) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
lea 0x1(%rsi),%eax
cltq
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 121d <_Z5func0iii+0x74>
mov %edi,%r12d
mov %esi,%ebp
mov $0x0,%r8d
test %rax,%rax
je 1203 <_Z5func0iii+0x5a>
l... | _Z5func0iii:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
lea r13d, [rsi+1]
movsxd r13, r13d
mov rax, r13
shr rax, 3Dh
jnz short loc_1212
mov r12d, edi
mov ebp, esi
mov ebx, edx
mov r8d, 0
test r13, r13
jz short loc_11FB
shl r13, 2
mov rdi, r13;... | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // r13
_DWORD *v7; // r8
_DWORD *v8; // rax
_DWORD *v9; // rdx
int i; // edi
int v11; // eax
long long v12; // rsi
int *v13; // rcx
long long v14; // rsi
unsigned int v15; // ebx
v3 = a2 + 1;
if ( v3 >> 61 )
std::__throw_leng... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
LEA R13D,[RSI + 0x1]
MOVSXD R13,R13D
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101212
MOV R12D,EDI
MOV EBP,ESI
MOV EBX,EDX
MOV R8D,0x0
TEST R13,R13
JZ 0x001011fb
SHL R13,0x2
MOV RDI,R13
CALL 0x001010a0
MOV R8,RAX
LEA RDX,[RAX + R13*0x1]
LAB_001011ec:
MOV dword ptr [... | /* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int4 uVar1;
int iVar2;
int iVar3;
int4 *puVar4;
int *piVar5;
int unaff_EBX;
int unaff_EBP;
int4 *in_R8;
int4 *in_R9;
int unaff_R12D;
ulong uVar6;
ulong uVar7;
bool bVar8;
uVar6 = (ulong)(param_2 + 1);
uVar7 =... |
1,606 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n, int r, int p) {
std::vector<int> C(r+1, 0);
C[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = std::min(i, r); j > 0; --j) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
lea 0x1(%rsi),%r13d
push %r12
movslq %r13d,%r13
push %rbp
push %rbx
sub $0x8,%rsp
cmp %rax,%r13
ja 1363 <_Z5func0iii+0xe3>
test %r13,%r13
je 10c0 <_Z5func0iii.cold>
shl $0x2,%r13
mov %edi,%r12d
mov %edx,%ebx
mov ... | _Z5func0iii:
endbr64
push r13
lea r13d, [rsi+1]
push r12
movsxd r13, r13d
push rbp
mov rax, r13
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_1375
test r13, r13
jz _Z5func0iii_cold; func0(int,int,int) [clone]
shl r13, 2
mov r12d, edi
mov ebp, esi
mov ebx, edx
mov ... | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // r13
void *v7; // rax
char *v8; // rax
char *v9; // r9
int v10; // r8d
char *v11; // r10
int v12; // eax
long long v13; // rdi
char *v14; // rcx
int v15; // esi
long long v16; // rdi
int v17; // eax
unsigned int v18; // ebx
... | func0:
ENDBR64
PUSH R13
LEA R13D,[RSI + 0x1]
PUSH R12
MOVSXD R13,R13D
PUSH RBP
MOV RAX,R13
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x00101375
TEST R13,R13
JZ 0x001010e0
SHL R13,0x2
MOV R12D,EDI
MOV EBP,ESI
MOV EBX,EDX
MOV RDI,R13
CALL 0x001010c0
MOV RDX,R13
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RAX],0x1
... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int *piVar1;
int4 uVar2;
code *pcVar3;
int iVar4;
void *__s;
int4 *puVar5;
int *p... |
1,607 | func0 |
#include <vector>
#include <assert.h>
| int func0(int n, int r, int p) {
std::vector<int> C(r+1, 0);
C[0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = std::min(i, r); j > 0; --j) {
C[j] = (C[j] + C[j-1]) % p;
}
}
return C[r];
}
| int main() {
assert(func0(10, 2, 13) == 6);
assert(func0(15, 12, 43) == 25);
assert(func0(17, 9, 18) == 10);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
lea 0x1(%rsi),%r13d
push %r12
movslq %r13d,%r13
push %rbp
push %rbx
sub $0x8,%rsp
cmp %rax,%r13
ja 137b <_Z5func0iii+0xdb>
test %r13,%r13
je 10e0 <_Z5func0iii.cold>
shl $0x2,%r13
mov %edi,%r12d
mov %esi,%ebp
mov ... | _Z5func0iii:
endbr64
push r13
lea r13d, [rsi+1]
push r12
movsxd r13, r13d
push rbp
mov rax, r13
push rbx
sub rsp, 8
shr rax, 3Dh
jnz loc_1375
test r13, r13
jz _Z5func0iii_cold; func0(int,int,int) [clone]
shl r13, 2
mov r12d, edi
mov ebp, esi
mov ebx, edx
mov ... | long long func0(int a1, int a2, int a3)
{
unsigned long long v3; // r13
void *v7; // rax
char *v8; // rax
char *v9; // r9
int v10; // r8d
char *v11; // r10
int v12; // eax
long long v13; // rdi
char *v14; // rcx
int v15; // esi
long long v16; // rdi
int v17; // eax
unsigned int v18; // ebx
... | func0:
ENDBR64
PUSH R13
LEA R13D,[RSI + 0x1]
PUSH R12
MOVSXD R13,R13D
PUSH RBP
MOV RAX,R13
PUSH RBX
SUB RSP,0x8
SHR RAX,0x3d
JNZ 0x00101375
TEST R13,R13
JZ 0x001010e0
SHL R13,0x2
MOV R12D,EDI
MOV EBP,ESI
MOV EBX,EDX
MOV RDI,R13
CALL 0x001010c0
MOV RDX,R13
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV dword ptr [RAX],0x1
... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int, int) */
int4 func0(int param_1,int param_2,int param_3)
{
int *piVar1;
int4 uVar2;
code *pcVar3;
int iVar4;
void *__s;
int4 *puVar5;
int *p... |
1,608 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| bool func0(const std::string& str) {
std::regex regex("((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]"
"{2,256}\\.[a-z]"
"{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)");
if (str.empty()) {
return false;
}... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
std::cout << "All tests passed successfully." << std::endl;
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x40(%rbp),%rax
mov $0x10,%edx
lea 0x2b3b7(%rip),%rsi
mov ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov edx, 10h
lea rcx, aHttpHttpsWwwAZ; "((http|https)://)(www.)?[a-... | _BOOL8 func0(long long a1)
{
_BOOL4 v1; // ebx
_BYTE v3[40]; // [rsp+10h] [rbp-40h] BYREF
unsigned long long v4; // [rsp+38h] [rbp-18h]
v4 = __readfsqword(0x28u);
std::basic_regex<char,std::regex_traits<char>>::basic_regex(
v3,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+~#?&//=]{2,256}\\.[a-z]{2,6}\... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV EDX,0x10
LEA RCX,[0x132058]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b7f:
CALL 0x00106102
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0... | /* func0(std::string const&) */
int8 func0(string *param_1)
{
char cVar1;
bool bVar2;
int8 uVar3;
long in_FS_OFFSET;
regex local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::regex::basic_regex
(local_48,
"((http|https)://)(www.)?[a-zA-Z0-9@:%._\\+... |
1,609 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| bool func0(const std::string& str) {
std::regex regex("((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]"
"{2,256}\\.[a-z]"
"{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)");
if (str.empty()) {
return false;
}... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
std::cout << "All tests passed successfully." << std::endl;
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbx
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
mov %r12,%rdi
callq 4770 <_ZNSt6localeC1Ev@plt>
movl $0x... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push rbx
sub rsp, 50h
mov rbx, rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea r14, [rbp+var_60]
lea rdi, [rbp+var_58]; this
call __ZNSt6localeC1Ev; std::locale::... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH RBX
SUB RSP,0x50
MOV RBX,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA R14,[RBP + -0x60]
LEA RDI,[RBP + -0x58]
CALL 0x00104730
MOV qword ptr [RBP + -0x50],0x0
MOV qword ptr [RBP + -0x48],0x0
MOV ECX,0x10
LEA RDX,[0x1184cb]
LEA RSI,[RDX ... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
bool bVar3;
int iVar4;
int7 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
regex local_68 [8];
int local_60 [8];
int8 local_58;
_Sp_counted_base<(_L... | |
1,610 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| bool func0(const std::string& str) {
std::regex regex("((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]"
"{2,256}\\.[a-z]"
"{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)");
if (str.empty()) {
return false;
}... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
std::cout << "All tests passed successfully." << std::endl;
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
lea 0x8(%rsp),%rbp
mov %r12,%rdi
callq 4790... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
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
xor eax, eax... | long long func0(long long *a1)
{
long long v1; // rsi
unsigned int v2; // r14d
long long v3; // rbx
long long v4; // rdx
volatile signed __int32 *v5; // rcx
signed __int32 v6; // eax
long long v8; // rdi
long long v9; // rax
long long v10; // rdi
_BYTE v11[8]; // [rsp+0h] [rbp-70h] BYREF
_BYTE v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
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 0x00104730
LEA RDX,[0x1194cb]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,[RDX + -0x63... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int7 extraout_var;
ulong uVar5;
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 ... |
1,611 | func0 |
#include <iostream>
#include <regex>
#include <cassert>
| bool func0(const std::string& str) {
std::regex regex("((http|https)://)(www.)?"
"[a-zA-Z0-9@:%._\\+~#?&//=]"
"{2,256}\\.[a-z]"
"{2,6}\\b([-a-zA-Z0-9@:%"
"._\\+~#?&//=]*)");
if (str.empty()) {
return false;
}... | int main() {
assert(func0("https://www.google.com") == true);
assert(func0("https:/www.gmail.com") == false);
assert(func0("https:// www.redit.com") == false);
std::cout << "All tests passed successfully." << std::endl;
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
sub $0x58,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r12
lea 0x8(%rsp),%rbp
mov %r12,%rdi
callq 47f0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
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
xor eax, eax... | long long func0(long long *a1)
{
long long v1; // rsi
unsigned int v2; // r14d
long long v3; // rbx
long long v4; // rdx
volatile signed __int32 *v5; // rcx
signed __int32 v6; // eax
long long v8; // rdi
long long v9; // rax
long long v10; // rdi
_BYTE v11[8]; // [rsp+0h] [rbp-70h] BYREF
_BYTE v1... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
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 0x00104790
LEA RDX,[0x11a4cb]
PXOR XMM0,XMM0
MOV RDI,R13
MOV ECX,0x10
LEA RSI,[RDX + -0x63... | /* func0(std::string const&) */
ulong func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
bool bVar3;
int iVar4;
int7 extraout_var;
ulong uVar5;
long in_FS_OFFSET;
regex local_78 [8];
int local_70 [8];
int local_68 [16];
match_results local_58 [16];
int local_48 [16... |
1,612 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x4(%rbp),%eax
cmp -0x8(%rbp),%eax
jg 1164 <_Z5func0ii+0x1b>
mov -0x4(%rbp),%eax
jmp 1167 <_Z5func0ii+0x1e>
mov -0x8(%rbp),%eax
pop %rbp
retq
| _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_4]
cmp eax, [rbp+var_8]
jg short loc_1164
mov eax, [rbp+var_4]
jmp short loc_1167
loc_1164:
mov eax, [rbp+var_8]
loc_1167:
pop rbp
retn | long long func0(unsigned int a1, unsigned int a2)
{
if ( (int)a1 > (int)a2 )
return a2;
else
return a1;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x4]
CMP EAX,dword ptr [RBP + -0x8]
JG 0x00101164
MOV EAX,dword ptr [RBP + -0x4]
JMP 0x00101167
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x8]
LAB_00101167:
POP RBP
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
1,613 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
| _Z5func0ii:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
1,614 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| _Z5func0ii:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
1,615 | func0 |
#include <assert.h>
| int func0(int a, int b) {
if (a <= b) {
return a;
} else {
return b;
}
}
| int main() {
assert(func0(1, 2) == 1);
assert(func0(-5, -4) == -5);
assert(func0(0, 0) == 0);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
cmp %esi,%edi
mov %esi,%eax
cmovle %edi,%eax
retq
nopl 0x0(%rax)
| _Z5func0ii:
endbr64
cmp edi, esi
mov eax, esi
cmovle eax, edi
retn | long long func0(unsigned int a1, unsigned int a2)
{
long long result; // rax
result = a2;
if ( (int)a1 <= (int)a2 )
return a1;
return result;
} | func0:
ENDBR64
CMP EDI,ESI
MOV EAX,ESI
CMOVLE EAX,EDI
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
if (param_1 <= param_2) {
param_2 = param_1;
}
return param_2;
} |
1,616 | func0 |
#include <vector>
#include <cassert>
| bool func0(const std::vector<char>& tuplex, char tuple1) {
for (auto& item : tuplex) {
if (item == tuple1) {
return true;
}
}
return false;
}
| int main() {
std::vector<char> tuplex = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O0 | cpp | func0(std::vector<char, std::allocator<char> > const&, char):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,%eax
mov %al,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov ... | _Z5func0RKSt6vectorIcSaIcEEc:
endbr64
push rbp
mov rbp, rsp
sub rsp, 40h
mov [rbp+var_38], rdi
mov eax, esi
mov [rbp+var_3C], al
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZN... | long long func0(long long a1, char a2)
{
long long v3; // [rsp+18h] [rbp-28h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-20h] BYREF
_BYTE *v5; // [rsp+30h] [rbp-10h]
unsigned long long v6; // [rsp+38h] [rbp-8h]
v6 = __readfsqword(0x28u);
v4[1] = a1;
v3 = std::vector<char>::begin(a1);
v4[0] = std::vector<ch... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV EAX,ESI
MOV byte ptr [RBP + -0x3c],AL
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x0010147a
MO... | /* func0(std::vector<char, std::allocator<char> > const&, char) */
int8 func0(vector *param_1,char param_2)
{
bool bVar1;
int8 uVar2;
long in_FS_OFFSET;
int8 local_30;
int8 local_28;
vector<char,std::allocator<char>> *local_20;
char *local_18;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x... |
1,617 | func0 |
#include <vector>
#include <cassert>
| bool func0(const std::vector<char>& tuplex, char tuple1) {
for (auto& item : tuplex) {
if (item == tuple1) {
return true;
}
}
return false;
}
| int main() {
std::vector<char> tuplex = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O1 | cpp | func0(std::vector<char, std::allocator<char> > const&, char):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
je 11cd <_Z5func0RKSt6vectorIcSaIcEEc+0x24>
cmp %sil,(%rax)
je 11d3 <_Z5func0RKSt6vectorIcSaIcEEc+0x2a>
add $0x1,%rax
cmp %rax,%rdx
jne 11b9 <_Z5func0RKSt6vectorIcSaIcEEc+0... | _Z5func0RKSt6vectorIcSaIcEEc:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jz short loc_11CD
loc_11B9:
cmp [rax], sil
jz short loc_11D3
add rax, 1
cmp rdx, rax
jnz short loc_11B9
mov eax, 0
retn
loc_11CD:
mov eax, 0
retn
loc_11D3:
mov eax, 1
retn | long long func0(long long a1, char a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rdx
v2 = *(_BYTE **)a1;
v3 = *(_BYTE **)(a1 + 8);
if ( v3 == *(_BYTE **)a1 )
return 0LL;
while ( *v2 != a2 )
{
if ( v3 == ++v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JZ 0x001011cd
LAB_001011b9:
CMP byte ptr [RAX],SIL
JZ 0x001011d3
ADD RAX,0x1
CMP RDX,RAX
JNZ 0x001011b9
MOV EAX,0x0
RET
LAB_001011cd:
MOV EAX,0x0
RET
LAB_001011d3:
MOV EAX,0x1
RET | /* func0(std::vector<char, std::allocator<char> > const&, char) */
int8 func0(vector *param_1,char param_2)
{
char *pcVar1;
pcVar1 = *(char **)param_1;
if (*(char **)(param_1 + 8) == pcVar1) {
return 0;
}
do {
if (*pcVar1 == param_2) {
return 1;
}
pcVar1 = pcVar1 + 1;
} while (*(c... |
1,618 | func0 |
#include <vector>
#include <cassert>
| bool func0(const std::vector<char>& tuplex, char tuple1) {
for (auto& item : tuplex) {
if (item == tuple1) {
return true;
}
}
return false;
}
| int main() {
std::vector<char> tuplex = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O2 | cpp | func0(std::vector<char, std::allocator<char> > const&, char):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 12a1 <_Z5func0RKSt6vectorIcSaIcEEc+0x21>
jmp 12b0 <_Z5func0RKSt6vectorIcSaIcEEc+0x30>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rax,%rdx
je 12b0 <_Z5func0RKSt6vectorIcSaIc... | _Z5func0RKSt6vectorIcSaIcEEc:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_1291
jmp short loc_12A0
loc_1288:
add rax, 1
cmp rdx, rax
jz short loc_12A0
loc_1291:
cmp [rax], sil
jnz short loc_1288
mov eax, 1
retn
loc_12A0:
xor eax, eax
retn | long long func0(long long a1, char a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rdx
v2 = *(_BYTE **)a1;
v3 = *(_BYTE **)(a1 + 8);
if ( v3 == *(_BYTE **)a1 )
return 0LL;
while ( *v2 != a2 )
{
if ( v3 == ++v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x00101291
JMP 0x001012a0
LAB_00101288:
ADD RAX,0x1
CMP RDX,RAX
JZ 0x001012a0
LAB_00101291:
CMP byte ptr [RAX],SIL
JNZ 0x00101288
MOV EAX,0x1
RET
LAB_001012a0:
XOR EAX,EAX
RET | /* func0(std::vector<char, std::allocator<char> > const&, char) */
int8 func0(vector *param_1,char param_2)
{
char *pcVar1;
pcVar1 = *(char **)param_1;
while( true ) {
if (*(char **)(param_1 + 8) == pcVar1) {
return 0;
}
if (*pcVar1 == param_2) break;
pcVar1 = pcVar1 + 1;
}
return 1... |
1,619 | func0 |
#include <vector>
#include <cassert>
| bool func0(const std::vector<char>& tuplex, char tuple1) {
for (auto& item : tuplex) {
if (item == tuple1) {
return true;
}
}
return false;
}
| int main() {
std::vector<char> tuplex = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuplex, 'r') == true);
assert(func0(tuplex, '5') == false);
assert(func0(tuplex, '3') == true);
return 0;
}
| O3 | cpp | func0(std::vector<char, std::allocator<char> > const&, char):
endbr64
mov (%rdi),%rax
mov 0x8(%rdi),%rdx
cmp %rdx,%rax
jne 1361 <_Z5func0RKSt6vectorIcSaIcEEc+0x21>
jmp 1370 <_Z5func0RKSt6vectorIcSaIcEEc+0x30>
nopw 0x0(%rax,%rax,1)
add $0x1,%rax
cmp %rax,%rdx
je 1370 <_Z5func0RKSt6vectorIcSaIc... | _Z5func0RKSt6vectorIcSaIcEEc:
endbr64
mov rax, [rdi]
mov rdx, [rdi+8]
cmp rdx, rax
jnz short loc_11D1
jmp short loc_11E0
loc_11C8:
add rax, 1
cmp rdx, rax
jz short loc_11E0
loc_11D1:
cmp [rax], sil
jnz short loc_11C8
mov eax, 1
retn
loc_11E0:
xor eax, eax
retn | long long func0(long long a1, char a2)
{
_BYTE *v2; // rax
_BYTE *v3; // rdx
v2 = *(_BYTE **)a1;
v3 = *(_BYTE **)(a1 + 8);
if ( v3 == *(_BYTE **)a1 )
return 0LL;
while ( *v2 != a2 )
{
if ( v3 == ++v2 )
return 0LL;
}
return 1LL;
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
CMP RDX,RAX
JNZ 0x001011d1
JMP 0x001011e0
LAB_001011c8:
ADD RAX,0x1
CMP RDX,RAX
JZ 0x001011e0
LAB_001011d1:
CMP byte ptr [RAX],SIL
JNZ 0x001011c8
MOV EAX,0x1
RET
LAB_001011e0:
XOR EAX,EAX
RET | /* func0(std::vector<char, std::allocator<char> > const&, char) */
int8 func0(vector *param_1,char param_2)
{
char *pcVar1;
pcVar1 = *(char **)param_1;
while( true ) {
if (*(char **)(param_1 + 8) == pcVar1) {
return 0;
}
if (*pcVar1 == param_2) break;
pcVar1 = pcVar1 + 1;
}
return 1... |
1,620 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(func0(12) == "Even Parity");
assert(func0(7) == "Odd Parity");
assert(func0(10) == "Even Parity");
return 0;
}
| O0 | cpp | func0[abi:cxx11](unsigned int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x2c(%rbp),%eax
shr %eax
xor -0x2c(%rbp),%eax
mov %eax,-0x1c(%rbp)
mov -0x1c(%rbp),%eax
shr... | _Z5func0B5cxx11j:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 38h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_3C]
shr eax, 1
xor eax, [rbp+var_3C]
mov [rbp+var_2C], eax
mov eax, [rbp+var_2C]
sh... | long long func0[abi:cxx11](long long a1, unsigned int a2)
{
char v3; // [rsp+13h] [rbp-2Dh] BYREF
unsigned int v4; // [rsp+14h] [rbp-2Ch]
char *v5; // [rsp+18h] [rbp-28h]
char *v6; // [rsp+20h] [rbp-20h]
unsigned long long v7; // [rsp+28h] [rbp-18h]
v7 = __readfsqword(0x28u);
v4 = ((a2 ^ (a2 >> 1)) >> 2... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x38
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x3c]
SHR EAX,0x1
XOR EAX,dword ptr [RBP + -0x3c]
MOV dword ptr [RBP + -0x2c],EAX
MOV EAX... | /* func0[abi:cxx11](unsigned int) */
string * func0_abi_cxx11_(uint param_1)
{
uint in_ESI;
int4 in_register_0000003c;
string *this;
long in_FS_OFFSET;
allocator local_35;
uint local_34;
allocator *local_30;
allocator *local_28;
long local_20;
this = (string *)CONCAT44(in_register_0000003c,para... |
1,621 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(func0(12) == "Even Parity");
assert(func0(7) == "Odd Parity");
assert(func0(10) == "Even Parity");
return 0;
}
| O1 | cpp | func0[abi:cxx11](unsigned int):
endbr64
push %rbx
mov %rdi,%rbx
mov %esi,%eax
shr %eax
xor %eax,%esi
mov %esi,%eax
shr $0x2,%eax
xor %esi,%eax
mov %eax,%esi
shr $0x4,%esi
xor %esi,%eax
mov %eax,%esi
shr $0x8,%esi
xor %eax,%esi
mov %esi,%eax
shr $0x10,%eax
xor %eax,%esi
... | _Z5func0B5cxx11j:
endbr64
push rbx
mov rbx, rdi
mov edx, esi
shr edx, 1
xor edx, esi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
test al, 1
jz ... | _QWORD * func0[abi:cxx11](_QWORD *a1, unsigned int a2)
{
*a1 = a1 + 2;
if ( (((unsigned __int8)((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2)) >> 4) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2)) >> 4)) >> 8)) >> 16) ^ (unsigned __... | func0[abi:cxx11]:
ENDBR64
PUSH RBX
MOV RBX,RDI
MOV EDX,ESI
SHR EDX,0x1
XOR EDX,ESI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
TEST AL,0x1
JZ 0x00101253
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x10200e]
LE... | /* func0[abi:cxx11](unsigned int) */
int8 func0_abi_cxx11_(uint param_1)
{
uint uVar1;
uint in_ESI;
int4 in_register_0000003c;
uVar1 = in_ESI >> 1 ^ in_ESI;
uVar1 = uVar1 >> 2 ^ uVar1;
uVar1 = uVar1 >> 4 ^ uVar1;
uVar1 = uVar1 >> 8 ^ uVar1;
if (((uVar1 ^ uVar1 >> 0x10) & 1) == 0) {
*(long *)CON... |
1,622 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(func0(12) == "Even Parity");
assert(func0(7) == "Odd Parity");
assert(func0(10) == "Even Parity");
return 0;
}
| O2 | cpp | func0[abi:cxx11](unsigned int):
endbr64
mov %esi,%edx
lea 0x10(%rdi),%rcx
mov %rdi,%rax
shr %edx
mov %rcx,(%rdi)
xor %edx,%esi
mov %esi,%edx
shr $0x2,%edx
xor %esi,%edx
mov %edx,%esi
shr $0x4,%esi
xor %esi,%edx
mov %edx,%esi
shr $0x8,%esi
xor %edx,%esi
mov %esi,%edx
shr ... | _Z5func0B5cxx11j:
endbr64
mov edx, esi
push rbx
mov rbx, rdi
shr edx, 1
xor edx, esi
mov eax, edx
shr eax, 2
xor eax, edx
mov edx, eax
shr edx, 4
xor edx, eax
mov eax, edx
shr eax, 8
xor eax, edx
mov edx, eax
shr edx, 10h
xor eax, edx
test al, 1
lea ... | _QWORD * func0[abi:cxx11](_QWORD *a1, unsigned int a2)
{
*a1 = a1 + 2;
if ( (((unsigned __int8)((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2)) >> 4) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2)) >> 4)) >> 8)) >> 16) ^ (unsigned __... | func0[abi:cxx11]:
ENDBR64
MOV EDX,ESI
PUSH RBX
MOV RBX,RDI
SHR EDX,0x1
XOR EDX,ESI
MOV EAX,EDX
SHR EAX,0x2
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x4
XOR EDX,EAX
MOV EAX,EDX
SHR EAX,0x8
XOR EAX,EDX
MOV EDX,EAX
SHR EDX,0x10
XOR EAX,EDX
TEST AL,0x1
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
JZ 0x00101430
LEA RDX,[0x10200e]
LE... | /* func0[abi:cxx11](unsigned int) */
int8 func0_abi_cxx11_(uint param_1)
{
uint uVar1;
uint in_ESI;
int4 in_register_0000003c;
uVar1 = in_ESI >> 1 ^ in_ESI;
uVar1 = uVar1 >> 2 ^ uVar1;
uVar1 = uVar1 >> 4 ^ uVar1;
uVar1 = uVar1 >> 8 ^ uVar1;
*(long *)CONCAT44(in_register_0000003c,param_1) = CONCAT44... |
1,623 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| std::string func0(unsigned int x) {
unsigned int y = x ^ (x >> 1);
y = y ^ (y >> 2);
y = y ^ (y >> 4);
y = y ^ (y >> 8);
y = y ^ (y >> 16);
if (y & 1) {
return "Odd Parity";
}
return "Even Parity";
}
| int main() {
assert(func0(12) == "Even Parity");
assert(func0(7) == "Odd Parity");
assert(func0(10) == "Even Parity");
return 0;
}
| O3 | cpp | func0[abi:cxx11](unsigned int):
endbr64
mov %esi,%edx
lea 0x10(%rdi),%rcx
mov %rdi,%rax
shr %edx
mov %rcx,(%rdi)
xor %edx,%esi
mov %esi,%edx
shr $0x2,%edx
xor %esi,%edx
mov %edx,%esi
shr $0x4,%esi
xor %esi,%edx
mov %edx,%esi
shr $0x8,%esi
xor %edx,%esi
mov %esi,%edx
shr ... | _Z5func0B5cxx11j:
endbr64
mov ecx, esi
mov rax, rdi
shr ecx, 1
xor ecx, esi
mov edx, ecx
shr edx, 2
xor edx, ecx
mov ecx, edx
shr ecx, 4
xor ecx, edx
mov edx, ecx
shr edx, 8
xor edx, ecx
mov ecx, edx
shr ecx, 10h
xor edx, ecx
and edx, 1
lea rdx, [r... | long long func0[abi:cxx11](long long a1, unsigned int a2)
{
long long result; // rax
result = a1;
*(_QWORD *)a1 = a1 + 16;
if ( (((unsigned __int8)((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2)) >> 4) ^ ((a2 ^ (a2 >> 1) ^ ((a2 ^ (a2 >> 1)) >> 2) ^ ((a2 ^ (a2 >> 1) ^ ((... | func0[abi:cxx11]:
ENDBR64
MOV ECX,ESI
MOV RAX,RDI
SHR ECX,0x1
XOR ECX,ESI
MOV EDX,ECX
SHR EDX,0x2
XOR EDX,ECX
MOV ECX,EDX
SHR ECX,0x4
XOR ECX,EDX
MOV EDX,ECX
SHR EDX,0x8
XOR EDX,ECX
MOV ECX,EDX
SHR ECX,0x10
XOR EDX,ECX
AND EDX,0x1
LEA RDX,[RDI + 0x10]
MOV qword ptr [RDI],RDX
JZ 0x00101390
MOV RDI,0x697261502064644f
MOV... | /* func0[abi:cxx11](unsigned int) */
void func0_abi_cxx11_(uint param_1)
{
uint uVar1;
uint in_ESI;
int4 in_register_0000003c;
long *plVar2;
plVar2 = (long *)CONCAT44(in_register_0000003c,param_1);
uVar1 = in_ESI >> 1 ^ in_ESI;
uVar1 = uVar1 >> 2 ^ uVar1;
uVar1 = uVar1 >> 4 ^ uVar1;
uVar1 = uVar1... |
1,624 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(int n) {
std::string nums = std::to_string(n);
for (int i = nums.length() - 2; i >= 0; --i) {
if (nums[i] < nums[i+1]) {
std::string z = nums.substr(i);
char y = *std::min_element(z.begin() + 1, z.end(), [z](char a, char b) { return a > z[0] && (a < b || b <= z[0])... | int main() {
assert(func0(12) == 21);
assert(func0(10) == false);
assert(func0(102) == 120);
return 0;
}
| O0 | cpp | func0(int)::{lambda(char, char)#1}::operator()(char, char) const:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x18(%rbp)
mov %esi,%ecx
mov %edx,%eax
mov %ecx,%edx
mov %dl,-0x1c(%rbp)
mov %al,-0x20(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x18(%rbp),%rax
m... | _ZZ5func0iENKUlccE_clEcc:
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov ecx, esi
mov eax, edx
mov edx, ecx
mov [rbp+var_C], dl
mov [rbp+var_10], al
mov rax, [rbp+var_8]
mov esi, 0
mov rdi, rax
call __ZNKSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEixE... | _BOOL8 func0(int)::{lambda(char,char)#1}::operator()(long long a1, char a2, char a3)
{
return a2 > *(char *)std::string::operator[](a1, 0LL) && (a2 < a3 || a3 <= *(char *)std::string::operator[](a1, 0LL));
} | ~func0:
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00102230
NOP
LEAVE
RET | /* ~func0() */
void __thiscall func0(int)::{lambda(char,char)#1}::~func0(_lambda_char_char__1_ *this)
{
std::string::~string((string *)this);
return;
} |
1,625 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(int n) {
std::string nums = std::to_string(n);
for (int i = nums.length() - 2; i >= 0; --i) {
if (nums[i] < nums[i+1]) {
std::string z = nums.substr(i);
char y = *std::min_element(z.begin() + 1, z.end(), [z](char a, char b) { return a > z[0] && (a < b || b <= z[0])... | int main() {
assert(func0(12) == 21);
assert(func0(10) == false);
assert(func0(102) == 120);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0xe8,%rsp
mov %edi,%r8d
mov %fs:0x28,%rax
mov %rax,0xd8(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rdi
lea 0x1c96(%rip),%rcx
mov $0x10,%edx
mov 0x3c28(%rip),%rsi
callq 1dc2 <_ZN9__gnu_cxx12__to_xstringINSt7__cxx1112basic_strin... | _Z5func0i:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 1B8h
mov rax, fs:28h
mov [rsp+1D8h+var_30], rax
xor eax, eax
mov r12d, edi
shr r12d, 1Fh
mov ebp, edi
neg ebp
cmovs ebp, edi
cmp ebp, 9
jbe loc_22F3
cmp ebp, 63h ; 'c'
jbe short loc_140A
cmp ... | long long func0(int a1)
{
unsigned int v1; // r12d
unsigned int v2; // ebp
unsigned int v3; // eax
unsigned int v4; // ebx
unsigned int v5; // edx
char *v6; // r12
int v7; // ebp
char v8; // bp
size_t v9; // rbx
char *v10; // rax
long long v11; // rbx
unsigned int v13; // eax
unsigned int v14... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
MOV R12D,EDI
SHR R12D,0x1f
MOV EBP,EDI
NEG EBP
CMOVS EBP,EDI
CMP EBP,0x9
JBE 0x001022f3
CMP EBP,0x63
JBE 0x0010140a
CMP EBP,0x3e7
JBE 0x001016b4
CMP EBP,0x270f
JBE 0x00101914
MOV EAX,... | /* func0(int) */
ulong func0(int 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,
int8 param_10,int8 param_11,int8 param_12,int8 param_13,
int8 param_14,int8 param_15,int8 param_16,int8 param_17,
int8 param_18,int8 ... |
1,626 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(int n) {
std::string nums = std::to_string(n);
for (int i = nums.length() - 2; i >= 0; --i) {
if (nums[i] < nums[i+1]) {
std::string z = nums.substr(i);
char y = *std::min_element(z.begin() + 1, z.end(), [z](char a, char b) { return a > z[0] && (a < b || b <= z[0])... | int main() {
assert(func0(12) == 21);
assert(func0(10) == false);
assert(func0(102) == 120);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r15
mov %edi,%r8d
mov $0x10,%edx
lea 0x1b4d(%rip),%rcx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x108,%rsp
mov 0x3ad5(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0xf8(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rdi
callq 1ec0 <_ZN9__gnu_cxx12__to_xstring... | _Z5func0i:
endbr64
push r15
mov ecx, edi
push r14
shr ecx, 1Fh
push r13
movzx r14d, cl
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 1F8h
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
neg ebp
cmovs ebp, edi
mov edi, ecx
cmp ebp, 9
jbe loc_26... | long long func0(int a1)
{
unsigned int v1; // ecx
_BOOL8 v2; // r14
unsigned int v3; // ebp
long long v4; // rbx
int v5; // eax
unsigned int v6; // r12d
__int8 *v7; // rcx
long long v8; // rdx
unsigned long long v9; // rdx
int v10; // eax
unsigned int v11; // esi
long long v12; // rax
long lo... | func0:
ENDBR64
PUSH R15
MOV ECX,EDI
PUSH R14
SHR ECX,0x1f
PUSH R13
MOVZX R14D,CL
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x1f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
NEG EBP
CMOVS EBP,EDI
MOV EDI,ECX
CMP EBP,0x9
JBE 0x0010261b
CMP EBP,0x63
JBE 0x00102105
CMP EBP,0x3e7
JBE 0x00102... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
ulong func0(int param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int8 param_7,int param_8,int8 param_9,
int8 param_10,int8 param_11,int1 param_12,int8 param_13,
int... |
1,627 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cassert>
| int func0(int n) {
std::string nums = std::to_string(n);
for (int i = nums.length() - 2; i >= 0; --i) {
if (nums[i] < nums[i+1]) {
std::string z = nums.substr(i);
char y = *std::min_element(z.begin() + 1, z.end(), [z](char a, char b) { return a > z[0] && (a < b || b <= z[0])... | int main() {
assert(func0(12) == 21);
assert(func0(10) == false);
assert(func0(102) == 120);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r15
mov %edi,%r8d
mov $0x10,%edx
lea 0x193f(%rip),%rcx
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x108,%rsp
mov 0x38f5(%rip),%rsi
mov %fs:0x28,%rax
mov %rax,0xf8(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%rdi
callq 14f0 <_ZN9__gnu_cxx12__to_xstring... | _Z5func0i:
endbr64
push r15
mov ecx, edi
push r14
shr ecx, 1Fh
push r13
movzx r13d, cl
push r12
push rbp
mov ebp, edi
push rbx
sub rsp, 1F8h
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
neg ebp
cmovs ebp, edi
mov edi, ecx
cmp ebp, 9
jbe loc_27... | long long func0(int a1)
{
unsigned int v1; // ecx
_BOOL8 v2; // r13
unsigned int v3; // ebp
long long v4; // rbx
int v5; // esi
unsigned int v6; // r12d
long long v7; // rsi
long long v8; // rdx
__int8 *v9; // rcx
unsigned long long v10; // rdx
int v11; // eax
unsigned int v12; // esi
long lo... | func0:
ENDBR64
PUSH R15
MOV ECX,EDI
PUSH R14
SHR ECX,0x1f
PUSH R13
MOVZX R13D,CL
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB RSP,0x1f8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
NEG EBP
CMOVS EBP,EDI
MOV EDI,ECX
CMP EBP,0x9
JBE 0x0010276b
CMP EBP,0x63
JBE 0x00101d58
CMP EBP,0x3e7
JBE 0x00102... | /* WARNING: Type propagation algorithm not settling */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* WARNING: Restarted to delay deadcode elimination for space: stack */
/* func0(int) */
ulong func0(int param_1,int param_2,int param_3,int param_4,int param_5,
int pa... |
1,628 | func0 | #include <vector>
#include <queue>
#include <tuple>
#include <cassert>
using namespace std;
| vector<vector<int>> func0(const vector<int>& nums1, const vector<int>& nums2, int k) {
// min-heap: (sum, i, j)
typedef tuple<int, int, int> Node;
priority_queue<Node, vector<Node>, greater<Node>> heap;
auto push = [&](int i, int j) {
if (i < nums1.size() && j < nums2.size()) {
... | int main() {
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 2);
vector<vector<int>> expected = {{1, 2}, {1, 4}};
assert(result == expected);
}
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 1);
vector<vector<int>> expected = {{1, 2}};
... | O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, int)::{lambda(int, int)#1}::operator()(int, int) const:
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x20,%rsp
mov %rdi,-0x28(%rbp)
mov %esi,-0x2c(%rbp)
mov %edx,-0x30(%rbp)
mov %fs:0x28,%rax
... | _ZZ5func0RKSt6vectorIiSaIiEES3_iENKUliiE_clEii:
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 20h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov [rbp+var_30], edx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov eax, [rbp+var_2C]
movsxd rbx, eax
mov rax, [rbp+... | unsigned long long func0(std::vector<int> const&,std::vector<int> const&,int)::{lambda(int,int)#1}::operator()(
_QWORD *a1,
int a2,
int a3)
{
long long v4; // rbx
int v5; // r12d
int v7; // [rsp+0h] [rbp-30h] BYREF
int v8; // [rsp+4h] [rbp-2Ch] BYREF
_QWORD *v9; // [rsp+8h] [rbp-28h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0xd8
MOV qword ptr [RBP + -0xd8],RDI
MOV qword ptr [RBP + -0xe0],RSI
MOV qword ptr [RBP + -0xe8],RDX
MOV dword ptr [RBP + -0xec],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x001... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, int) */
vector * func0(vector *param_1,vector *param_2,int param_3)
{
bool bVar1;
char cVar2;
int8 *puVar3;
int4 *puVar4;
ulong uVar5;
int in_ECX;
int4 in_register_00000014;
long in_FS_OFFSET;
_... |
1,629 | func0 | #include <vector>
#include <queue>
#include <tuple>
#include <cassert>
using namespace std;
| vector<vector<int>> func0(const vector<int>& nums1, const vector<int>& nums2, int k) {
// min-heap: (sum, i, j)
typedef tuple<int, int, int> Node;
priority_queue<Node, vector<Node>, greater<Node>> heap;
auto push = [&](int i, int j) {
if (i < nums1.size() && j < nums2.size()) {
... | int main() {
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 2);
vector<vector<int>> expected = {{1, 2}, {1, 4}};
assert(result == expected);
}
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 1);
vector<vector<int>> expected = {{1, 2}};
... | O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,%rbx
mov %rsi,%r12
mov %rdx,%r15
mov %ecx,%ebp
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor ... | _Z5func0RKSt6vectorIiSaIiEES3_i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0A8h
mov rbx, rdi
mov r12, rsi
mov r15, rdx
mov ebp, ecx
mov rax, fs:28h
mov [rsp+0D8h+var_40], rax
xor eax, eax
mov [rsp+0D8h+var_68], 0
mov [rsp+0D8h+var_60... | _QWORD * func0(_QWORD *a1, long long a2, _DWORD **a3, int a4)
{
_DWORD *v8; // rdx
void *v9; // kr00_8
int v10; // eax
unsigned long long *v11; // rdx
unsigned long long **v12; // rsi
char *v13; // r13
char *v14; // rdi
int v15; // r14d
int v16; // ebp
unsigned long long *v17; // rax
unsigned long... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xa8
MOV RBX,RDI
MOV R12,RSI
MOV R15,RDX
MOV EBP,ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x98],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x70],0x0
MOV qword ptr [RSP + 0x78],0x0
MOV qword ptr [RSP + 0x80],0x0
MOV dword ptr [RSP + 0x20]... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, int) */
vector * func0(vector *param_1,vector *param_2,int param_3)
{
int iVar1;
int iVar2;
int4 uVar3;
int4 uVar4;
int8 *puVar5;
int *piVar6;
int in_ECX;
int4 in_register_00000014;
long *plVar7... |
1,630 | func0 | #include <vector>
#include <queue>
#include <tuple>
#include <cassert>
using namespace std;
| vector<vector<int>> func0(const vector<int>& nums1, const vector<int>& nums2, int k) {
// min-heap: (sum, i, j)
typedef tuple<int, int, int> Node;
priority_queue<Node, vector<Node>, greater<Node>> heap;
auto push = [&](int i, int j) {
if (i < nums1.size() && j < nums2.size()) {
... | int main() {
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 2);
vector<vector<int>> expected = {{1, 2}, {1, 4}};
assert(result == expected);
}
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 1);
vector<vector<int>> expected = {{1, 2}};
... | O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdx,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
mov (%rsi),%... | _Z5func0RKSt6vectorIiSaIiEES3_i:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdx
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 0D8h
mov [rsp+108h+var_EC], ecx
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
mov [rsp+108h+va... | long long func0(long long a1, char **a2, _DWORD **a3, int a4)
{
char *v6; // rax
_DWORD *v7; // rdx
char *v8; // rbx
char *v9; // rbp
char *v10; // r15
char *v11; // rdx
unsigned long long *v12; // rax
_QWORD *v13; // rdx
unsigned long long **v14; // rsi
_QWORD *v15; // rsi
char *v16; // rcx
si... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV dword ptr [RSP + 0x1c],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x48],0x0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP + 0xb0],0x0... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, int) */
vector * func0(vector *param_1,vector *param_2,int param_3)
{
long lVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
int4 uVar6;
int4 uVar7;
int iVar8;
int iVar9;
int8 *puVar10;
... |
1,631 | func0 | #include <vector>
#include <queue>
#include <tuple>
#include <cassert>
using namespace std;
| vector<vector<int>> func0(const vector<int>& nums1, const vector<int>& nums2, int k) {
// min-heap: (sum, i, j)
typedef tuple<int, int, int> Node;
priority_queue<Node, vector<Node>, greater<Node>> heap;
auto push = [&](int i, int j) {
if (i < nums1.size() && j < nums2.size()) {
... | int main() {
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 2);
vector<vector<int>> expected = {{1, 2}, {1, 4}};
assert(result == expected);
}
{
vector<vector<int>> result = func0({1, 3, 7}, {2, 4, 6}, 1);
vector<vector<int>> expected = {{1, 2}};
... | O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&, int):
endbr64
push %r15
mov %rdi,%r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdx,0x18(%rsp)
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
mov (%rsi),%... | _Z5func0RKSt6vectorIiSaIiEES3_i:
endbr64
push r15
pxor xmm0, xmm0
push r14
mov r14, rdx
push r13
mov r13, rsi
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 0D8h
mov [rsp+108h+var_EC], ecx
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor eax, eax
mov [rsp+108h+va... | long long func0(long long a1, char **a2, _DWORD **a3, int a4)
{
char *v6; // rax
_DWORD *v7; // rdx
char *v8; // rbx
char *v9; // rbp
char *v10; // r15
char *v11; // rdx
unsigned long long *v12; // rax
_QWORD *v13; // rdx
unsigned long long **v14; // rsi
_QWORD *v15; // rsi
char *v16; // rcx
si... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
MOV R14,RDX
PUSH R13
MOV R13,RSI
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV dword ptr [RSP + 0x1c],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
MOV dword ptr [RSP + 0x48],0x0
MOV RAX,qword ptr [RSI]
MOV qword ptr [RSP + 0xb0],0x0... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&, int) */
vector * func0(vector *param_1,vector *param_2,int param_3)
{
long lVar1;
int *piVar2;
int *piVar3;
int iVar4;
int iVar5;
int4 uVar6;
int4 uVar7;
int iVar8;
int iVar9;
int8 *puVar10;
... |
1,632 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(std::vector<std::pair<int, int>> list1) {
std::vector<int> products;
for (auto p : list1) {
products.push_back(abs(p.first * p.second));
}
return *std::min_element(products.begin(), products.end());
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 8);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 30);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 100);
return 0;
}
| O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x68,%rsp
mov %rdi,-0x68(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x30(%rbp),%rax
mov %rax,%rdi
callq 1790 <_ZNSt6vectorIiSaIiEEC1Ev>
mov ... | _Z5func0St6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 68h
mov [rbp+var_68], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEEC2Ev; std::vector<int>::vector(void)
mov rax, [rbp+... | long long func0(long long a1)
{
int v1; // eax
long long v2; // rbx
long long v3; // rax
int v5; // [rsp+1Ch] [rbp-54h] BYREF
long long v6; // [rsp+20h] [rbp-50h] BYREF
_QWORD v7[2]; // [rsp+28h] [rbp-48h] BYREF
long long v8; // [rsp+38h] [rbp-38h] BYREF
_BYTE v9[24]; // [rsp+40h] [rbp-30h] BYREF
uns... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x30]
MOV RDI,RAX
CALL 0x001017ac
MOV RAX,qword ptr [RBP + -0x68]
MOV qword ptr [RBP + -0x40],RAX
MOV RAX,qword ptr [RBP + -0x40]
MOV RDI,RAX
... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
int4 func0(vector param_1)
{
int4 uVar1;
bool bVar2;
int8 *puVar3;
int8 uVar4;
int8 uVar5;
int4 *puVar6;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_5c;
int8 local_58;
int8 local_50;
vector<std::pa... |
1,633 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(std::vector<std::pair<int, int>> list1) {
std::vector<int> products;
for (auto p : list1) {
products.push_back(abs(p.first * p.second));
}
return *std::min_element(products.begin(), products.end());
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 8);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 30);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 100);
return 0;
}
| O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
cmp ... | _Z5func0St6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
push rbp
push rbx
sub rsp, 30h
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
mov [rsp+48h+var_38], 0
mov [rsp+48h+var_30], 0
mov [rsp+48h+var_28], 0
mov rbx, [rdi]
mov rbp, [rdi+8]
cmp rbx, rbp
jz loc_... | long long func0(long long a1)
{
_DWORD *v1; // rbx
_DWORD *v2; // rbp
int v3; // eax
int *v4; // rsi
int *v5; // rdx
void *v6; // rdi
int *v7; // rax
unsigned int v8; // ebx
int v10; // [rsp+Ch] [rbp-3Ch] BYREF
void *v11; // [rsp+10h] [rbp-38h] BYREF
int *v12; // [rsp+18h] [rbp-30h]
int *v13; /... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOV qword ptr [RSP + 0x10],0x0
MOV qword ptr [RSP + 0x18],0x0
MOV qword ptr [RSP + 0x20],0x0
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
CMP RBX,RBP
JZ 0x0010135a
LEA R12,[RSP + 0xc]
J... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
int func0(vector param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int4 in_register_0000003c;
int *piVar5;
long in_FS_OFFSE... |
1,634 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(std::vector<std::pair<int, int>> list1) {
std::vector<int> products;
for (auto p : list1) {
products.push_back(abs(p.first * p.second));
}
return *std::min_element(products.begin(), products.end());
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 8);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 30);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 100);
return 0;
}
| O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rsp)
movq $0x0,0x18(%rsp)
movq $0x0,0x20(%rsp)
cmp ... | _Z5func0St6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
push rbx
sub rsp, 30h
mov rbx, [rdi]
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
movaps xmmword ptr [rsp+48h+var_38], xmm0
mov [rsp+48h+var_28], 0
cmp rbx, rbp
jz ... | long long func0(long long a1)
{
_DWORD *v1; // rbx
_DWORD *v2; // rbp
int *v3; // rcx
int *v4; // rsi
int v5; // eax
int *v6; // rax
int v7; // ebx
int v8; // eax
int v10; // [rsp+4h] [rbp-3Ch] BYREF
void *v11[2]; // [rsp+8h] [rbp-38h] BYREF
int *v12; // [rsp+18h] [rbp-28h]
unsigned long long v... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP RBX,RBP
JZ 0x00101548
XOR ECX,ECX
XOR ESI,ESI
LEA R12... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
int func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_... |
1,635 | func0 |
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <cassert>
| int func0(std::vector<std::pair<int, int>> list1) {
std::vector<int> products;
for (auto p : list1) {
products.push_back(abs(p.first * p.second));
}
return *std::min_element(products.begin(), products.end());
}
| int main() {
assert(func0({{2, 7}, {2, 6}, {1, 8}, {4, 9}}) == 8);
assert(func0({{10, 20}, {15, 2}, {5, 10}}) == 30);
assert(func0({{11, 44}, {10, 15}, {20, 5}, {12, 9}}) == 100);
return 0;
}
| O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >):
endbr64
push %r12
pxor %xmm0,%xmm0
push %rbp
push %rbx
sub $0x30,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi),%rbp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xor %eax,%eax
movaps %xmm0,0x10(%rsp)
movq $0x0,0x20(%rsp)
cmp %rb... | _Z5func0St6vectorISt4pairIiiESaIS1_EE:
endbr64
push r12
pxor xmm0, xmm0
push rbp
push rbx
sub rsp, 30h
mov rbx, [rdi]
mov rbp, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_20], rax
xor eax, eax
movaps xmmword ptr [rsp+48h+var_38], xmm0
mov [rsp+48h+var_28], 0
cmp rbx, rbp
jz ... | long long func0(long long a1)
{
_DWORD *v1; // rbx
_DWORD *v2; // rbp
int *v3; // rsi
int *v4; // rdi
int v5; // eax
signed int *v6; // r9
signed int v7; // ebx
char *v8; // rax
unsigned long long v9; // rcx
__m128i v10; // xmm0
__m128i v11; // xmm1
__m128i v12; // xmm3
__m128i v13; // xmm1
... | func0:
ENDBR64
PUSH R12
PXOR XMM0,XMM0
PUSH RBP
PUSH RBX
SUB RSP,0x30
MOV RBX,qword ptr [RDI]
MOV RBP,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x28],RAX
XOR EAX,EAX
MOVAPS xmmword ptr [RSP + 0x10],XMM0
MOV qword ptr [RSP + 0x20],0x0
CMP RBX,RBP
JZ 0x001015f8
XOR ESI,ESI
XOR EDI,EDI
LEA R12... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > >) */
uint func0(vector param_1)
{
uint *puVar1;
uint *puVar2;
int *piVar3;
uint *puVar4;
uint *puVar5;
uint *puVar6;
uint *puVar7;
uint *... |
1,636 | func0 |
#include <vector>
#include <string>
#include <limits>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(std::vector<std::any> listval) {
int min_val = std::numeric_limits<int>::max();
for(auto& item : listval) {
if(item.type() == typeid(int)) {
int val = std::any_cast<int>(item);
if (val < min_val) {
min_val = val;
}
}
}
... | int main() {
assert(func0(std::vector<std::any>{std::string("Python"), 3, 2, 4, 5, std::string("version")}) == 2);
assert(func0(std::vector<std::any>{std::string("Python"), 15, 20, 25}) == 15);
assert(func0(std::vector<std::any>{std::string("Python"), 30, 20, 40, 50, std::string("version")}) == 20);
... | O0 | cpp | func0(std::vector<std::any, std::allocator<std::any> >):
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 $0x7fffffff,-0x30(%rbp)
mov -0x38(%rbp),%rax
mov %rax,-0x18(%rbp)
mov -0x18(%rbp),%rax
mov %rax,%rdi
cal... | _Z5func0St6vectorISt3anySaIS0_EE:
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_30], 7FFFFFFFh
mov rax, [rbp+var_38]
mov [rbp+var_18], rax
mov rax, [rbp+var_18]
mov rdi, rax
call _ZNSt6vec... | long long func0(long long a1)
{
long long v1; // rax
int v3; // [rsp+10h] [rbp-30h]
int v4; // [rsp+14h] [rbp-2Ch]
long long v5; // [rsp+18h] [rbp-28h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-20h] BYREF
std::any *v7; // [rsp+30h] [rbp-10h]
unsigned long long v8; // [rsp+38h] [rbp-8h]
v8 = __readfsqword(... | 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 + -0x30],0x7fffffff
MOV RAX,qword ptr [RBP + -0x38]
MOV qword ptr [RBP + -0x18],RAX
MOV RAX,qword ptr [RBP + -0x18]
MOV RDI,RAX
CALL 0x00103338
MOV q... | /* func0(std::vector<std::any, std::allocator<std::any> >) */
int func0(vector param_1)
{
char cVar1;
bool bVar2;
int iVar3;
type_info *this;
int4 in_register_0000003c;
long in_FS_OFFSET;
int local_38;
int8 local_30;
int8 local_28;
vector<std::any,std::allocator<std::any>> *local_20;
any *local_... |
1,637 | func0 |
#include <vector>
#include <string>
#include <limits>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(std::vector<std::any> listval) {
int min_val = std::numeric_limits<int>::max();
for(auto& item : listval) {
if(item.type() == typeid(int)) {
int val = std::any_cast<int>(item);
if (val < min_val) {
min_val = val;
}
}
}
... | int main() {
assert(func0(std::vector<std::any>{std::string("Python"), 3, 2, 4, 5, std::string("version")}) == 2);
assert(func0(std::vector<std::any>{std::string("Python"), 15, 20, 25}) == 15);
assert(func0(std::vector<std::any>{std::string("Python"), 30, 20, 40, 50, std::string("version")}) == 20);
... | O1 | cpp | func0(std::vector<std::any, std::allocator<std::any> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
mov (%rdi),%rbx
mov 0x8(%rdi),%r14
cmp %r14,%rbx
je 1480 <_Z5func0St6vectorISt3anySaIS0_EE+0... | _Z5func0St6vectorISt3anySaIS0_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
mov rbx, [rdi]
mov r13, [rdi+8]
cmp r13, rbx
jz loc_1497
mov r14d, 7FFFFFFFh
mov r15, rsp
jmp ... | long long func0(long long *a1)
{
long long v1; // rbx
long long v2; // r13
int v3; // r14d
void *v4; // rax
int *v5; // rdi
void ( *v6)(long long, long long, _QWORD *); // rax
void *v7; // rdx
int *v8; // rdi
_QWORD *exception; // rdi
_QWORD v11[9]; // [rsp+0h] [rbp-48h] BYREF
v11[1] = __readfsq... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
CMP R13,RBX
JZ 0x00101497
MOV R14D,0x7fffffff
MOV R15,RSP
JMP 0x001013bf
LAB_001013a6:
MOV EAX,dword ptr [R12 + 0x... | /* func0(std::vector<std::any, std::allocator<std::any> >) */
int func0(vector param_1)
{
int8 *puVar1;
char *pcVar2;
code *pcVar3;
int8 uVar4;
int iVar5;
int1 *puVar6;
int8 *puVar7;
int4 in_register_0000003c;
int iVar8;
long in_FS_OFFSET;
int1 *local_48;
long local_40;
local_40 = *(long ... |
1,638 | func0 |
#include <vector>
#include <string>
#include <limits>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(std::vector<std::any> listval) {
int min_val = std::numeric_limits<int>::max();
for(auto& item : listval) {
if(item.type() == typeid(int)) {
int val = std::any_cast<int>(item);
if (val < min_val) {
min_val = val;
}
}
}
... | int main() {
assert(func0(std::vector<std::any>{std::string("Python"), 3, 2, 4, 5, std::string("version")}) == 2);
assert(func0(std::vector<std::any>{std::string("Python"), 15, 20, 25}) == 15);
assert(func0(std::vector<std::any>{std::string("Python"), 30, 20, 40, 50, std::string("version")}) == 20);
... | O2 | cpp | func0(std::vector<std::any, std::allocator<std::any> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rdi),%rcx
mov 0x8(%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %r14,%rcx
je 1b48 <_Z5func0St6vectorISt3anySaIS0_EE+0... | _Z5func0St6vectorISt3anySaIS0_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rcx, [rdi]
mov r12, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
cmp r12, rcx
jz loc_1B10
mov rbx, cs:qword_4CC8
mov r15, rcx
mov ... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // r12
long long v3; // r15
int v4; // r13d
void *v5; // rax
int *v6; // rdi
void ( *v7)(long long, long long, _QWORD *); // rax
void *v8; // rdx
int *v9; // rdi
_QWORD *exception; // rdi
_QWORD v12[9]; // [rsp+0h] [rbp-48h] BYRE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RCX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP R12,RCX
JZ 0x00101b10
MOV RBX,qword ptr [0x00104cc8]
MOV R15,RCX
MOV R13D,0x7fffffff
MOV R14,RSP
LEA RBP,[0x10... | /* func0(std::vector<std::any, std::allocator<std::any> >) */
int func0(vector param_1)
{
int8 *puVar1;
char *pcVar2;
code *pcVar3;
int8 uVar4;
int iVar5;
int1 *puVar6;
int8 *puVar7;
int4 in_register_0000003c;
int iVar8;
long in_FS_OFFSET;
int1 *local_48;
long local_40;
uVar4 = int::typei... |
1,639 | func0 |
#include <vector>
#include <string>
#include <limits>
#include <cassert>
#include <typeinfo>
#include <any>
| int func0(std::vector<std::any> listval) {
int min_val = std::numeric_limits<int>::max();
for(auto& item : listval) {
if(item.type() == typeid(int)) {
int val = std::any_cast<int>(item);
if (val < min_val) {
min_val = val;
}
}
}
... | int main() {
assert(func0(std::vector<std::any>{std::string("Python"), 3, 2, 4, 5, std::string("version")}) == 2);
assert(func0(std::vector<std::any>{std::string("Python"), 15, 20, 25}) == 15);
assert(func0(std::vector<std::any>{std::string("Python"), 30, 20, 40, 50, std::string("version")}) == 20);
... | O3 | cpp | func0(std::vector<std::any, std::allocator<std::any> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x18,%rsp
mov (%rdi),%rcx
mov 0x8(%rdi),%r14
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
cmp %r14,%rcx
je 1b88 <_Z5func0St6vectorISt3anySaIS0_EE+0... | _Z5func0St6vectorISt3anySaIS0_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 18h
mov rcx, [rdi]
mov r12, [rdi+8]
mov rax, fs:28h
mov [rsp+48h+var_40], rax
xor eax, eax
cmp r12, rcx
jz loc_1B00
mov rbx, cs:qword_4CC8
mov r15, rcx
mov ... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // r12
long long v3; // r15
int v4; // r13d
void *v5; // rax
int *v6; // rdi
void ( *v7)(long long, long long, _QWORD *); // rax
void *v8; // rdx
int *v9; // rdi
_QWORD *exception; // rdi
_QWORD v12[9]; // [rsp+0h] [rbp-48h] BYRE... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x18
MOV RCX,qword ptr [RDI]
MOV R12,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
CMP R12,RCX
JZ 0x00101b00
MOV RBX,qword ptr [0x00104cc8]
MOV R15,RCX
MOV R13D,0x7fffffff
MOV R14,RSP
LEA RBP,[0x10... | /* func0(std::vector<std::any, std::allocator<std::any> >) */
int func0(vector param_1)
{
int8 *puVar1;
char *pcVar2;
code *pcVar3;
int8 uVar4;
int iVar5;
int1 *puVar6;
int8 *puVar7;
int4 in_register_0000003c;
int iVar8;
long in_FS_OFFSET;
int1 *local_48;
long local_40;
uVar4 = int::typei... |
1,640 | func0 |
#include <string>
#include <cassert>
#include <cctype>
#include <sstream>
| std::string func0(const std::string& word) {
std::stringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
}... | int main() {
assert(func0("android_tv") == "AndroidTv");
assert(func0("google_pixel") == "GooglePixel");
assert(func0("apple_watch") == "AppleWatch");
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 $0x1c8,%rsp
mov %rdi,-0x1c8(%rbp)
mov %rsi,-0x1d0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov $0x8,%esi
mov $0x10,%edi
callq 296... | _Z5func0RKNSt7__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 esi, 8
mov edi, 10h
call _ZStorSt13_Ios_OpenmodeS_; std::... | long long func0(long long a1, long long a2)
{
unsigned int v2; // eax
char *v3; // rax
char v4; // bl
_QWORD *v5; // rax
_BYTE v7[32]; // [rsp+10h] [rbp-1C0h] BYREF
_BYTE v8[392]; // [rsp+30h] [rbp-1A0h] BYREF
unsigned long long v9; // [rsp+1B8h] [rbp-18h]
v9 = __readfsqword(0x28u);
v2 = std::operat... | 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 ESI,0x8
MOV EDI,0x10
CALL 0x00102a9e
MOV EDX,EAX
MOV RCX,qword ptr [RBP + -0x1d0]
LEA RAX,[RBP + -0x1a0]
MOV RSI,RCX
MO... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
bool bVar2;
_Ios_Openmode _Var3;
int iVar4;
char *pcVar5;
int *puVar6;
istream *piVar7;
string *in_RSI;
long in_FS_OFFSET;
string local_1c8 [32];
stringstream local_1a8 [392];
long local_20;
local_20 = *(long *)... |
1,641 | func0 |
#include <string>
#include <cassert>
#include <cctype>
#include <sstream>
| std::string func0(const std::string& word) {
std::stringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
}... | int main() {
assert(func0("android_tv") == "AndroidTv");
assert(func0("google_pixel") == "GooglePixel");
assert(func0("apple_watch") == "AppleWatch");
return 0;
}
| 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 $0x1c8,%rsp
mov %rdi,%rbp
mov %rsi,%rbx
mov %fs:0x28,%rax
mov %rax,0x1b8(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%r13
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B8h
mov rbp, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rsp+1E8h+var_40], rax
xor eax, eax
lea r13, [rsp+1E8h+var_1C8]
lea rdi, [rsp+1E8h+v... | long long func0(long long a1, long long *a2)
{
long long v2; // rdx
long long v3; // rsi
_BYTE *v4; // r15
_QWORD *v5; // rax
void *v7; // [rsp+0h] [rbp-1E8h] BYREF
unsigned long long v8; // [rsp+8h] [rbp-1E0h]
_QWORD v9[2]; // [rsp+10h] [rbp-1D8h] BYREF
int *v10; // [rsp+20h] [rbp-1C8h] BYREF
long l... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b8
MOV RBP,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
LEA R13,[RSP + 0x20]
LEA RDI,[RSP + 0xa0]
CALL 0x001021b0
LEA RAX,[0x104b10]
MOV qword ptr [RSP + 0xa0],RAX
MOV qword ptr [RSP + 0x178],0x0
M... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char *pcVar1;
int8 uVar2;
int8 uVar3;
int iVar4;
int8 uVar5;
istream *piVar6;
int8 *in_RSI;
long in_FS_OFFSET;
char *local_1e8;
ulong local_1e0;
char local_1d8;
int7 uStack_1d7;
long local_1c8 [2];
long local_1b8;
char loc... |
1,642 | func0 |
#include <string>
#include <cassert>
#include <cctype>
#include <sstream>
| std::string func0(const std::string& word) {
std::stringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
}... | int main() {
assert(func0("android_tv") == "AndroidTv");
assert(func0("google_pixel") == "GooglePixel");
assert(func0("apple_watch") == "AppleWatch");
return 0;
}
| 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 $0x1d8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1c8(%rsp)
xor %eax,%eax
lea 0xc0(%rsp),%r14
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 1F8h
movq xmm1, cs:off_4CE8
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
lea rax, [rsp+228h+var_148... | long long func0(long long a1, long long a2)
{
_QWORD *v3; // rdi
__m128i si128; // xmm1
char *v5; // rbp
_BYTE *v6; // r15
unsigned long long v7; // rax
_QWORD *v8; // rax
__m128 v9; // xmm0
std::ios_base *v10; // rdi
void *v12; // rdi
__m128 v13; // [rsp+0h] [rbp-228h] BYREF
std::ios_base *v14; ... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x1f8
MOVQ XMM1,qword ptr [0x00104ce8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xe0]
LEA RBX,[RSP + 0x60]
MOV RDI,RAX
MOVHPS XMM1,qword ptr [0x00104cf0]
MOV qword ptr [RSP ... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string const&) */
string * func0(string *param_1)
{
streambuf *psVar1;
ulong __n;
int *__src;
int8 uVar2;
pointer_____offset_0x40___ puVar3;
pointer_____offset_0x10___ puVar4;
int iVar5;
istream *piVar6;
int8 uVar7;
int8 *in_RSI;... |
1,643 | func0 |
#include <string>
#include <cassert>
#include <cctype>
#include <sstream>
| std::string func0(const std::string& word) {
std::stringstream ss(word);
std::string token;
std::string result;
while (std::getline(ss, token, '_')) {
if (!token.empty()) {
token[0] = std::toupper(token[0]);
result += token;
}
}
return result;
}... | int main() {
assert(func0("android_tv") == "AndroidTv");
assert(func0("google_pixel") == "GooglePixel");
assert(func0("apple_watch") == "AppleWatch");
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x1e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1d8(%rsp)
xor %eax,%eax
lea 0xd0(%rsp),%r13
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 1F8h
movq xmm1, cs:off_4CE8
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
lea rax, [rsp+228h+var_148... | long long func0(long long a1, long long a2)
{
_QWORD *v3; // rdi
__m128i si128; // xmm1
char *v5; // rbp
_BYTE *v6; // r15
unsigned long long v7; // rax
_QWORD *v8; // rax
__m128 v9; // xmm0
std::ios_base *v10; // rdi
void *v12; // rdi
__m128 v13; // [rsp+0h] [rbp-228h] BYREF
std::ios_base *v14; ... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x1f8
MOVQ XMM1,qword ptr [0x00104ce8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xe0]
LEA RBX,[RSP + 0x60]
MOV RDI,RAX
MOVHPS XMM1,qword ptr [0x00104cf0]
MOV qword ptr [RSP ... | /* WARNING: Type propagation algorithm not settling */
/* func0(std::string const&) */
string * func0(string *param_1)
{
streambuf *psVar1;
ulong __n;
int *__src;
int8 uVar2;
pointer_____offset_0x40___ puVar3;
pointer_____offset_0x10___ puVar4;
int iVar5;
istream *piVar6;
int8 uVar7;
int8 *in_RSI;... |
1,644 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> l) {
std::vector<int>::iterator it = l.begin();
while (it != l.end()) {
if (*it % 2 != 0) {
it = l.erase(it);
} else {
++it;
}
}
return l;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{2}));
assert((func0({2,4,6}) == std::vector<int>{2,4,6}));
assert((func0({10,20,3}) == std::vector<int>{10,20}));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x30,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x30(%rbp),%rax
mov %rax,%rdi
callq 1a14 <_ZNSt6vectorIiSaIiEE5beginEv>
mov %rax,-0x18(%rbp)
m... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 30h
mov [rbp+var_28], rdi
mov [rbp+var_30], rsi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_30]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5beginEv; std::vector<int>::begin(void)
mov [rbp+v... | long long func0(long long a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-18h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-10h] BYREF
v4[1] = __readfsqword(0x28u);
v3 = std::vector<int>::begin(a2);
while ( 1 )
{
v4[0] = std::vector<int>::end(a2);
if ( !(unsigned __int8)__gnu_cxx::operator!=<int *,st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x30
MOV qword ptr [RBP + -0x28],RDI
MOV qword ptr [RBP + -0x30],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x001019de
MOV qword ptr [RBP + -0x18],RAX
JMP 0x001012f0
LAB_0010129e:
LEA RAX,[RBP + ... | /* func0(std::vector<int, std::allocator<int> >) */
vector<int,std::allocator<int>> * func0(vector param_1)
{
bool bVar1;
uint *puVar2;
vector<int,std::allocator<int>> *in_RSI;
int4 in_register_0000003c;
long in_FS_OFFSET;
int8 local_20;
int8 local_18;
long local_10;
local_10 = *(long *)(in_FS_OF... |
1,645 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> l) {
std::vector<int>::iterator it = l.begin();
while (it != l.end()) {
if (*it % 2 != 0) {
it = l.erase(it);
} else {
++it;
}
}
return l;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{2}));
assert((func0({2,4,6}) == std::vector<int>{2,4,6}));
assert((func0({10,20,3}) == std::vector<int>{10,20}));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%r12
mov %rsi,%rbp
mov (%rsi),%rbx
mov 0x8(%rsi),%rdx
cmp %rdx,%rbx
jne 12fe <_Z5func0St6vectorIiSaIiEE+0x75>
mov %rdx,%rbx
mov 0x0(%rbp),%rax
mov %rax,(%r12)
mov %rbx,0x8(%r12)
mov 0x10(... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
mov r12, rdi
mov rbp, rsi
mov rbx, [rsi]
mov rdx, [rsi+8]
cmp rbx, rdx
jnz short loc_12B2
mov rbx, rdx
loc_1266:
mov rax, [rbp+0]
mov [r12], rax
mov [r12+8], rbx
mov rax, [rbp+10h]
mov [r12+10h], rax
m... | _QWORD * func0(_QWORD *a1, long long a2)
{
char *v3; // rbx
char *v4; // rdx
_BYTE *v6; // rsi
signed long long v7; // rdx
v3 = *(char **)a2;
v4 = *(char **)(a2 + 8);
if ( *(char **)a2 == v4 )
{
v3 = *(char **)(a2 + 8);
}
else
{
do
{
if ( (*v3 & 1) != 0 )
{
v6 = v3... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R12,RDI
MOV RBP,RSI
MOV RBX,qword ptr [RSI]
MOV RDX,qword ptr [RSI + 0x8]
CMP RBX,RDX
JNZ 0x001012b2
MOV RBX,RDX
LAB_00101266:
MOV RAX,qword ptr [RBP]
MOV qword ptr [R12],RAX
MOV qword ptr [R12 + 0x8],RBX
MOV RAX,qword ptr [RBP + 0x10]
MOV qword ptr [R12 + 0x10],RAX
MOV qwo... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(vector param_1)
{
byte *pbVar1;
size_t __n;
byte *pbVar2;
byte *__dest;
int8 *in_RSI;
int4 in_register_0000003c;
int8 *puVar3;
puVar3 = (int8 *)CONCAT44(in_register_0000003c,param_1);
__dest = (byte *)*in_RSI;
pbVar1 = (byte *)in_... |
1,646 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> l) {
std::vector<int>::iterator it = l.begin();
while (it != l.end()) {
if (*it % 2 != 0) {
it = l.erase(it);
} else {
++it;
}
}
return l;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{2}));
assert((func0({2,4,6}) == std::vector<int>{2,4,6}));
assert((func0({10,20,3}) == std::vector<int>{10,20}));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rcx
mov %rdx,%rax
cmp %rdx,%rcx
jne 1614 <_Z5func0St6vectorIiSaIiEE+0x34>
jmp 1644 <_Z5func0St6vectorIiSaIiEE+0x64>
nopw 0x0(%rax,%rax,1)
m... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
movdqu xmm0, xmmword ptr [rsi]
movhlps xmm1, xmm0
movq rcx, xmm0
movq rdx, xmm1
cmp rcx, rdx
jnz short loc_15BC
jmp short loc_15FC
loc_15B0:
mov rdx, [rbx+8]
mov rcx, rsi
cmp rcx, r... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v5; // xmm0
_DWORD *v6; // rcx
long long v7; // rdx
const void *v8; // rsi
signed long long v9; // rdx
long long v10; // rax
__m128 *result; // rax
v5 = (__m128)_mm_loadu_si128(a2);
v6 = (_DWORD *)v5.m128_u64[0];
v7 = _mm_... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOVDQU XMM0,xmmword ptr [RSI]
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RDX,XMM1
CMP RCX,RDX
JNZ 0x001015bc
JMP 0x001015fc
LAB_001015b0:
MOV RDX,qword ptr [RBX + 0x8]
MOV RCX,RSI
CMP RCX,RDX
JZ 0x001015ef
LAB_001015bc:
LEA RSI,[RCX + 0x4]
TEST byte ptr [RC... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int8 uVar1;
byte *__dest;
byte *__src;
byte *pbVar2;
size_t __n;
__dest = *(byte **)*param_2;
pbVar2 = *(byte **)(*param_2 + 8);
if (__dest != pbVar2) {
do {
while (__src = __dest + 4, (*... |
1,647 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::vector<int> func0(std::vector<int> l) {
std::vector<int>::iterator it = l.begin();
while (it != l.end()) {
if (*it % 2 != 0) {
it = l.erase(it);
} else {
++it;
}
}
return l;
}
| int main() {
assert((func0({1,2,3}) == std::vector<int>{2}));
assert((func0({2,4,6}) == std::vector<int>{2,4,6}));
assert((func0({10,20,3}) == std::vector<int>{10,20}));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
mov %rdi,%r12
push %rbx
mov %rsi,%rbx
sub $0x8,%rsp
mov 0x8(%rsi),%rdx
mov (%rsi),%rcx
movq %rdx,%xmm0
cmp %rdx,%rcx
jne 1610 <_Z5func0St6vectorIiSaIiEE+0x30>
jmp 1641 <_Z5func0St6vectorIiSaIiEE+0x61>
nopl 0x0(%rax)
mov ... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rdi
push rbx
mov rbx, rsi
sub rsp, 8
movdqu xmm0, xmmword ptr [rsi]
movhlps xmm1, xmm0
movq rcx, xmm0
movq rax, xmm1
cmp rcx, rax
jnz short loc_15B8
jmp short loc_15FB
loc_15B0:
mov rcx, rsi
cmp rcx, rax
jz short loc_... | __m128 * func0(__m128 *a1, const __m128i *a2, double a3, __m128 a4)
{
__m128 v5; // xmm0
_DWORD *v6; // rcx
unsigned long long v7; // rax
const void *v8; // rsi
long long v9; // rax
__m128 *result; // rax
v5 = (__m128)_mm_loadu_si128(a2);
v6 = (_DWORD *)v5.m128_u64[0];
v7 = _mm_movehl_ps(a4, v5).m128... | func0:
ENDBR64
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV RBX,RSI
SUB RSP,0x8
MOVDQU XMM0,xmmword ptr [RSI]
MOVHLPS XMM1,XMM0
MOVQ RCX,XMM0
MOVQ RAX,XMM1
CMP RCX,RAX
JNZ 0x001015b8
JMP 0x001015fb
LAB_001015b0:
MOV RCX,RSI
CMP RCX,RAX
JZ 0x001015ee
LAB_001015b8:
LEA RSI,[RCX + 0x4]
TEST byte ptr [RCX],0x1
JZ 0x001015b0
CMP RSI,R... | /* func0(std::vector<int, std::allocator<int> >) */
int8 * func0(int8 *param_1,int (*param_2) [16])
{
int8 uVar1;
byte *__dest;
byte *pbVar2;
byte *__src;
size_t __n;
__dest = *(byte **)*param_2;
pbVar2 = *(byte **)(*param_2 + 8);
if (__dest != pbVar2) {
do {
while (__src = __dest + 4, (*... |
1,648 | func0 | #include <cassert>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
template <int N>
| auto func0(const vector<tuple<string, int, int>>& list1) {
using ElementType = typename tuple_element<N, tuple<string, int, int>>::type;
vector<ElementType> result;
for (const auto& t : list1)
result.push_back(get<N>(t));
return result;
}
| int main() {
vector<tuple<string, int, int>> data = {
{"Greyson Fulton", 98, 99},
{"Brady Kent", 97, 96},
{"Wyatt Knott", 91, 94},
{"Beau Turnbull", 94, 98}
};
{
auto res = func0<0>(data);
vector<string> expected = {"Greyson Fulton", "Brady Kent", "... | O0 | cpp | auto func0<0>(std::vector<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, int>, std::allocator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48... | _Z5func0ILi0EEDaRKSt6vectorISt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiEESaIS8_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov r... | long long func0<0>(long long a1, long long a2)
{
long long v2; // rax
long long v4; // [rsp+18h] [rbp-38h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-30h] BYREF
long long v6; // [rsp+30h] [rbp-20h]
unsigned long long v7; // [rsp+38h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<std::string>::vector(a1);
... | func0<0>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x00103512
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX... | /* auto func0<0>(std::vector<std::tuple<std::string, int, int>,
std::allocator<std::tuple<std::string, int, int> > > const&) */
auto func0<0>(vector *param_1)
{
bool bVar1;
type *ptVar2;
vector<std::tuple<std::string,int,int>,std::allocator<std::tuple<std::string,int,int>>> *in_RSI;
long in_FS_OFFSET;
in... |
1,649 | func0 | #include <cassert>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
template <int N>
| auto func0(const vector<tuple<string, int, int>>& list1) {
using ElementType = typename tuple_element<N, tuple<string, int, int>>::type;
vector<ElementType> result;
for (const auto& t : list1)
result.push_back(get<N>(t));
return result;
}
| int main() {
vector<tuple<string, int, int>> data = {
{"Greyson Fulton", 98, 99},
{"Brady Kent", 97, 96},
{"Wyatt Knott", 91, 94},
{"Beau Turnbull", 94, 98}
};
{
auto res = func0<0>(data);
vector<string> expected = {"Greyson Fulton", "Brady Kent", "... | O1 | cpp | |||||
1,650 | func0 | #include <cassert>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
template <int N>
| auto func0(const vector<tuple<string, int, int>>& list1) {
using ElementType = typename tuple_element<N, tuple<string, int, int>>::type;
vector<ElementType> result;
for (const auto& t : list1)
result.push_back(get<N>(t));
return result;
}
| int main() {
vector<tuple<string, int, int>> data = {
{"Greyson Fulton", 98, 99},
{"Brady Kent", 97, 96},
{"Wyatt Knott", 91, 94},
{"Beau Turnbull", 94, 98}
};
{
auto res = func0<0>(data);
vector<string> expected = {"Greyson Fulton", "Brady Kent", "... | O2 | cpp | _Z5func0ILi0EEDaRKSt6vectorISt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiEESaIS8_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r14, [rsi+8]
mov rax, fs:28h
mov [rsp+58h+var_40... | long long func0<0>(long long a1, long long *a2)
{
long long v3; // rbx
long long v4; // r14
long long v5; // rbx
long long *v6; // rsi
long long *v7; // rbp
size_t v8; // r12
_BYTE *v9; // rdi
_BYTE *v10; // r15
long long v11; // rax
long long v13; // rax
_QWORD v14[9]; // [rsp+8h] [rbp-48h] BYRE... | func0<0>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
CMP R14,RBX
JZ 0x00102... | /* auto func0<0>(std::vector<std::tuple<std::string, int, int>,
std::allocator<std::tuple<std::string, int, int> > > const&) */
auto func0<0>(vector *param_1)
{
string *psVar1;
ulong __n;
int *__src;
ulong *puVar2;
string *psVar3;
ulong *puVar4;
long *in_RSI;
long in_FS_OFFSET;
ulong local_48;
... | |
1,651 | func0 | #include <cassert>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
template <int N>
| auto func0(const vector<tuple<string, int, int>>& list1) {
using ElementType = typename tuple_element<N, tuple<string, int, int>>::type;
vector<ElementType> result;
for (const auto& t : list1)
result.push_back(get<N>(t));
return result;
}
| int main() {
vector<tuple<string, int, int>> data = {
{"Greyson Fulton", 98, 99},
{"Brady Kent", 97, 96},
{"Wyatt Knott", 91, 94},
{"Beau Turnbull", 94, 98}
};
{
auto res = func0<0>(data);
vector<string> expected = {"Greyson Fulton", "Brady Kent", "... | O3 | cpp | auto func0<2>(std::vector<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, int>, std::allocator<std::tuple<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, int> > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r1... | _Z5func0ILi2EEDaRKSt6vectorISt5tupleIJNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiiEESaIS8_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 18h
mov r12, [rsi+8]
mov rbx, [rsi]
movups xmmword ptr [rdi], xmm0
mov qwo... | long long func0<2>(long long a1, int **a2)
{
int *v2; // r12
int *v3; // rbx
char *v4; // r8
long long v5; // r15
int v6; // eax
void *v7; // r14
signed long long v8; // r13
unsigned long long v9; // rax
unsigned long long v10; // rdx
char *v11; // r9
char *v13; // rax
unsigned long long v14; /... | func0<2>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x18
MOV R12,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R12,RBX
JZ 0x00102103
XOR R8D,R8D
XOR R15D,R15D
JMP 0x00102087
LAB_00102070:
MOV EAX,dwor... | /* auto func0<2>(std::vector<std::tuple<std::string, int, int>,
std::allocator<std::tuple<std::string, int, int> > > const&) */
auto func0<2>(vector *param_1)
{
int4 uVar1;
int4 *puVar2;
int4 *__src;
ulong uVar3;
void *__dest;
int8 uVar4;
ulong uVar5;
int4 *puVar6;
int8 *in_RSI;
int4 *puVar7;
... |
1,652 | func0 |
#include <iostream>
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& list1, const std::vector<int>& list2) {
int c = list1.size();
int d = list2.size();
for (int i = 0; i < c; ++i) {
for (int j = 0; j < d; ++j) {
if (list1[i] == list2[j]) {
return true;
}
}
}
re... | int main() {
assert(func0({1, 2, 3, 4, 5}, {6, 7, 8, 9}) == false);
assert(func0({1, 2, 3}, {4, 5, 6}) == false);
assert(func0({1, 4, 5}, {1, 4, 5}) == true);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov %rsi,-0x30(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 1878 <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x18(%r... | _Z5func0RKSt6vectorIiSaIiEES3_:
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 _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var_18], eax
mov rax, [rbp+var_30]
mov ... | long long func0(long long a1, long long a2)
{
int v2; // ebx
int i; // [rsp+10h] [rbp-20h]
int j; // [rsp+14h] [rbp-1Ch]
int v6; // [rsp+18h] [rbp-18h]
int v7; // [rsp+1Ch] [rbp-14h]
v6 = std::vector<int>::size(a1);
v7 = std::vector<int>::size(a2);
for ( i = 0; i < v6; ++i )
{
for ( j = 0; j < v... | 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 [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010183a
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x30]
MOV RDI,RAX
CALL 0x0010183a
MOV dword ptr [RBP + -0x14],EAX
MOV dword ptr ... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int iVar1;
int iVar2;
int iVar3;
int *piVar4;
int local_28;
int local_24;
iVar2 = std::vector<int,std::allocator<int>>::size((vector<int,std::allo... |
1,653 | func0 |
#include <iostream>
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& list1, const std::vector<int>& list2) {
int c = list1.size();
int d = list2.size();
for (int i = 0; i < c; ++i) {
for (int j = 0; j < d; ++j) {
if (list1[i] == list2[j]) {
return true;
}
}
}
re... | int main() {
assert(func0({1, 2, 3, 4, 5}, {6, 7, 8, 9}) == false);
assert(func0({1, 2, 3}, {4, 5, 6}) == false);
assert(func0({1, 4, 5}, {1, 4, 5}) == true);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov (%rdi),%r8
mov 0x8(%rdi),%rdx
sub %r8,%rdx
sar $0x2,%rdx
mov (%rsi),%rcx
mov 0x8(%rsi),%rax
sub %rcx,%rax
sar $0x2,%rax
mov %eax,%edi
test %edx,%edx
jle 12aa <_Z5func0RKSt6vec... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rcx, [rdi]
mov rdx, [rdi+8]
sub rdx, rcx
sar rdx, 2
mov rdi, [rsi]
mov rax, [rsi+8]
sub rax, rdi
sar rax, 2
mov r8d, eax
test edx, edx
jle short loc_1269
mov rsi, rcx
lea edx, [rdx-1]
lea r9, [rcx+rdx*4+4]
lea eax, [r... | long long func0(_QWORD *a1, _QWORD *a2)
{
_DWORD *v2; // rcx
long long v3; // rdx
_DWORD *v4; // rdi
long long v5; // rax
int v6; // r8d
_DWORD *v7; // rsi
long long v8; // r9
long long v9; // rcx
_DWORD *v10; // rax
v2 = (_DWORD *)*a1;
v3 = (long long)(a1[1] - *a1) >> 2;
v4 = (_DWORD *)*a2;
... | func0:
ENDBR64
MOV RCX,qword ptr [RDI]
MOV RDX,qword ptr [RDI + 0x8]
SUB RDX,RCX
SAR RDX,0x2
MOV RDI,qword ptr [RSI]
MOV RAX,qword ptr [RSI + 0x8]
SUB RAX,RDI
SAR RAX,0x2
MOV R8D,EAX
TEST EDX,EDX
JLE 0x00101269
MOV RSI,RCX
LEA EDX,[RDX + -0x1]
LEA R9,[RCX + RDX*0x4 + 0x4]
LEA EAX,[RAX + -0x1]
LEA RCX,[RDI + RAX*0x4 + 0... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
int *piVar5;
piVar5 = *(int **)param_1;
piVar2 = *(int **)param_2;
iVar4 = (int)(*(long *)(par... |
1,654 | func0 |
#include <iostream>
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& list1, const std::vector<int>& list2) {
int c = list1.size();
int d = list2.size();
for (int i = 0; i < c; ++i) {
for (int j = 0; j < d; ++j) {
if (list1[i] == list2[j]) {
return true;
}
}
}
re... | int main() {
assert(func0({1, 2, 3, 4, 5}, {6, 7, 8, 9}) == false);
assert(func0({1, 2, 3}, {4, 5, 6}) == false);
assert(func0({1, 4, 5}, {1, 4, 5}) == true);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov %rsi,%rax
mov 0x8(%rdi),%rdx
mov (%rdi),%rsi
mov (%rax),%rdi
mov 0x8(%rax),%rax
sub %rsi,%rdx
sub %rdi,%rax
sar $0x2,%rdx
sar $0x2,%rax
mov %eax,%r8d
test %edx,%edx
jle 15b... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, rsi
mov rdx, [rdi+8]
mov rsi, [rdi]
mov rdi, [rax]
mov rax, [rax+8]
sub rdx, rsi
sub rax, rdi
sar rdx, 2
sar rax, 2
mov r8d, eax
test edx, edx
jle short loc_14F1
sub edx, 1
sub eax, 1
lea r9, [rsi+rdx*4+4]
lea ... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // rdx
_DWORD *v4; // rsi
_DWORD *v5; // rdi
long long v6; // rdx
long long v7; // rax
long long v8; // r9
long long v9; // rcx
_DWORD *v10; // rax
v3 = *(_QWORD *)(a1 + 8);
v4 = *(_DWORD **)a1;
v5 = (_DWORD *)*a2;
v6 = (v3 - (long long... | func0:
ENDBR64
MOV RAX,RSI
MOV RDX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RDX,RSI
SUB RAX,RDI
SAR RDX,0x2
SAR RAX,0x2
MOV R8D,EAX
TEST EDX,EDX
JLE 0x001014f1
SUB EDX,0x1
SUB EAX,0x1
LEA R9,[RSI + RDX*0x4 + 0x4]
LEA RCX,[RDI + RAX*0x4 + 0x4]
LAB_001014ba:
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
int *piVar6;
piVar6 = *(int **)param_1;
piVar2 = *(int **)param_2;
iVar3 = (int)(... |
1,655 | func0 |
#include <iostream>
#include <assert.h>
#include <vector>
| bool func0(const std::vector<int>& list1, const std::vector<int>& list2) {
int c = list1.size();
int d = list2.size();
for (int i = 0; i < c; ++i) {
for (int j = 0; j < d; ++j) {
if (list1[i] == list2[j]) {
return true;
}
}
}
re... | int main() {
assert(func0({1, 2, 3, 4, 5}, {6, 7, 8, 9}) == false);
assert(func0({1, 2, 3}, {4, 5, 6}) == false);
assert(func0({1, 4, 5}, {1, 4, 5}) == true);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&):
endbr64
mov %rsi,%rax
mov 0x8(%rdi),%rdx
mov (%rdi),%rsi
mov (%rax),%rdi
mov 0x8(%rax),%rax
sub %rsi,%rdx
sub %rdi,%rax
sar $0x2,%rdx
sar $0x2,%rax
mov %eax,%r8d
test %edx,%edx
jle 159... | _Z5func0RKSt6vectorIiSaIiEES3_:
endbr64
mov rax, rsi
mov rdx, [rdi+8]
mov rsi, [rdi]
mov rdi, [rax]
mov rax, [rax+8]
sub rdx, rsi
sub rax, rdi
sar rdx, 2
sar rax, 2
mov r8d, eax
test edx, edx
jle short loc_14F1
sub edx, 1
sub eax, 1
lea r9, [rsi+rdx*4+4]
lea ... | long long func0(long long a1, _QWORD *a2)
{
long long v3; // rdx
_DWORD *v4; // rsi
_DWORD *v5; // rdi
long long v6; // rdx
long long v7; // rax
long long v8; // r9
long long v9; // rcx
_DWORD *v10; // rax
v3 = *(_QWORD *)(a1 + 8);
v4 = *(_DWORD **)a1;
v5 = (_DWORD *)*a2;
v6 = (v3 - (long long... | func0:
ENDBR64
MOV RAX,RSI
MOV RDX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
MOV RDI,qword ptr [RAX]
MOV RAX,qword ptr [RAX + 0x8]
SUB RDX,RSI
SUB RAX,RDI
SAR RDX,0x2
SAR RAX,0x2
MOV R8D,EAX
TEST EDX,EDX
JLE 0x001014f1
SUB EDX,0x1
SUB EAX,0x1
LEA R9,[RSI + RDX*0x4 + 0x4]
LEA RCX,[RDI + RAX*0x4 + 0x4]
LAB_001014ba:
... | /* func0(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> >
const&) */
int8 func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int iVar5;
int *piVar6;
piVar6 = *(int **)param_1;
piVar2 = *(int **)param_2;
iVar3 = (int)(... |
1,656 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::pair<int, int> func0(std::vector<int> arr) {
int arr_len = arr.size();
if (arr_len < 2) {
throw std::invalid_argument("No pairs exists");
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; ++i) {
for (int j = i + 1; j < arr_len; ++j) {
if (ar... | int main() {
assert(func0({1, 2, 3, 4, 7, 0, 8, 4}) == std::make_pair(7, 8));
assert(func0({0, -1, -2, -4, 5, 0, -6}) == std::make_pair(-4, -6));
assert(func0({1, 2, 3}) == std::make_pair(2, 3));
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x30,%rsp
mov %rdi,-0x38(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 192a <_ZNKSt6vectorIiSaIiEE4sizeEv>
mov %eax,-0x1c(%rbp)
... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 30h
mov [rbp+var_38], rdi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNKSt6vectorIiSaIiEE4sizeEv; std::vector<int>::size(void)
mov [rbp+var... | long long func0(long long a1)
{
std::invalid_argument *exception; // rbx
int v2; // ebx
int v4; // [rsp+14h] [rbp-2Ch] BYREF
int v5; // [rsp+18h] [rbp-28h] BYREF
int i; // [rsp+1Ch] [rbp-24h]
int j; // [rsp+20h] [rbp-20h]
int v8; // [rsp+24h] [rbp-1Ch]
unsigned long long v9; // [rsp+28h] [rbp-18h]
v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x30
MOV qword ptr [RBP + -0x38],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x0010191e
MOV dword ptr [RBP + -0x1c],EAX
CMP dword ptr [RBP + -0x1c],0x1
JG 0x0010134f
MOV EDI,0x1... | /* func0(std::vector<int, std::allocator<int> >) */
void func0(vector param_1)
{
int iVar1;
int iVar2;
invalid_argument *this;
int *piVar3;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this_00;
long in_FS_OFFSET;
int local_34;
int local_30;
int local_2c;
int local_28;
int local_... |
1,657 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::pair<int, int> func0(std::vector<int> arr) {
int arr_len = arr.size();
if (arr_len < 2) {
throw std::invalid_argument("No pairs exists");
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; ++i) {
for (int j = i + 1; j < arr_len; ++j) {
if (ar... | int main() {
assert(func0({1, 2, 3, 4, 7, 0, 8, 4}) == std::make_pair(7, 8));
assert(func0({0, -1, -2, -4, 5, 0, -6}) == std::make_pair(-4, -6));
assert(func0({1, 2, 3}) == std::make_pair(2, 3));
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rdi),%r10
mov 0x8(%rdi),%rax
sub %r10,%rax
sar $0x2,%rax
cmp $0x1,%eax
jle 1301 <_Z5func0St6vectorIiSaIiEE+0x38>
mov %eax,%r11d
mov (%r10),%edx
mov 0x4(%r10),%ecx
mov $0x0,%ebx
mov $0x1... | _Z5func0St6vectorIiSaIiEE:
endbr64
push r12
push rbp
push rbx
mov r10, [rdi]
mov rax, [rdi+8]
sub rax, r10
sar rax, 2
cmp eax, 1
jle short loc_1305
mov r11d, eax
mov edx, [r10]
mov ecx, [r10+4]
lea ebp, [rax-1]
lea r12, [rbp+1]
add rbp, 2
mov ebx, 1
loc_12BE:... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r10
long long v2; // rax
unsigned int v3; // edx
long long v4; // rcx
long long v5; // rbp
long long v6; // r12
long long v7; // rbp
long long v8; // rbx
unsigned int v9; // r9d
long long v10; // rax
unsigned int v11; // r8d
int v12; // ... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV R10,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R10
SAR RAX,0x2
CMP EAX,0x1
JLE 0x00101305
MOV R11D,EAX
MOV EDX,dword ptr [R10]
MOV ECX,dword ptr [R10 + 0x4]
LEA EBP,[RAX + -0x1]
LEA R12,[RBP + 0x1]
ADD RBP,0x2
MOV EBX,0x1
LAB_001012be:
CMP R12,RBX
JZ 0x001012f7
M... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int iVar2;
long lVar3;
invalid_argument *this;
int iVar4;
int iVar5;
long lVar6;
int4 in_register_0000003c;
piVar1 = *(int **)CONCAT44(in_register_0000003c,param_1);
iVar2 = (int)(((int8 *)CONCAT44(in_... |
1,658 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::pair<int, int> func0(std::vector<int> arr) {
int arr_len = arr.size();
if (arr_len < 2) {
throw std::invalid_argument("No pairs exists");
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; ++i) {
for (int j = i + 1; j < arr_len; ++j) {
if (ar... | int main() {
assert(func0({1, 2, 3, 4, 7, 0, 8, 4}) == std::make_pair(7, 8));
assert(func0({0, -1, -2, -4, 5, 0, -6}) == std::make_pair(-4, -6));
assert(func0({1, 2, 3}) == std::make_pair(2, 3));
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbp
push %rbx
mov (%rdi),%r10
mov 0x8(%rdi),%rax
sub %r10,%rax
sar $0x2,%rax
cmp $0x1,%eax
jle 11e0 <_Z5func0St6vectorIiSaIiEE.cold>
mov (%r10),%edx
mov 0x4(%r10),%ecx
mov %eax,%r11d
mov $0x1,%ebx
mov $0x1,%eax... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
sub rsp, 8
mov r10, [rdi]
mov rax, [rdi+8]
sub rax, r10
sar rax, 2
cmp eax, 1
jle _Z5func0St6vectorIiSaIiEE_cold; func0(std::vector<int>) [clone]
lea ebp, [rax-2]
mov edx, [r10]
mov ecx, [r10+4]
mov r11d, eax
add ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r10
long long v2; // rax
unsigned int v3; // edx
long long v4; // rcx
int v5; // r11d
long long v6; // rbp
long long v7; // rbx
unsigned int v8; // edi
long long v9; // rax
unsigned int v10; // esi
int v11; // r8d
v1 = *a1;
v2 = a1[1]... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R10,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R10
SAR RAX,0x2
CMP EAX,0x1
JLE 0x001011a0
LEA EBP,[RAX + -0x2]
MOV EDX,dword ptr [R10]
MOV ECX,dword ptr [R10 + 0x4]
MOV R11D,EAX
ADD RBP,0x2
MOV EBX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV EDI,dword p... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int iVar2;
invalid_argument *this;
long lVar3;
int iVar4;
int iVar5;
long lVar6;
int4 in_register_0000003c;
piVar1 = *(int **)CONCAT44(in_register_0000003c,param_1);
iVar2 = (int)(((int8 *)CONCAT44(in_... |
1,659 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
| std::pair<int, int> func0(std::vector<int> arr) {
int arr_len = arr.size();
if (arr_len < 2) {
throw std::invalid_argument("No pairs exists");
}
int x = arr[0];
int y = arr[1];
for (int i = 0; i < arr_len; ++i) {
for (int j = i + 1; j < arr_len; ++j) {
if (ar... | int main() {
assert(func0({1, 2, 3, 4, 7, 0, 8, 4}) == std::make_pair(7, 8));
assert(func0({0, -1, -2, -4, 5, 0, -6}) == std::make_pair(-4, -6));
assert(func0({1, 2, 3}) == std::make_pair(2, 3));
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %r12
push %rbp
push %rbx
mov (%rdi),%r10
mov 0x8(%rdi),%rax
sub %r10,%rax
sar $0x2,%rax
cmp $0x1,%eax
jle 11e0 <_Z5func0St6vectorIiSaIiEE.cold>
mov (%r10),%edx
mov 0x4(%r10),%ecx
mov %eax,%r11d
mov $0x1,%ebx
mov $0x1,%eax... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
push rbx
sub rsp, 8
mov r10, [rdi]
mov rax, [rdi+8]
sub rax, r10
sar rax, 2
cmp eax, 1
jle _Z5func0St6vectorIiSaIiEE_cold; func0(std::vector<int>) [clone]
lea ebp, [rax-2]
mov edx, [r10]
mov ecx, [r10+4]
mov r11d, eax
add ... | long long func0(unsigned int **a1)
{
unsigned int *v1; // r10
long long v2; // rax
unsigned int v3; // edx
long long v4; // rcx
int v5; // r11d
long long v6; // rbp
long long v7; // rbx
unsigned int v8; // edi
long long v9; // rax
unsigned int v10; // esi
int v11; // r8d
v1 = *a1;
v2 = a1[1]... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R10,qword ptr [RDI]
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,R10
SAR RAX,0x2
CMP EAX,0x1
JLE 0x001011a0
LEA EBP,[RAX + -0x2]
MOV EDX,dword ptr [R10]
MOV ECX,dword ptr [R10 + 0x4]
MOV R11D,EAX
ADD RBP,0x2
MOV EBX,0x1
NOP word ptr [RAX + RAX*0x1]
LAB_001014f0:
MOV EDI,dword p... | /* func0(std::vector<int, std::allocator<int> >) */
int8 func0(vector param_1)
{
int *piVar1;
int iVar2;
invalid_argument *this;
long lVar3;
int iVar4;
int iVar5;
long lVar6;
int4 in_register_0000003c;
piVar1 = *(int **)CONCAT44(in_register_0000003c,param_1);
iVar2 = (int)(((int8 *)CONCAT44(in_... |
1,660 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
const int MAX = 1000000;
| int func0(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[i / 2] + dp[i / 3] + dp[i / 4], i);
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %edi,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x38(%rbp),%rax
mov %rax,%rdi
callq 14f6 <_ZNSaIiEC1Ev>
movl $0x0,-0x34(%rbp)
mov -0x44(%rbp),%eax
add $0x1,%eax
movslq %eax,%rsi
lea ... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_44], edi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_40]
mov [rbp+var_38], rax
nop
nop
mov [rbp+var_3C], 0
mov eax, [rbp+var_44]
add eax, 1
movsxd rsi, eax
lea rcx,... | long long func0(int a1)
{
int v1; // ebx
int v2; // ebx
int v3; // ebx
unsigned int v4; // ebx
int i; // [rsp+10h] [rbp-40h] BYREF
int v7; // [rsp+14h] [rbp-3Ch] BYREF
int *v8; // [rsp+18h] [rbp-38h]
_BYTE v9[24]; // [rsp+20h] [rbp-30h] BYREF
unsigned long long v10; // [rsp+38h] [rbp-18h]
v10 = __... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV dword ptr [RBP + -0x44],EDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x40]
MOV qword ptr [RBP + -0x38],RAX
NOP
NOP
MOV dword ptr [RBP + -0x3c],0x0
MOV EAX,dword ptr [RBP + -0x44]
ADD EAX,0x1
MOVSXD RSI,EAX
LEA R... | /* func0(int) */
int4 func0(int param_1)
{
int iVar1;
int iVar2;
int4 uVar3;
int iVar4;
int4 *puVar5;
int *piVar6;
long in_FS_OFFSET;
int local_48;
int local_44;
int *local_40;
vector<int,std::allocator<int>> local_38 [24];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
local... |
1,661 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
const int MAX = 1000000;
| int func0(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[i / 2] + dp[i / 3] + dp[i / 4], i);
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
lea 0x1(%rdi),%edx
movslq %edx,%rdx
movabs $0x1fffffffffffffff,%rax
cmp %rax,%rdx
ja 12be <_Z5func0i+0xd5>
mov %edi,%ebx
test %rdx,%rdx
je 12ca <_Z5func0i+0xe1>
lea 0x0(,%rdx,4),%rbp
mov %rbp,%rdi
callq 10e0 <_Znwm@plt>
mov %rax,%... | _Z5func0i:
endbr64
push rbp
push rbx
sub rsp, 8
lea ebp, [rdi+1]
movsxd rbp, ebp
mov rax, rbp
shr rax, 3Dh
jnz loc_1273
mov ebx, edi
test rbp, rbp
jz loc_127F
shl rbp, 2
mov rdi, rbp; unsigned __int64
call __Znwm; operator new(ulong)
mov rdi, rax; void *
lea rdx... | // write access to const memory has been detected, the output may be wrong!
long long func0(int a1)
{
unsigned long long v1; // rbp
_DWORD *v3; // rax
_DWORD *v4; // rdi
_DWORD *v5; // rdx
long long v6; // rax
int v7; // edx
unsigned int v8; // ebx
v1 = a1 + 1;
if ( v1 >> 61 )
std::__throw_lengt... | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
LEA EBP,[RDI + 0x1]
MOVSXD RBP,EBP
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x00101273
MOV EBX,EDI
TEST RBP,RBP
JZ 0x0010127f
SHL RBP,0x2
MOV RDI,RBP
CALL 0x001010a0
MOV RDI,RAX
LEA RDX,[RAX + RBP*0x1]
LAB_001011e4:
MOV dword ptr [RAX],0x0
ADD RAX,0x4
CMP RAX,RDX
JNZ 0x001011e4
MOV dwor... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
int iVar2;
int4 *puVar3;
int4 *puVar4;
int iVar5;
int unaff_EBX;
ulong uVar6;
ulong uVar7;
uVar6 = (ulong)(param_1 + 1);
if (uVar6 >> 0x3d == 0) {
if (... |
1,662 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
const int MAX = 1000000;
| int func0(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[i / 2] + dp[i / 3] + dp[i / 4], i);
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O2 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r12
push %rbp
push %rbx
lea 0x1(%rdi),%ebx
movslq %ebx,%rbx
cmp %rax,%rbx
ja 13ad <_Z5func0i+0xdd>
test %rbx,%rbx
je 13a0 <_Z5func0i+0xd0>
shl $0x2,%rbx
mov %edi,%ebp
mov %rbx,%rdi
callq 10e0 <_Znwm@plt>
mov %rax,%rdi
lea (%... | _Z5func0i:
endbr64
push r12
lea r12d, [rdi+1]
push rbp
push rbx
movsxd rbx, r12d
mov rax, rbx
shr rax, 3Dh
jnz loc_133D
test rbx, rbx
jz loc_1330
shl rbx, 2
mov ebp, edi
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, rbx; n
xor esi, esi;... | long long func0(int a1)
{
int v1; // r12d
unsigned long long v2; // rbx
void *v4; // rax
_DWORD *v5; // rdi
long long v6; // rdx
int v7; // eax
unsigned int v8; // ebp
v1 = a1 + 1;
if ( (unsigned long long)(a1 + 1) >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size... | func0:
ENDBR64
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
PUSH RBX
MOVSXD RBX,R12D
MOV RAX,RBX
SHR RAX,0x3d
JNZ 0x0010133d
TEST RBX,RBX
JZ 0x00101330
SHL RBX,0x2
MOV EBP,EDI
MOV RDI,RBX
CALL 0x001010c0
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV RDI,RAX
MOV RAX,qword ptr [0x001020a0]
MOV qword ptr [RDI],RAX
CMP... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
code *pcVar2;
int iVar3;
void *__s;
int8 *puVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
uVar7 = (... |
1,663 | func0 |
#include <iostream>
#include <vector>
#include <assert.h>
using namespace std;
const int MAX = 1000000;
| int func0(int n) {
vector<int> dp(n + 1, 0);
dp[0] = 0;
dp[1] = 1;
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[i / 2] + dp[i / 3] + dp[i / 4], i);
}
return dp[n];
}
| int main() {
assert(func0(12) == 13);
assert(func0(24) == 27);
assert(func0(23) == 23);
return 0;
}
| O3 | cpp | func0(int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r12
push %rbp
push %rbx
lea 0x1(%rdi),%ebx
movslq %ebx,%rbx
cmp %rax,%rbx
ja 13cd <_Z5func0i+0xdd>
test %rbx,%rbx
je 13c0 <_Z5func0i+0xd0>
shl $0x2,%rbx
mov %edi,%ebp
mov %rbx,%rdi
callq 1100 <_Znwm@plt>
mov %rbx,%rdx
xor %e... | _Z5func0i:
endbr64
push r12
lea r12d, [rdi+1]
push rbp
push rbx
movsxd rbx, r12d
mov rax, rbx
shr rax, 3Dh
jnz loc_133D
test rbx, rbx
jz loc_1330
shl rbx, 2
mov ebp, edi
mov rdi, rbx; unsigned __int64
call __Znwm; operator new(ulong)
mov rdx, rbx; n
xor esi, esi;... | long long func0(int a1)
{
int v1; // r12d
unsigned long long v2; // rbx
void *v4; // rax
_DWORD *v5; // rdi
long long v6; // rdx
int v7; // eax
unsigned int v8; // ebp
v1 = a1 + 1;
if ( (unsigned long long)(a1 + 1) >> 61 )
std::__throw_length_error("cannot create std::vector larger than max_size... | func0:
ENDBR64
PUSH R12
LEA R12D,[RDI + 0x1]
PUSH RBP
PUSH RBX
MOVSXD RBX,R12D
MOV RAX,RBX
SHR RAX,0x3d
JNZ 0x0010133d
TEST RBX,RBX
JZ 0x00101330
SHL RBX,0x2
MOV EBP,EDI
MOV RDI,RBX
CALL 0x001010c0
MOV RDX,RBX
XOR ESI,ESI
MOV RDI,RAX
CALL 0x001010a0
MOV RDI,RAX
MOV RAX,qword ptr [0x001020a0]
MOV qword ptr [RDI],RAX
CMP... | /* WARNING: Control flow encountered bad instruction data */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int4 func0(int param_1)
{
int4 uVar1;
code *pcVar2;
int iVar3;
void *__s;
int8 *puVar4;
int iVar5;
ulong uVar6;
ulong uVar7;
uVar7 = (... |
1,664 | func0 | #include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
using namespace std;
| vector<vector<string>> func0(const vector<vector<string>> &Input) {
unordered_map<string, vector<string>> groups;
vector<string> order;
for (const auto &elem : Input) {
if (elem.empty()) continue;
const string &key = elem[0];
if (groups.find(key) == groups.end()) {
... | int main(){
{
vector<vector<string>> input = { {"x", "y"}, {"x", "z"}, {"w", "t"} };
vector<vector<string>> expected = { {"x", "y", "z"}, {"w", "t"} };
assert(func0(input) == expected);
}
{
vector<vector<string>> input = { {"a", "b"}, {"a", "c"}, {"d", "e"} };
... | O0 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0C8h
mov [rbp+var_C8], rdi
mov [rbp+var_D0], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_50]
mov rdi, rax
ca... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rbx
long long v4; // rax
unsigned long long v5; // rax
long long v6; // rax
long long v8; // [rsp+10h] [rbp-C0h] BYREF
long long v9; // [rsp+18h] [rbp-B8h] BYREF
long long v10; // [rsp+20h] [rbp-B0h] BYREF
long long v... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xc8
MOV qword ptr [RBP + -0xc8],RDI
MOV qword ptr [RBP + -0xd0],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x50]
MOV RDI,RAX
CALL 0x00103b54
LEA RAX,[RBP + -0x70]
MOV RDI,RAX
CALL 0x00103bdc
MOV RAX,qword ptr [RBP + -... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&) */
vector * func0(vector *param_1)
{
char cVar1;
bool bVar2;
vector<std::string,std::allocator<std::string>> *pvVar3;
string *psVar4;
ulong uVar... |
1,665 | func0 | #include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
using namespace std;
| vector<vector<string>> func0(const vector<vector<string>> &Input) {
unordered_map<string, vector<string>> groups;
vector<string> order;
for (const auto &elem : Input) {
if (elem.empty()) continue;
const string &key = elem[0];
if (groups.find(key) == groups.end()) {
... | int main(){
{
vector<vector<string>> input = { {"x", "y"}, {"x", "z"}, {"w", "t"} };
vector<vector<string>> expected = { {"x", "y", "z"}, {"w", "t"} };
assert(func0(input) == expected);
}
{
vector<vector<string>> input = { {"a", "b"}, {"a", "c"}, {"d", "e"} };
... | O1 | cpp | func0(std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, s... | _Z5func0RKSt6vectorIS_INSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EESaIS7_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 78h
mov r15, rdi
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea rax, [rsp+0A8h+var_48]
mov [rsp+0... | _QWORD * func0(_QWORD *a1, long long *a2)
{
long long v3; // r14
void **v4; // r14
void **v5; // r13
long long **v6; // rbx
unsigned long long v7; // rax
_QWORD *v8; // rax
unsigned long long v9; // rbp
long long v10; // rax
char *v11; // rbx
_QWORD *v12; // r13
size_t v13; // rbp
long long v14;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV R15,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x60]
MOV qword ptr [RSP + 0x30],RAX
MOV qword ptr [RSP + 0x38],0x1
MOV qword ptr [RSP + 0x40],0x0
MOV qword ptr [RSP + 0x48],0x0
MOV dword ... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&) */
vector * func0(vector *param_1)
{
vector *pvVar1;
string *psVar2;
size_t __n;
int8 *puVar3;
int iVar4;
long *plVar5;
vector<std::string,s... |
1,666 | func0 | #include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
using namespace std;
| vector<vector<string>> func0(const vector<vector<string>> &Input) {
unordered_map<string, vector<string>> groups;
vector<string> order;
for (const auto &elem : Input) {
if (elem.empty()) continue;
const string &key = elem[0];
if (groups.find(key) == groups.end()) {
... | int main(){
{
vector<vector<string>> input = { {"x", "y"}, {"x", "z"}, {"w", "t"} };
vector<vector<string>> expected = { {"x", "y", "z"}, {"w", "t"} };
assert(func0(input) == expected);
}
{
vector<vector<string>> input = { {"a", "b"}, {"a", "c"}, {"d", "e"} };
... | 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_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0C8h
mov rbx, [rsi]
mov [rsp+0F8h+var_E8], rdi
lea rcx, [rsp+0F8h+var_78]
lea r14, [rsp+0F8h+var_98... | long long func0(long long a1, long long **a2)
{
long long *v2; // rbx
long long *v3; // rax
long long v4; // r13
char *v5; // r15
long long **v6; // rbp
size_t v7; // r12
char *v8; // rdx
long long v9; // rax
unsigned long long v10; // r13
long long v11; // rax
_QWORD *v12; // rdi
long long v13... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xc8
MOV RBX,qword ptr [RSI]
MOV qword ptr [RSP + 0x10],RDI
LEA RCX,[RSP + 0x80]
LEA R14,[RSP + 0x60]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xb8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xb0]
MOV qword ptr [RSP + 0x8],RCX
MOV ... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&) */
vector * func0(vector *param_1)
{
long lVar1;
long *plVar2;
size_t __n;
int (*pauVar3) [16];
int iVar4;
vector<std::string,std::allocator<s... |
1,667 | func0 | #include <vector>
#include <string>
#include <unordered_map>
#include <cassert>
using namespace std;
| vector<vector<string>> func0(const vector<vector<string>> &Input) {
unordered_map<string, vector<string>> groups;
vector<string> order;
for (const auto &elem : Input) {
if (elem.empty()) continue;
const string &key = elem[0];
if (groups.find(key) == groups.end()) {
... | int main(){
{
vector<vector<string>> input = { {"x", "y"}, {"x", "z"}, {"w", "t"} };
vector<vector<string>> expected = { {"x", "y", "z"}, {"w", "t"} };
assert(func0(input) == expected);
}
{
vector<vector<string>> input = { {"a", "b"}, {"a", "c"}, {"d", "e"} };
... | 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_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 0D8h
mov rcx, [rsi+8]
mov [rsp+108h+var_E0], rdi
mov rax, fs:28h
mov [rsp+108h+var_40], rax
xor ... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v2; // rcx
_QWORD *v3; // rax
_QWORD *v4; // r15
long long v5; // r13
long long v6; // r12
void *v7; // rbx
size_t v8; // rbp
long long v9; // rax
long long v10; // r13
_BYTE *v11; // rdi
size_t v12; // r12
_BYTE *v13; // rax
long long v14; ... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0xd8
MOV RCX,qword ptr [RSI + 0x8]
MOV qword ptr [RSP + 0x28],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0xc8],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0xc0]
MOV qword ptr [RSP + 0x38],RCX
MOV qword ptr [RSP + 0x58],RAX
MOV qwor... | /* func0(std::vector<std::vector<std::string, std::allocator<std::string > >,
std::allocator<std::vector<std::string, std::allocator<std::string > > > > const&) */
vector * func0(vector *param_1)
{
long *plVar1;
size_t sVar2;
int *puVar3;
long *plVar4;
int (*pauVar5) [16];
int8 *puVar6;
int iVar7;
... |
1,668 | func0 |
#include <vector>
#include <cassert>
#include <algorithm>
template <typename T>
| std::vector<T> func0(const std::vector<std::vector<T>>& lst) {
std::vector<T> maxList;
for (const auto& subList : lst) {
if (subList.size() > maxList.size()) {
maxList = subList;
}
}
return maxList;
}
| int main() {
assert((func0<char>({{'A'},{'A','B'},{'A','B','C'}}) == std::vector<char>{'A','B','C'}));
assert((func0<int>({{1},{1,2},{1,2,3}}) == std::vector<int>{1,2,3}));
assert((func0<int>({{1,1},{1,2,3},{1,5,6,1}}) == std::vector<int>{1,5,6,1}));
return 0;
}
| O0 | cpp | std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x48,%rsp
mov %rdi,-0x48(%rbp)
mov %rsi,-0x50(%rbp)
mov %fs:0x28,%rax
mov %... | _Z5func0IcESt6vectorIT_SaIS1_EERKS0_IS3_SaIS3_EE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 48h
mov [rbp+var_48], rdi
mov [rbp+var_50], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_48]
mov rdi, rax
call _ZNSt6vectorIcSaIcEEC2Ev; std::vector<... | long long func0<char>(long long a1, long long a2)
{
unsigned long long v2; // rbx
long long v4; // [rsp+18h] [rbp-38h] BYREF
_QWORD v5[2]; // [rsp+20h] [rbp-30h] BYREF
long long v6; // [rsp+30h] [rbp-20h]
unsigned long long v7; // [rsp+38h] [rbp-18h]
v7 = __readfsqword(0x28u);
std::vector<char>::vector(... | func0<char>:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x001021e4
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],... | /* std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char,
std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&) */
vector func0<char>(vector_conflict *param_1)
{
bool bVar1;
ulong uVar2;
ulong uVar3;
vector<std::vector<char,std::allocator<ch... |
1,669 | func0 |
#include <vector>
#include <cassert>
#include <algorithm>
template <typename T>
| std::vector<T> func0(const std::vector<std::vector<T>>& lst) {
std::vector<T> maxList;
for (const auto& subList : lst) {
if (subList.size() > maxList.size()) {
maxList = subList;
}
}
return maxList;
}
| int main() {
assert((func0<char>({{'A'},{'A','B'},{'A','B','C'}}) == std::vector<char>{'A','B','C'}));
assert((func0<int>({{1},{1,2},{1,2,3}}) == std::vector<int>{1,2,3}));
assert((func0<int>({{1,1},{1,2,3},{1,5,6,1}}) == std::vector<int>{1,5,6,1}));
return 0;
}
| O1 | cpp | std::vector<int, std::allocator<int> > func0<int>(std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbp
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rbx
mov ... | _Z5func0IiESt6vectorIT_SaIS1_EERKS0_IS3_SaIS3_EE:
endbr64
push r12
push rbp
push rbx
mov rbp, rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
mov r12, [rsi+8]
cmp r12, rbx
jnz short loc_2053
loc_2042:
mov rax, rbp
pop rbx
pop... | _QWORD * func0<int>(_QWORD *a1, long long a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r12
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = *(_QWORD **)a2;
v3 = *(_QWORD **)(a2 + 8);
if ( v3 != *(_QWORD **)a2 )
{
do
{
if ( a1[1] - *a1 < v2[1] - *v2 )
std::vector<int>::operator=(a1, v2);
... | func0<int>:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
MOV RBP,RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R12,qword ptr [RSI + 0x8]
CMP R12,RBX
JNZ 0x00102053
LAB_00102042:
MOV RAX,RBP
POP RBX
POP RBP
POP R12
RET
LAB_0010204a:
ADD RBX,0x18
CMP R12,RBX
JZ... | /* std::vector<int, std::allocator<int> > func0<int>(std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > const&) */
vector<int,std::allocator<int>> *
func0<int>(vector<int,std::allocator<int>> *param_1,int8 *param_2)
{
vector *pvVar1;
vector *pvVar2;
... |
1,670 | func0 |
#include <vector>
#include <cassert>
#include <algorithm>
template <typename T>
| std::vector<T> func0(const std::vector<std::vector<T>>& lst) {
std::vector<T> maxList;
for (const auto& subList : lst) {
if (subList.size() > maxList.size()) {
maxList = subList;
}
}
return maxList;
}
| int main() {
assert((func0<char>({{'A'},{'A','B'},{'A','B','C'}}) == std::vector<char>{'A','B','C'}));
assert((func0<int>({{1},{1,2},{1,2,3}}) == std::vector<int>{1,2,3}));
assert((func0<int>({{1,1},{1,2,3},{1,5,6,1}}) == std::vector<int>{1,5,6,1}));
return 0;
}
| O2 | cpp | std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov (%rsi),%rbx
mov 0x8(... | _Z5func0IcESt6vectorIT_SaIS1_EERKS0_IS3_SaIS3_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
mov rbx, [rsi]
mov r13, [rsi+8]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
cmp r13, rbx
jz loc_1CD8
xo... | long long func0<char>(long long a1, long long *a2)
{
long long v3; // rbx
long long v4; // r13
_BYTE *v5; // rcx
_BYTE *v6; // rdi
long long v7; // rdx
_BYTE *v8; // r14
long long v9; // rsi
size_t v10; // r12
_BYTE *v11; // rsi
signed long long v12; // rdx
_BYTE *v13; // r12
_BYTE *v15; // rax... | func0<char>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R13,RBX
JZ 0x00101cd8
XOR ECX,ECX
XOR EDI,EDI
JMP 0x00101c55
LAB_00101c40:
ADD RBX,0x18... | /* std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char,
std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&) */
vector<char,std::allocator<char>> *
func0<char>(vector<char,std::allocator<char>> *param_1,int8 *param_2)
{
vector<char,std::allocat... |
1,671 | func0 |
#include <vector>
#include <cassert>
#include <algorithm>
template <typename T>
| std::vector<T> func0(const std::vector<std::vector<T>>& lst) {
std::vector<T> maxList;
for (const auto& subList : lst) {
if (subList.size() > maxList.size()) {
maxList = subList;
}
}
return maxList;
}
| int main() {
assert((func0<char>({{'A'},{'A','B'},{'A','B','C'}}) == std::vector<char>{'A','B','C'}));
assert((func0<int>({{1},{1,2},{1,2,3}}) == std::vector<int>{1,2,3}));
assert((func0<int>({{1,1},{1,2,3},{1,5,6,1}}) == std::vector<int>{1,5,6,1}));
return 0;
}
| O3 | cpp | std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char, std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(... | _Z5func0IcESt6vectorIT_SaIS1_EERKS0_IS3_SaIS3_EE:
endbr64
push r15
pxor xmm0, xmm0
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 8
mov r14, [rsi+8]
mov rbx, [rsi]
movups xmmword ptr [rdi], xmm0
mov qword ptr [rdi+10h], 0
cmp r14, rbx
jz loc_1D14
xo... | long long func0<char>(long long a1, long long *a2)
{
long long v3; // r14
long long v4; // rbx
_BYTE *v5; // rdi
_BYTE *v6; // r15
long long v7; // rdx
_BYTE *v8; // r12
long long v9; // rsi
size_t v10; // r13
_BYTE *v11; // rsi
signed long long v12; // rdx
_BYTE *v14; // rax
v3 = a2[1];
v4 ... | func0<char>:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
SUB RSP,0x8
MOV R14,qword ptr [RSI + 0x8]
MOV RBX,qword ptr [RSI]
MOVUPS xmmword ptr [RDI],XMM0
MOV qword ptr [RDI + 0x10],0x0
CMP R14,RBX
JZ 0x00101d14
XOR EDI,EDI
XOR R15D,R15D
JMP 0x00101c8d
LAB_00101c80:
ADD RBX,0x... | /* std::vector<char, std::allocator<char> > func0<char>(std::vector<std::vector<char,
std::allocator<char> >, std::allocator<std::vector<char, std::allocator<char> > > > const&) */
vector<char,std::allocator<char>> *
func0<char>(vector<char,std::allocator<char>> *param_1,int8 *param_2)
{
vector<char,std::allocat... |
1,672 | func0 |
#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<double>& list1) {
int length = list1.size();
int sum_rounded = std::accumulate(list1.begin(), list1.end(), 0, [](int acc, double x) {
return acc + round(x);
});
return sum_rounded * length;
}
| int main() {
assert(func0({22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50}) == 243);
assert(func0({5, 2, 9, 24.3, 29}) == 345);
assert(func0({25.0, 56.7, 89.2}) == 513);
return 0;
}
| O0 | cpp | func0(std::vector<double, std::allocator<double> > const&)::{lambda(int, double)#1}::operator()(int, double) const:
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
movsd %xmm0,-0x18(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd %xmm1,-0x20(%rbp)
mov -0x18(%rbp),%rax
movq %ra... | _ZZ5func0RKSt6vectorIdSaIdEEENKUlidE_clEid:
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
movsd [rbp+x], xmm0
pxor xmm1, xmm1
cvtsi2sd xmm1, [rbp+var_C]
movsd [rbp+var_20], xmm1
mov rax, [rbp+x]
movq xmm0, rax; x
call _round
addsd xmm0, [rbp+var_20]
l... | double func0(std::vector<double> const&)::{lambda(int,double)#1}::operator()(double a1, long long a2, int a3)
{
return round(a1) + (double)a3;
} | 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 0x0010171e
MOV dword ptr [RBP + -0x18],EAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101792
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101746
MOV ED... | /* func0(std::vector<double, std::allocator<double> > const&) */
int func0(vector *param_1)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int iVar4;
_lambda_int_double__1_ in_ECX;
iVar1 = std::vector<double,std::allocator<double>>::size
((vector<double,std::allocato... |
1,673 | func0 |
#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<double>& list1) {
int length = list1.size();
int sum_rounded = std::accumulate(list1.begin(), list1.end(), 0, [](int acc, double x) {
return acc + round(x);
});
return sum_rounded * length;
}
| int main() {
assert(func0({22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50}) == 243);
assert(func0({5, 2, 9, 24.3, 29}) == 345);
assert(func0({25.0, 56.7, 89.2}) == 513);
return 0;
}
| O1 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
mov %r12,%rax
sub %rbp,%rax
sar $0x3,%rax
mov %rax,%r13
cmp %rbp,%r12
je 12cd <_Z5func0RKSt6vectorIdSaIdEE+0x64>
mov $0x0,%e... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, [rdi+8]
mov rbx, [rdi]
mov r13, r12
sub r13, rbx
sar r13, 3
cmp r12, rbx
jz short loc_1289
mov ebp, 0
loc_1252:
movsd xmm0, qword ptr [rbx]; x
call _round
movapd xmm1, xmm0... | long long func0(double **a1)
{
double *v1; // r12
double *v2; // rbx
long long v3; // r13
int v4; // ebp
v1 = a1[1];
v2 = *a1;
v3 = v1 - *a1;
if ( v1 == *a1 )
{
v4 = 0;
}
else
{
v4 = 0;
do
v4 = (int)((double)v4 + round(*v2++));
while ( v1 != v2 );
}
return (unsigned i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV R13,R12
SUB R13,RBX
SAR R13,0x3
CMP R12,RBX
JZ 0x00101289
MOV EBP,0x0
LAB_00101252:
MOVSD XMM0,qword ptr [RBX]
CALL 0x001010c0
MOVAPD XMM1,XMM0
PXOR XMM0,XMM0
CVTSI2SD XMM0,EBP
ADDSD XMM0,XMM1
CVTTSD... | /* func0(std::vector<double, std::allocator<double> > const&) */
int func0(vector *param_1)
{
double *pdVar1;
double *pdVar2;
int iVar3;
long lVar4;
double dVar5;
pdVar1 = *(double **)(param_1 + 8);
pdVar2 = *(double **)param_1;
lVar4 = (long)pdVar1 - (long)pdVar2;
if (pdVar1 == pdVar2) {
iVa... |
1,674 | func0 |
#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<double>& list1) {
int length = list1.size();
int sum_rounded = std::accumulate(list1.begin(), list1.end(), 0, [](int acc, double x) {
return acc + round(x);
});
return sum_rounded * length;
}
| int main() {
assert(func0({22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50}) == 243);
assert(func0({5, 2, 9, 24.3, 29}) == 345);
assert(func0({25.0, 56.7, 89.2}) == 513);
return 0;
}
| O2 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
mov %r12,%rax
sub %rbp,%rax
sar $0x3,%rax
cmp %r12,%rbp
je 1540 <_Z5func0RKSt6vectorIdSaIdEE+0x70>
mov %rax,%r13
xor %ebx,%e... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, [rdi+8]
mov rbx, [rdi]
mov rax, r12
sub rax, rbx
sar rax, 3
cmp r12, rbx
jz short loc_1450
mov r13, rax
xor ebp, ebp
nop dword ptr [rax+00000000h]
loc_1410:
movsd xmm0,... | long long func0(double **a1)
{
double *v1; // r12
double *v2; // rbx
long long v3; // r13
int v4; // ebp
double v5; // xmm0_8
v1 = a1[1];
v2 = *a1;
if ( v1 == *a1 )
return 0LL;
v3 = a1[1] - *a1;
v4 = 0;
do
{
v5 = *v2++;
v4 = (int)((double)v4 + round(v5));
}
while ( v1 != v2 );
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,R12
SUB RAX,RBX
SAR RAX,0x3
CMP R12,RBX
JZ 0x00101450
MOV R13,RAX
XOR EBP,EBP
NOP dword ptr [RAX]
LAB_00101410:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x001010c0
MOVAPD XMM1,XMM0
PXOR XMM0,X... | /* func0(std::vector<double, std::allocator<double> > const&) */
int func0(vector *param_1)
{
double *pdVar1;
long lVar2;
double *pdVar3;
int iVar4;
double dVar5;
pdVar1 = *(double **)(param_1 + 8);
pdVar3 = *(double **)param_1;
lVar2 = (long)pdVar1 - (long)pdVar3;
if (pdVar1 != pdVar3) {
iVa... |
1,675 | func0 |
#include <iostream>
#include <vector>
#include <cmath>
#include <numeric>
#include <assert.h>
| int func0(const std::vector<double>& list1) {
int length = list1.size();
int sum_rounded = std::accumulate(list1.begin(), list1.end(), 0, [](int acc, double x) {
return acc + round(x);
});
return sum_rounded * length;
}
| int main() {
assert(func0({22.4, 4.0, -16.22, -9.10, 11.00, -12.22, 14.20, -5.20, 17.50}) == 243);
assert(func0({5, 2, 9, 24.3, 29}) == 345);
assert(func0({25.0, 56.7, 89.2}) == 513);
return 0;
}
| O3 | cpp | func0(std::vector<double, std::allocator<double> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
mov %r12,%rax
sub %rbp,%rax
sar $0x3,%rax
cmp %r12,%rbp
je 14f0 <_Z5func0RKSt6vectorIdSaIdEE+0x70>
mov %rax,%r13
xor %ebx,%e... | _Z5func0RKSt6vectorIdSaIdEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov r12, [rdi+8]
mov rbx, [rdi]
mov rax, r12
sub rax, rbx
sar rax, 3
cmp r12, rbx
jz short loc_1450
mov r13, rax
xor ebp, ebp
nop dword ptr [rax+00000000h]
loc_1410:
movsd xmm0,... | long long func0(double **a1)
{
double *v1; // r12
double *v2; // rbx
long long v3; // r13
int v4; // ebp
double v5; // xmm0_8
v1 = a1[1];
v2 = *a1;
if ( v1 == *a1 )
return 0LL;
v3 = a1[1] - *a1;
v4 = 0;
do
{
v5 = *v2++;
v4 = (int)((double)v4 + round(v5));
}
while ( v1 != v2 );
... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R12,qword ptr [RDI + 0x8]
MOV RBX,qword ptr [RDI]
MOV RAX,R12
SUB RAX,RBX
SAR RAX,0x3
CMP R12,RBX
JZ 0x00101450
MOV R13,RAX
XOR EBP,EBP
NOP dword ptr [RAX]
LAB_00101410:
MOVSD XMM0,qword ptr [RBX]
ADD RBX,0x8
CALL 0x001010c0
MOVAPD XMM1,XMM0
PXOR XMM0,X... | /* func0(std::vector<double, std::allocator<double> > const&) */
int func0(vector *param_1)
{
double *pdVar1;
long lVar2;
double *pdVar3;
int iVar4;
double dVar5;
pdVar1 = *(double **)(param_1 + 8);
pdVar3 = *(double **)param_1;
lVar2 = (long)pdVar1 - (long)pdVar3;
if (pdVar1 != pdVar3) {
iVa... |
1,676 | func0 |
#include <cassert>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
movl $0x0,-0x8(%rbp)
movl $0x1,-0x4(%rbp)
mov -0x4(%rbp),%eax
cmp -0x14(%rbp),%eax
jg 1180 <_Z5func0i+0x37>
mov -0x4(%rbp),%eax
imul %eax,%eax
imul -0x4(%rbp),%eax
shl $0x3,%eax
add %eax,-0x8(%rbp)
addl $0x1,-0x4(%rbp)... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_14], edi
mov [rbp+var_8], 0
mov [rbp+var_4], 1
jmp short loc_1178
loc_1164:
mov eax, [rbp+var_4]
imul eax, eax
imul eax, [rbp+var_4]
shl eax, 3
add [rbp+var_8], eax
add [rbp+var_4], 1
loc_1178:
mov eax, [rbp+var_4]
cm... | long long func0(int a1)
{
unsigned int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i <= a1; ++i )
v2 += 8 * i * i * i;
return v2;
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x8],0x0
MOV dword ptr [RBP + -0x4],0x1
JMP 0x00101178
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x4]
IMUL EAX,EAX
IMUL EAX,dword ptr [RBP + -0x4]
SHL EAX,0x3
ADD dword ptr [RBP + -0x8],EAX
ADD dword ptr [RBP + -0x4],0x1
LAB_0010117... | /* func0(int) */
int func0(int param_1)
{
int4 local_10;
int4 local_c;
local_10 = 0;
for (local_c = 1; local_c <= param_1; local_c = local_c + 1) {
local_10 = local_10 + local_c * local_c * local_c * 8;
}
return local_10;
} |
1,677 | func0 |
#include <cassert>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O1 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1173 <_Z5func0i+0x2a>
add $0x1,%edi
mov $0x1,%eax
mov $0x0,%ecx
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
lea (%rcx,%rdx,8),%ecx
add $0x1,%eax
cmp %edi,%eax
jne 115e <_Z5func0i+0x15>
mov %ecx,%eax
retq
mov $0x0,%ecx
jmp 1170 <_Z5func0i+0... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1173
add edi, 1
mov eax, 1
mov ecx, 0
loc_115E:
mov edx, eax
imul edx, eax
imul edx, eax
lea ecx, [rcx+rdx*8]
add eax, 1
cmp eax, edi
jnz short loc_115E
loc_1170:
mov eax, ecx
retn
loc_1173:
mov ecx, 0
jmp short loc_... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
if ( a1 <= 0 )
{
return 0;
}
else
{
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v3 += 8 * v2 * v2 * v2;
++v2;
}
while ( v2 != v1 );
}
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101173
ADD EDI,0x1
MOV EAX,0x1
MOV ECX,0x0
LAB_0010115e:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
LEA ECX,[RCX + RDX*0x8]
ADD EAX,0x1
CMP EAX,EDI
JNZ 0x0010115e
LAB_00101170:
MOV EAX,ECX
RET
LAB_00101173:
MOV ECX,0x0
JMP 0x00101170 | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 1) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
iVar2 = iVar2 + iVar1 * iVar1 * iVar1 * 8;
iVar1 = iVar1 + 1;
} while (iVar1 != param_1 + 1);
}
return iVar2;
} |
1,678 | func0 |
#include <cassert>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O2 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1170 <_Z5func0i+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %edi,%eax
jne 1158 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
m... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea ecx, [rcx+rdx*8]
cmp edi, eax
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ec... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v1 != v2 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA ECX,[RCX + RDX*0x8]
CMP EDI,EAX
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3 * 8;
} while (param_1 + 1 != iVar1);
return iVar2;
}
return 0;
} |
1,679 | func0 |
#include <cassert>
| int func0(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += (2*i)*(2*i)*(2*i);
}
return sum;
}
| int main() {
assert(func0(2) == 72);
assert(func0(3) == 288);
assert(func0(4) == 800);
return 0;
}
| O3 | cpp | func0(int):
endbr64
test %edi,%edi
jle 1170 <_Z5func0i+0x30>
add $0x1,%edi
mov $0x1,%eax
xor %r8d,%r8d
nopl 0x0(%rax,%rax,1)
mov %eax,%edx
imul %eax,%edx
imul %eax,%edx
add $0x1,%eax
lea (%r8,%rdx,8),%r8d
cmp %edi,%eax
jne 1158 <_Z5func0i+0x18>
mov %r8d,%eax
retq
xor %r8d,%r8d
m... | _Z5func0i:
endbr64
test edi, edi
jle short loc_1170
add edi, 1
mov eax, 1
xor ecx, ecx
nop word ptr [rax+rax+00h]
loc_1158:
mov edx, eax
imul edx, eax
imul edx, eax
add eax, 1
lea ecx, [rcx+rdx*8]
cmp eax, edi
jnz short loc_1158
mov eax, ecx
retn
loc_1170:
xor ec... | long long func0(int a1)
{
int v1; // edi
int v2; // eax
unsigned int v3; // ecx
int v4; // edx
if ( a1 <= 0 )
return 0LL;
v1 = a1 + 1;
v2 = 1;
v3 = 0;
do
{
v4 = v2 * v2 * v2;
++v2;
v3 += 8 * v4;
}
while ( v2 != v1 );
return v3;
} | func0:
ENDBR64
TEST EDI,EDI
JLE 0x00101170
ADD EDI,0x1
MOV EAX,0x1
XOR ECX,ECX
NOP word ptr [RAX + RAX*0x1]
LAB_00101158:
MOV EDX,EAX
IMUL EDX,EAX
IMUL EDX,EAX
ADD EAX,0x1
LEA ECX,[RCX + RDX*0x8]
CMP EAX,EDI
JNZ 0x00101158
MOV EAX,ECX
RET
LAB_00101170:
XOR ECX,ECX
MOV EAX,ECX
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
if (0 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
iVar3 = iVar1 * iVar1 * iVar1;
iVar1 = iVar1 + 1;
iVar2 = iVar2 + iVar3 * 8;
} while (iVar1 != param_1 + 1);
return iVar2;
}
return 0;
} |
1,680 | func0 | #include <string>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::vector<std::string>& test_tup) {
std::string delim = "-";
std::stringstream res;
for (size_t i = 0; i < test_tup.size(); ++i) {
res << test_tup[i];
if (i < test_tup.size() - 1) {
res << delim;
}
}
return res.str();
}
| int main() {
assert(func0({"ID", "is", "4", "UTS"}) == "ID-is-4-UTS");
assert(func0({"QWE", "is", "4", "RTY"}) == "QWE-is-4-RTY");
assert(func0({"ZEN", "is", "4", "OP"}) == "ZEN-is-4-OP");
return 0;
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x1d8,%rsp
mov %rdi,-0x1d8(%rbp)
mov %rsi,-0x1e0(%... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
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
lea rax, [rbp+var_1D1]
mov [rbp+var_1C8], rax
... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
unsigned long long v4; // rax
char v6; // [rsp+1Fh] [rbp-1D1h] BYREF
unsigned long long i; // [rsp+20h] [rbp-1D0h]
char *v8; // [rsp+28h] [rbp-1C8h]
_BYTE v9[32]; // [rsp+30h] [rbp-1C0h] BYREF
_BYTE v10[16]; // [rsp... | 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
LEA RAX,[RBP + -0x1d1]
MOV qword ptr [RBP + -0x1c8],RAX
NOP
NOP
LEA RDX,[RBP + -0x1d1]
LEA RAX,[RBP + -0x1c0]
LEA RCX,[0x10... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
string *psVar1;
long lVar2;
ulong uVar3;
vector<std::string,std::allocator<std::string>> *in_RSI;
long in_FS_OFFSET;
allocator local_1d9;
ulong local_1d8;
allocator *local_1d0;
string local_... |
1,681 | func0 | #include <string>
#include <vector>
#include <sstream>
#include <assert.h>
| std::string func0(const std::vector<std::string>& test_tup) {
std::string delim = "-";
std::stringstream res;
for (size_t i = 0; i < test_tup.size(); ++i) {
res << test_tup[i];
if (i < test_tup.size() - 1) {
res << delim;
}
}
return res.str();
}
| int main() {
assert(func0({"ID", "is", "4", "UTS"}) == "ID-is-4-UTS");
assert(func0({"QWE", "is", "4", "RTY"}) == "QWE-is-4-RTY");
assert(func0({"ZEN", "is", "4", "OP"}) == "ZEN-is-4-OP");
return 0;
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > > const&):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1b8,%rsp
mov %rdi,%r... | _Z5func0RKSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1B8h
mov r13, rdi
mov rbp, rsi
mov rax, fs:28h
mov [rsp+1E8h+var_40], rax
xor eax, eax
mov rdi, rsp
lea rax, [rsp+1E8... | long long func0(long long a1, long long *a2)
{
long long v2; // rax
unsigned long long v3; // rbx
unsigned long long v4; // r8
void *v6[2]; // [rsp+0h] [rbp-1E8h] BYREF
_QWORD v7[2]; // [rsp+10h] [rbp-1D8h] BYREF
int *v8; // [rsp+20h] [rbp-1C8h] BYREF
long long v9; // [rsp+28h] [rbp-1C0h]
int *v10; // ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1b8
MOV R13,RDI
MOV RBP,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1a8],RAX
XOR EAX,EAX
MOV RDI,RSP
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
LEA RDX,[0x103005]
LEA RSI,[RDX + -0x1]
LAB_0010248e:
CALL 0x00102c94
LEA RBX,[RSP +... | /* func0(std::vector<std::string, std::allocator<std::string > > const&) */
vector * func0(vector *param_1)
{
int8 uVar1;
int8 uVar2;
long lVar3;
int8 *puVar4;
ulong uVar5;
long *in_RSI;
long in_FS_OFFSET;
long *local_1e8;
long local_1e0;
long local_1d8 [2];
long local_1c8 [2];
long local_1b8 ... |
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.