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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
3,782 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
#include <utility>
using namespace std;
| vector<pair<char, int>> func0(const string &s, int a) {
// Map to store frequency and first occurrence index
unordered_map<char, pair<int, int>> freq; // key: character, value: {count, first_index}
for (int i = 0; i < s.size(); ++i) {
char c = s[i];
if (freq.find(c) == freq.end()) {
... | int main(){
{
vector<pair<char, int>> expected = {{'s', 4}, {'e', 3}, {'f', 3}};
assert(func0("lkseropewdssafsdfafkpwe", 3) == expected);
}
{
vector<pair<char, int>> expected = {{'s', 4}, {'e', 3}};
assert(func0("lkseropewdssafsdfafkpwe", 2) == expected);
}
{... | O2 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::tuple<char, int, int>*, std::vector<std::tuple<char, int, int>, std::allocator<std::tuple<char, int, int> > > >, long, std::tuple<char, int, int>, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt5tupleIJciiEESt6vectorIS3_SaIS3_EEEElS3_NS0_5__ops15_Iter_comp_iterIZ5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEUlRKS3_SK_E_EEEvT_T0_SO_T1_T2__isra_0:
lea rax, [rdx-1]
push r14
mov r9, rsi
mov r10, rdx
mov r11, rax
push r12
s... | long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::tuple<char,int,int> *,std::vector<std::tuple<char,int,int>>>,long,std::tuple<char,int,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::string const&,int)::{lambda(std::tuple<char,int,int> const&,std::tuple<char,int,int> const&)#1}>>(
long long a1,... | __adjust_heap<__normal_iterator<std::tuple<char,int,int>*,std::vector<std::tuple<char,int,int>,std::allocator<std::tuple<char,int,int>>>>,long,std::tuple<char,int,int>,__ops::_Iter_comp_iter<func0(std::string_const&,int)::{lambda(std::tuple<char,int,int>const&,std::tuple<char,int,int>const&)#1}>>:
LEA RAX,[RDX + -0x1]
... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::tuple<char, int, int>*,
std::vector<std::tuple<char, int, int>, std::allocator<std::tuple<char, int, int> > > >, long,
std::tuple<char, int, int>, __ops::_Iter_comp_iter<func0(std::string... |
3,783 | func0 | #include <cassert>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
#include <utility>
using namespace std;
| vector<pair<char, int>> func0(const string &s, int a) {
// Map to store frequency and first occurrence index
unordered_map<char, pair<int, int>> freq; // key: character, value: {count, first_index}
for (int i = 0; i < s.size(); ++i) {
char c = s[i];
if (freq.find(c) == freq.end()) {
... | int main(){
{
vector<pair<char, int>> expected = {{'s', 4}, {'e', 3}, {'f', 3}};
assert(func0("lkseropewdssafsdfafkpwe", 3) == expected);
}
{
vector<pair<char, int>> expected = {{'s', 4}, {'e', 3}};
assert(func0("lkseropewdssafsdfafkpwe", 2) == expected);
}
{... | O3 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::tuple<char, int, int>*, std::vector<std::tuple<char, int, int>, std::allocator<std::tuple<char, int, int> > > >, long, std::tuple<char, int, int>, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt5tupleIJciiEESt6vectorIS3_SaIS3_EEEElS3_NS0_5__ops15_Iter_comp_iterIZ5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiEUlRKS3_SK_E_EEEvT_T0_SO_T1_T2__isra_0:
lea rax, [rdx-1]
push r14
mov r9, rsi
mov r10, rdx
mov r11, rax
push r12
s... | long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::tuple<char,int,int> *,std::vector<std::tuple<char,int,int>>>,long,std::tuple<char,int,int>,__gnu_cxx::__ops::_Iter_comp_iter<func0(std::string const&,int)::{lambda(std::tuple<char,int,int> const&,std::tuple<char,int,int> const&)#1}>>(
long long a1,... | __adjust_heap<__normal_iterator<std::tuple<char,int,int>*,std::vector<std::tuple<char,int,int>,std::allocator<std::tuple<char,int,int>>>>,long,std::tuple<char,int,int>,__ops::_Iter_comp_iter<func0(std::string_const&,int)::{lambda(std::tuple<char,int,int>const&,std::tuple<char,int,int>const&)#1}>>:
LEA RAX,[RDX + -0x1]
... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::tuple<char, int, int>*,
std::vector<std::tuple<char, int, int>, std::allocator<std::tuple<char, int, int> > > >, long,
std::tuple<char, int, int>, __ops::_Iter_comp_iter<func0(std::string... |
3,784 | func0 |
#include <cassert>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
| int func0(vector<string> list1) {
int min = list1[0].size();
for (string i : list1) {
if (i.size() < min) {
min = i.size();
}
}
return min;
}
| int main() {
assert(func0({"win", "lose", "great"}) == 3);
assert(func0({"a", "ab", "abc"}) == 1);
assert(func0({"12", "12", "1234"}) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x60,%rsp
mov %rdi,-0x58(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rb... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push rbp
mov rbp, rsp
sub rsp, 60h
mov [rbp+var_58], rdi
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov rax, [rbp+var_58]
mov esi, 0
mov rdi, rax
call _ZNSt6vectorINSt7__cxx1112basic_... | long long func0(long long a1)
{
long long v1; // rax
long long v2; // rax
unsigned int v4; // [rsp+14h] [rbp-4Ch]
long long v5; // [rsp+18h] [rbp-48h] BYREF
_QWORD v6[2]; // [rsp+20h] [rbp-40h] BYREF
_BYTE v7[40]; // [rsp+30h] [rbp-30h] BYREF
unsigned long long v8; // [rsp+58h] [rbp-8h]
v8 = __readfsq... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x60
MOV qword ptr [RBP + -0x58],RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV ESI,0x0
MOV RDI,RAX
CALL 0x00102936
MOV RDI,RAX
CALL 0x00102250
MOV dword ptr [RBP + -0x4c],EAX
MOV RAX,qword ptr [RBP + -0x58]
MOV ... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
int func0(vector param_1)
{
bool bVar1;
string *psVar2;
ulong uVar3;
int4 in_register_0000003c;
vector<std::string,std::allocator<std::string>> *this;
long in_FS_OFFSET;
int local_54;
int8 local_50;
int8 local_48;
vector<std::str... |
3,785 | func0 |
#include <cassert>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
| int func0(vector<string> list1) {
int min = list1[0].size();
for (string i : list1) {
if (i.size() < min) {
min = i.size();
}
}
return min;
}
| int main() {
assert(func0({"win", "lose", "great"}) == 3);
assert(func0({"a", "ab", "abc"}) == 1);
assert(func0({"12", "12", "1234"}) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x38,%rsp
mov %fs:0x28,%rax
mov %rax,0x28(%rsp)
xo... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rax, fs:28h
mov [rsp+78h+var_40], rax
xor eax, eax
mov rbx, [rdi]
mov r12d, [rbx+8]
mov r14, [rdi+8]
cmp r14, r... | long long func0(_QWORD *a1)
{
long long v1; // rbx
unsigned int v2; // r12d
long long v3; // r14
_QWORD *v4; // rdi
_BYTE *v5; // r15
size_t v6; // rbp
size_t v8; // [rsp+8h] [rbp-70h] BYREF
void *v9; // [rsp+10h] [rbp-68h] BYREF
unsigned long long v10; // [rsp+18h] [rbp-60h]
_QWORD v11[11]; // [rs... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x48
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x38],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RDI]
MOV R12D,dword ptr [RBX + 0x8]
MOV R14,qword ptr [RDI + 0x8]
CMP R14,RBX
JZ 0x001013d6
LEA R13,[RSP + 0x20]
JMP 0x001013a1
LAB_00101326:
LEA RS... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
int func0(vector param_1)
{
int8 *puVar1;
int *__src;
ulong __n;
int8 *puVar2;
int4 in_register_0000003c;
int iVar3;
long in_FS_OFFSET;
ulong local_70;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
... |
3,786 | func0 |
#include <cassert>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
| int func0(vector<string> list1) {
int min = list1[0].size();
for (string i : list1) {
if (i.size() < min) {
min = i.size();
}
}
return min;
}
| int main() {
assert(func0({"win", "lose", "great"}) == 3);
assert(func0({"a", "ab", "abc"}) == 1);
assert(func0({"12", "12", "1234"}) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x30,%rsp
mov (%rdi),%rbx
mov 0x8(%rdi... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rcx, [rdi]
mov r13, [rdi+8]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov rbx, [rcx+8]
mov ebp, eb... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // r13
size_t v3; // rbx
unsigned int v4; // ebp
long long i; // r14
_QWORD *v6; // rax
_BYTE *v7; // r15
_QWORD *v8; // rdi
size_t v10; // [rsp+18h] [rbp-70h] BYREF
void *v11; // [rsp+20h] [rbp-68h] BYREF
unsigned long long v12;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RCX,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RCX + 0x8]
MOV EBP,EBX
CMP R13,RCX
JZ 0x00101600
LEA RAX,[RSP + 0x20]
MOV R14,RCX
LEA R12,[RSP... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong func0(vector param_1)
{
int8 *puVar1;
int *__src;
ulong __n;
ulong uVar2;
int4 in_register_0000003c;
int8 *puVar3;
long in_FS_OFFSET;
ulong local_70;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
... |
3,787 | func0 |
#include <cassert>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
| int func0(vector<string> list1) {
int min = list1[0].size();
for (string i : list1) {
if (i.size() < min) {
min = i.size();
}
}
return min;
}
| int main() {
assert(func0({"win", "lose", "great"}) == 3);
assert(func0({"a", "ab", "abc"}) == 1);
assert(func0({"12", "12", "1234"}) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x58,%rsp
mov (%rdi),%rbx
mov... | _Z5func0St6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS5_EE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 58h
mov rcx, [rdi]
mov r13, [rdi+8]
mov rax, fs:28h
mov [rsp+88h+var_40], rax
xor eax, eax
mov rbx, [rcx+8]
mov ebp, eb... | long long func0(long long *a1)
{
long long v1; // rcx
long long v2; // r13
size_t v3; // rbx
unsigned int v4; // ebp
long long i; // r14
_QWORD *v6; // rax
_BYTE *v7; // r15
_QWORD *v8; // rdi
size_t v10; // [rsp+18h] [rbp-70h] BYREF
void *v11; // [rsp+20h] [rbp-68h] BYREF
unsigned long long v12;... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x58
MOV RCX,qword ptr [RDI]
MOV R13,qword ptr [RDI + 0x8]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
MOV RBX,qword ptr [RCX + 0x8]
MOV EBP,EBX
CMP R13,RCX
JZ 0x00101610
LEA RAX,[RSP + 0x20]
MOV R14,RCX
LEA R12,[RSP... | /* func0(std::vector<std::string, std::allocator<std::string > >) */
ulong func0(vector param_1)
{
int8 *puVar1;
int *__src;
ulong __n;
ulong uVar2;
int4 in_register_0000003c;
int8 *puVar3;
long in_FS_OFFSET;
ulong local_70;
ulong *local_68;
ulong local_60;
ulong local_58 [3];
long local_40;
... |
3,788 | func0 |
#include <cassert>
#include <vector>
| char func0(const std::vector<char>& tup1, int index) {
if(index < 0){
index += tup1.size();
}
return tup1[index];
}
| int main(){
std::vector<char> tuple1 = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuple1, 3) == 'e');
assert(func0(tuple1, -4) == 'u');
assert(func0(tuple1, -3) == 'r');
}
| O0 | cpp | func0(std::vector<char, std::allocator<char> > const&, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %rdi,-0x8(%rbp)
mov %esi,-0xc(%rbp)
cmpl $0x0,-0xc(%rbp)
jns 12f8 <_Z5func0RKSt6vectorIcSaIcEEi+0x2f>
mov -0x8(%rbp),%rax
mov %rax,%rdi
callq 1490 <_ZNKSt6vectorIcSaIcEE4sizeEv>
mov ... | _Z5func0RKSt6vectorIcSaIcEEi:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_8], rdi
mov [rbp+var_C], esi
cmp [rbp+var_C], 0
jns short loc_1258
mov rax, [rbp+var_8]
mov rdi, rax
call _ZNKSt6vectorIcSaIcEE4sizeEv; std::vector<char>::size(void)
mov edx, eax
mov eax, ... | long long func0(long long a1, int a2)
{
int v3; // [rsp+4h] [rbp-Ch]
v3 = a2;
if ( a2 < 0 )
v3 = std::vector<char>::size(a1) + a2;
return *(unsigned __int8 *)std::vector<char>::operator[](a1, v3);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV qword ptr [RBP + -0x8],RDI
MOV dword ptr [RBP + -0xc],ESI
CMP dword ptr [RBP + -0xc],0x0
JNS 0x00101258
MOV RAX,qword ptr [RBP + -0x8]
MOV RDI,RAX
CALL 0x00101406
MOV EDX,EAX
MOV EAX,dword ptr [RBP + -0xc]
ADD EAX,EDX
MOV dword ptr [RBP + -0xc],EAX
LAB_00101258:
MOV ... | /* func0(std::vector<char, std::allocator<char> > const&, int) */
int func0(vector *param_1,int param_2)
{
int *puVar1;
int4 local_14;
local_14 = param_2;
if (param_2 < 0) {
local_14 = std::vector<char,std::allocator<char>>::size
((vector<char,std::allocator<char>> *)param_1);
... |
3,789 | func0 |
#include <cassert>
#include <vector>
| char func0(const std::vector<char>& tup1, int index) {
if(index < 0){
index += tup1.size();
}
return tup1[index];
}
| int main(){
std::vector<char> tuple1 = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuple1, 3) == 'e');
assert(func0(tuple1, -4) == 'u');
assert(func0(tuple1, -3) == 'r');
}
| O1 | cpp | func0(std::vector<char, std::allocator<char> > const&, int):
endbr64
test %esi,%esi
js 11bc <_Z5func0RKSt6vectorIcSaIcEEi+0x13>
movslq %esi,%rsi
mov (%rdi),%rax
movzbl (%rax,%rsi,1),%eax
retq
mov 0x8(%rdi),%rax
sub (%rdi),%rax
add %eax,%esi
jmp 11b1 <_Z5func0RKSt6vectorIcSaIcEEi+0x8>
| _Z5func0RKSt6vectorIcSaIcEEi:
endbr64
test esi, esi
js short loc_11BC
loc_11B1:
movsxd rsi, esi
mov rax, [rdi]
movzx eax, byte ptr [rax+rsi]
retn
loc_11BC:
mov rax, [rdi+8]
sub rax, [rdi]
add esi, eax
jmp short loc_11B1 | long long func0(_DWORD *a1, int a2)
{
if ( a2 < 0 )
a2 += a1[2] - *a1;
return *(unsigned __int8 *)(*(_QWORD *)a1 + a2);
} | func0:
ENDBR64
TEST ESI,ESI
JS 0x001011bc
LAB_001011b1:
MOVSXD RSI,ESI
MOV RAX,qword ptr [RDI]
MOVZX EAX,byte ptr [RAX + RSI*0x1]
RET
LAB_001011bc:
MOV RAX,qword ptr [RDI + 0x8]
SUB RAX,qword ptr [RDI]
ADD ESI,EAX
JMP 0x001011b1 | /* func0(std::vector<char, std::allocator<char> > const&, int) */
int func0(vector *param_1,int param_2)
{
if (param_2 < 0) {
param_2 = param_2 + ((int)*(int8 *)(param_1 + 8) - (int)*(int8 *)param_1);
}
return *(int *)(*(long *)param_1 + (long)param_2);
} |
3,790 | func0 |
#include <cassert>
#include <vector>
| char func0(const std::vector<char>& tup1, int index) {
if(index < 0){
index += tup1.size();
}
return tup1[index];
}
| int main(){
std::vector<char> tuple1 = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuple1, 3) == 'e');
assert(func0(tuple1, -4) == 'u');
assert(func0(tuple1, -3) == 'r');
}
| O2 | cpp | func0(std::vector<char, std::allocator<char> > const&, int):
endbr64
mov (%rdi),%rax
test %esi,%esi
jns 11c0 <_Z5func0RKSt6vectorIcSaIcEEi+0x10>
add 0x8(%rdi),%esi
sub %eax,%esi
movslq %esi,%rsi
movzbl (%rax,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIcSaIcEEi:
endbr64
mov rax, [rdi]
test esi, esi
jns short loc_11C0
add esi, [rdi+8]
sub esi, eax
loc_11C0:
movsxd rsi, esi
movzx eax, byte ptr [rax+rsi]
retn | long long func0(long long *a1, int a2)
{
long long v2; // rax
v2 = *a1;
if ( a2 < 0 )
a2 = *((_DWORD *)a1 + 2) + a2 - v2;
return *(unsigned __int8 *)(v2 + a2);
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
TEST ESI,ESI
JNS 0x001011c0
ADD ESI,dword ptr [RDI + 0x8]
SUB ESI,EAX
LAB_001011c0:
MOVSXD RSI,ESI
MOVZX EAX,byte ptr [RAX + RSI*0x1]
RET | /* func0(std::vector<char, std::allocator<char> > const&, int) */
int func0(vector *param_1,int param_2)
{
if (param_2 < 0) {
param_2 = (param_2 + *(int *)(param_1 + 8)) - (int)*(long *)param_1;
}
return *(int *)(*(long *)param_1 + (long)param_2);
} |
3,791 | func0 |
#include <cassert>
#include <vector>
| char func0(const std::vector<char>& tup1, int index) {
if(index < 0){
index += tup1.size();
}
return tup1[index];
}
| int main(){
std::vector<char> tuple1 = {'w', '3', 'r', 'e', 's', 'o', 'u', 'r', 'c', 'e'};
assert(func0(tuple1, 3) == 'e');
assert(func0(tuple1, -4) == 'u');
assert(func0(tuple1, -3) == 'r');
}
| O3 | cpp | func0(std::vector<char, std::allocator<char> > const&, int):
endbr64
mov (%rdi),%rax
test %esi,%esi
jns 11c0 <_Z5func0RKSt6vectorIcSaIcEEi+0x10>
add 0x8(%rdi),%esi
sub %eax,%esi
movslq %esi,%rsi
movzbl (%rax,%rsi,1),%eax
retq
nopl 0x0(%rax,%rax,1)
| _Z5func0RKSt6vectorIcSaIcEEi:
endbr64
mov rax, [rdi]
test esi, esi
jns short loc_11C0
add esi, [rdi+8]
sub esi, eax
loc_11C0:
movsxd rsi, esi
movzx eax, byte ptr [rax+rsi]
retn | long long func0(long long *a1, int a2)
{
long long v2; // rax
v2 = *a1;
if ( a2 < 0 )
a2 = *((_DWORD *)a1 + 2) + a2 - v2;
return *(unsigned __int8 *)(v2 + a2);
} | func0:
ENDBR64
MOV RAX,qword ptr [RDI]
TEST ESI,ESI
JNS 0x001011c0
ADD ESI,dword ptr [RDI + 0x8]
SUB ESI,EAX
LAB_001011c0:
MOVSXD RSI,ESI
MOVZX EAX,byte ptr [RAX + RSI*0x1]
RET | /* func0(std::vector<char, std::allocator<char> > const&, int) */
int func0(vector *param_1,int param_2)
{
if (param_2 < 0) {
param_2 = (param_2 + *(int *)(param_1 + 8)) - (int)*(long *)param_1;
}
return *(int *)(*(long *)param_1 + (long)param_2);
} |
3,792 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
int count_digs(const vector<int>& tup) {
int sum = 0;
for(auto ele : tup){
sum += to_string(ele).length();
}
return sum;
}
| string func0(vector<vector<int>> test_list){
sort(test_list.begin(), test_list.end(), [&](const vector<int>& a, const vector<int>& b) {
return count_digs(a) < count_digs(b);
});
string res = "[";
for(int i = 0; i < test_list.size(); i++){
res += "(";
for(int j = 0; j < tes... | int main(){
assert(func0(vector<vector<int>>{ {3,4,6,723}, {1,2}, {12345}, {134,234,34} }) == "[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]");
assert(func0(vector<vector<int>>{ {3,4,8}, {1,2}, {1234335}, {1345,234,334} }) == "[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]");
assert(func0(vector<... | O0 | cpp | func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > >)::{lambda(std::vector<int, std::allocator<int> > const&, std::vector<int, std::allocator<int> > const&)#1}::operator()(std::vector<int, std::allocator<int> > const&, std::vector<int, std::alloc... | _ZZ5func0B5cxx11St6vectorIS_IiSaIiEESaIS1_EEENKUlRKS1_S5_E_clES5_S5_:
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_18], rdi
mov [rbp+var_20], rsi
mov [rbp+var_28], rdx
mov rax, [rbp+var_20]
mov rdi, rax
call _Z10count_digsRKSt6vectorIiSaIiEE; count_digs(std::vector<int> ... | bool func0[abi:cxx11](std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}::operator()(
long long a1,
long long a2,
long long a3)
{
int v3; // ebx
v3 = count_digs(a2);
return v3 < (int)count_digs(a3);
} | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x68
MOV qword ptr [RBP + -0x68],RDI
MOV qword ptr [RBP + -0x70],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,RAX
CALL 0x00104ecc
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x70]
MOV RDI,RAX... | /* func0[abi:cxx11](std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > >) */
string * func0_abi_cxx11_(string *param_1,
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>
... |
3,793 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
int count_digs(const vector<int>& tup) {
int sum = 0;
for(auto ele : tup){
sum += to_string(ele).length();
}
return sum;
}
| string func0(vector<vector<int>> test_list){
sort(test_list.begin(), test_list.end(), [&](const vector<int>& a, const vector<int>& b) {
return count_digs(a) < count_digs(b);
});
string res = "[";
for(int i = 0; i < test_list.size(); i++){
res += "(";
for(int j = 0; j < tes... | int main(){
assert(func0(vector<vector<int>>{ {3,4,6,723}, {1,2}, {12345}, {134,234,34} }) == "[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]");
assert(func0(vector<vector<int>>{ {3,4,8}, {1,2}, {1234335}, {1345,234,334} }) == "[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]");
assert(func0(vector<... | O1 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::vector<int... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEElS4_NS0_5__ops15_Iter_comp_iterIZ5func0B5cxx11S7_EUlRKS4_SC_E_EEEvT_T0_SG_T1_T2_:
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 48h
mov rbx, rdi
mov r14, rsi
mov [rsp+78h+var_70], rdx... | unsigned long long std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,long,std::vector<int>,__gnu_cxx::__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
long long a1,
long... | __adjust_heap<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,long,std::vector<int,std::allocator<int>>,__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int,std::allocator<int>>,std::allocator<... | /* void std::__adjust_heap<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >,
__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<in... |
3,794 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
int count_digs(const vector<int>& tup) {
int sum = 0;
for(auto ele : tup){
sum += to_string(ele).length();
}
return sum;
}
| string func0(vector<vector<int>> test_list){
sort(test_list.begin(), test_list.end(), [&](const vector<int>& a, const vector<int>& b) {
return count_digs(a) < count_digs(b);
});
string res = "[";
for(int i = 0; i < test_list.size(); i++){
res += "(";
for(int j = 0; j < tes... | int main(){
assert(func0(vector<vector<int>>{ {3,4,6,723}, {1,2}, {12345}, {134,234,34} }) == "[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]");
assert(func0(vector<vector<int>>{ {3,4,8}, {1,2}, {1234335}, {1345,234,334} }) == "[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]");
assert(func0(vector<... | O2 | cpp | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, long, std::vector<int, std::allocator<int> >, __gnu_cxx::__ops::_Iter_comp_iter<func0(std::vector<std::vector<int... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEElS4_NS0_5__ops15_Iter_comp_iterIZ5func0B5cxx11S7_EUlRKS4_SC_E_EEEvT_T0_SG_T1_T2__isra_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 58h
mov [rsp+88h+var_80], rsi
mov q... | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,long,std::vector<int>,__gnu_cxx::__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
long long a1,
long long a2,
... | __adjust_heap<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,long,std::vector<int,std::allocator<int>>,__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int,std::allocator<int>>,std::allocator<... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, long, std::vector<int, std::allocator<... |
3,795 | func0 |
#include <bits/stdc++.h>
#include <cassert>
using namespace std;
int count_digs(const vector<int>& tup) {
int sum = 0;
for(auto ele : tup){
sum += to_string(ele).length();
}
return sum;
}
| string func0(vector<vector<int>> test_list){
sort(test_list.begin(), test_list.end(), [&](const vector<int>& a, const vector<int>& b) {
return count_digs(a) < count_digs(b);
});
string res = "[";
for(int i = 0; i < test_list.size(); i++){
res += "(";
for(int j = 0; j < tes... | int main(){
assert(func0(vector<vector<int>>{ {3,4,6,723}, {1,2}, {12345}, {134,234,34} }) == "[(1, 2), (12345,), (3, 4, 6, 723), (134, 234, 34)]");
assert(func0(vector<vector<int>>{ {3,4,8}, {1,2}, {1234335}, {1345,234,334} }) == "[(1, 2), (3, 4, 8), (1234335,), (1345, 234, 334)]");
assert(func0(vector<... | O3 | cpp | void std::__unguarded_linear_insert<__gnu_cxx::__normal_iterator<std::vector<int, std::allocator<int> >*, std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int> > > > >, __gnu_cxx::__ops::_Val_comp_iter<func0(std::vector<std::vector<int, std::allocator<int> >, std::alloc... | _ZSt13__adjust_heapIN9__gnu_cxx17__normal_iteratorIPSt6vectorIiSaIiEES2_IS4_SaIS4_EEEElS4_NS0_5__ops15_Iter_comp_iterIZ5func0B5cxx11S7_EUlRKS4_SC_E_EEEvT_T0_SG_T1_T2__isra_0:
push r15
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 58h
mov [rsp+88h+var_80], rsi
mov [... | void std::__adjust_heap<__gnu_cxx::__normal_iterator<std::vector<int> *,std::vector<std::vector<int>>>,long,std::vector<int>,__gnu_cxx::__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int>>)::{lambda(std::vector<int> const&,std::vector<int> const&)#1}>>(
long long a1,
long long a2,
... | __adjust_heap<__normal_iterator<std::vector<int,std::allocator<int>>*,std::vector<std::vector<int,std::allocator<int>>,std::allocator<std::vector<int,std::allocator<int>>>>>,long,std::vector<int,std::allocator<int>>,__ops::_Iter_comp_iter<func0[abi:cxx11](std::vector<std::vector<int,std::allocator<int>>,std::allocator<... | /* WARNING: Unknown calling convention -- yet parameter storage is locked */
/* void std::__adjust_heap<__normal_iterator<std::vector<int, std::allocator<int> >*,
std::vector<std::vector<int, std::allocator<int> >, std::allocator<std::vector<int,
std::allocator<int> > > > >, long, std::vector<int, std::allocator<... |
3,796 | func0 |
#include <cassert>
#include <string>
| std::string func0(int year) {
std::string sign;
int mod = (year - 2000) % 12;
if (mod < 0)
mod += 12;
if (mod == 0)
sign = "Dragon";
else if (mod == 1)
sign = "Snake";
else if (mod == 2)
sign = "Horse";
else if (mod == 3)
sign = "sheep";
... | int main() {
assert(func0(1997) == "Ox");
assert(func0(1998) == "Tiger");
assert(func0(1994) == "Dog");
}
| O0 | cpp | func0[abi:cxx11](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 -0x28(%rbp),%rax
mov %rax,%rdi
callq 1100 <_ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev@plt>
mov... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov [rbp+var_2C], esi
mov rax, [rbp+var_28]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1Ev; std::string::basic_string(void)
mov eax, [rbp+var_2C]
lea edx, [r... | long long func0[abi:cxx11](long long a1, int a2)
{
int v3; // [rsp+1Ch] [rbp-14h]
std::string::basic_string(a1);
v3 = (a2 - 2000) % 12 + ((a2 - 2000) % 12 < 0 ? 0xC : 0);
if ( v3 )
{
switch ( v3 )
{
case 1:
std::string::operator=(a1, "Snake");
break;
case 2:
std::... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV dword ptr [RBP + -0x2c],ESI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x00101160
MOV EAX,dword ptr [RBP + -0x2c]
LEA EDX,[RAX + -0x7d0]
MOVSXD RAX,EDX
IMUL RAX,RAX,0x2aaaaaab
SHR RAX,0x20
SAR EAX,0x1
MOV ECX,... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
int in_ESI;
int4 in_register_0000003c;
string *this;
int local_1c;
this = (string *)CONCAT44(in_register_0000003c,param_1);
std::string::string(this);
local_1c = in_ESI + -2000;
local_1c = local_1c + ((local_1c / 6 + (local_1c >> ... |
3,797 | func0 |
#include <cassert>
#include <string>
| std::string func0(int year) {
std::string sign;
int mod = (year - 2000) % 12;
if (mod < 0)
mod += 12;
if (mod == 0)
sign = "Dragon";
else if (mod == 1)
sign = "Snake";
else if (mod == 2)
sign = "Horse";
else if (mod == 3)
sign = "sheep";
... | int main() {
assert(func0(1997) == "Ox");
assert(func0(1998) == "Tiger");
assert(func0(1994) == "Dog");
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
lea 0x10(%rdi),%rbp
mov %rbp,(%rdi)
movq $0x0,0x8(%rdi)
movb $0x0,0x10(%rdi)
sub $0x7d0,%esi
movslq %esi,%rax
imul $0x2aaaaaab,%rax,%rax
sar $0x21,%rax
mov %esi,%edx
sar $0x1f,%edx
sub %edx,%eax
lea (%rax,%... | _Z5func0B5cxx11i:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbx, rdi
lea rax, [rdi+10h]
mov [rdi], rax
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
sub esi, 7D0h
movsxd rax, esi
imul rax, 2AAAAAABh
sar rax, 21h
mov edx, esi
sar edx, 1Fh
sub eax, edx
lea edx... | long long func0[abi:cxx11](long long a1, int a2)
{
int v2; // eax
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v2 = (a2 - 2000) % 12;
if ( v2 < 0 )
{
v2 += 12;
}
else if ( !v2 )
{
std::string::_M_replace(a1, 0LL, 0LL, "Dragon", 6LL);
return a1;
}
swi... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBX,RDI
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
SUB ESI,0x7d0
MOVSXD RAX,ESI
IMUL RAX,RAX,0x2aaaaaab
SAR RAX,0x21
MOV EDX,ESI
SAR EDX,0x1f
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
SHL EDX,0x2
MOV EAX,... | /* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int in_ESI;
int4 in_register_0000003c;
long *plVar2;
plVar2 = (long *)CONCAT44(in_register_0000003c,param_1);
*plVar2 = (long)(plVar2 + 2);
plVar2[1] = 0;
*(int *)(plVar2 + 2) = 0;
iVar1 = (in_ESI + -2000) % 0xc;
if (... |
3,798 | func0 |
#include <cassert>
#include <string>
| std::string func0(int year) {
std::string sign;
int mod = (year - 2000) % 12;
if (mod < 0)
mod += 12;
if (mod == 0)
sign = "Dragon";
else if (mod == 1)
sign = "Snake";
else if (mod == 2)
sign = "Horse";
else if (mod == 3)
sign = "sheep";
... | int main() {
assert(func0(1997) == "Ox");
assert(func0(1998) == "Tiger");
assert(func0(1994) == "Dog");
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
sub $0x7d0,%esi
push %r12
mov %rdi,%r12
movslq %esi,%rax
mov %esi,%edx
push %rbp
imul $0x2aaaaaab,%rax,%rax
sar $0x1f,%edx
push %rbx
lea 0x10(%rdi),%rbx
mov %rbx,(%rdi)
movq $0x0,0x8(%rdi)
sar $0x21,%rax
movb $0x0,0x10(%rdi)
sub %edx,%eax
lea (%rax,%... | _Z5func0B5cxx11i:
endbr64
push rbp
sub esi, 7D0h
lea rax, [rdi+10h]
push rbx
mov edx, esi
mov rbx, rdi
sar edx, 1Fh
sub rsp, 8
mov [rdi], rax
movsxd rax, esi
imul rax, 2AAAAAABh
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
sar rax, 21h
sub eax, edx
lea edx... | long long func0[abi:cxx11](long long a1, int a2)
{
int v2; // esi
int v3; // eax
v2 = a2 - 2000;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = v2 % 12;
if ( v2 % 12 < 0 )
{
v3 += 12;
}
else if ( !(v2 % 12) )
{
std::string::_M_replace(a1, 0LL, 0LL, "D... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
SUB ESI,0x7d0
LEA RAX,[RDI + 0x10]
PUSH RBX
MOV EDX,ESI
MOV RBX,RDI
SAR EDX,0x1f
SUB RSP,0x8
MOV qword ptr [RDI],RAX
MOVSXD RAX,ESI
IMUL RAX,RAX,0x2aaaaaab
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
SAR RAX,0x21
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
MOV EAX,ESI
SHL EDX,... | /* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int in_ESI;
int4 in_register_0000003c;
long *plVar2;
plVar2 = (long *)CONCAT44(in_register_0000003c,param_1);
*plVar2 = (long)(plVar2 + 2);
plVar2[1] = 0;
*(int *)(plVar2 + 2) = 0;
iVar1 = (in_ESI + -2000) % 0xc;
if (... |
3,799 | func0 |
#include <cassert>
#include <string>
| std::string func0(int year) {
std::string sign;
int mod = (year - 2000) % 12;
if (mod < 0)
mod += 12;
if (mod == 0)
sign = "Dragon";
else if (mod == 1)
sign = "Snake";
else if (mod == 2)
sign = "Horse";
else if (mod == 3)
sign = "sheep";
... | int main() {
assert(func0(1997) == "Ox");
assert(func0(1998) == "Tiger");
assert(func0(1994) == "Dog");
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
sub $0x7d0,%esi
push %r12
mov %rdi,%r12
movslq %esi,%rax
mov %esi,%edx
push %rbp
imul $0x2aaaaaab,%rax,%rax
sar $0x1f,%edx
push %rbx
lea 0x10(%rdi),%rbx
mov %rbx,(%rdi)
movq $0x0,0x8(%rdi)
sar $0x21,%rax
movb $0x0,0x10(%rdi)
sub %edx,%eax
lea (%rax,%... | _Z5func0B5cxx11i:
endbr64
push rbp
sub esi, 7D0h
lea rax, [rdi+10h]
push rbx
mov edx, esi
mov rbx, rdi
sar edx, 1Fh
sub rsp, 8
mov [rdi], rax
movsxd rax, esi
imul rax, 2AAAAAABh
mov qword ptr [rdi+8], 0
mov byte ptr [rdi+10h], 0
sar rax, 21h
sub eax, edx
lea edx... | long long func0[abi:cxx11](long long a1, int a2)
{
int v2; // esi
int v3; // eax
v2 = a2 - 2000;
*(_QWORD *)a1 = a1 + 16;
*(_QWORD *)(a1 + 8) = 0LL;
*(_BYTE *)(a1 + 16) = 0;
v3 = v2 % 12;
if ( v2 % 12 < 0 )
{
v3 += 12;
}
else if ( !(v2 % 12) )
{
std::string::_M_replace(a1, 0LL, 0LL, "D... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
SUB ESI,0x7d0
LEA RAX,[RDI + 0x10]
PUSH RBX
MOV EDX,ESI
MOV RBX,RDI
SAR EDX,0x1f
SUB RSP,0x8
MOV qword ptr [RDI],RAX
MOVSXD RAX,ESI
IMUL RAX,RAX,0x2aaaaaab
MOV qword ptr [RDI + 0x8],0x0
MOV byte ptr [RDI + 0x10],0x0
SAR RAX,0x21
SUB EAX,EDX
LEA EDX,[RAX + RAX*0x2]
MOV EAX,ESI
SHL EDX,... | /* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int in_ESI;
int4 in_register_0000003c;
long *plVar2;
plVar2 = (long *)CONCAT44(in_register_0000003c,param_1);
*plVar2 = (long)(plVar2 + 2);
plVar2[1] = 0;
*(int *)(plVar2 + 2) = 0;
iVar1 = (in_ESI + -2000) % 0xc;
if (... |
3,800 | func0 | #include <vector>
#include <utility>
#include <cassert>
#include <algorithm>
using namespace std;
| vector<pair<int, int>> func0(const vector<pair<int, int>>& test_list1, const vector<pair<int, int>>& test_list2) {
vector<pair<int, int>> res;
for (size_t i = 0; i < test_list1.size(); ++i) {
res.push_back({ max(test_list1[i].first, test_list2[i].first),
max(test_list1[i].sec... | int main() {
{
vector<pair<int,int>> result = func0({{2, 4}, {6, 7}, {5, 1}},
{{5, 4}, {8, 10}, {8, 14}});
vector<pair<int,int>> expected = {{5, 4}, {8, 10}, {8, 14}};
assert(result == expected);
}
{
ve... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r12
push %rbx
sub $0x40,%rsp
mov %rdi,-0x38(%rbp)
mov %rsi,-0x40(%rbp)
mov %rdx,-0x48(%rbp)
mo... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EES5_:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
sub rsp, 40h
mov [rbp+var_38], rdi
mov [rbp+var_40], rsi
mov [rbp+var_48], rdx
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6... | long long func0(long long a1, long long a2, long long a3)
{
long long v3; // rbx
long long v4; // rax
long long v5; // r12
long long v6; // rbx
long long v7; // rax
long long v8; // rax
unsigned long long i; // [rsp+28h] [rbp-28h]
_BYTE v12[8]; // [rsp+30h] [rbp-20h] BYREF
unsigned long long v13; // ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
SUB RSP,0x40
MOV qword ptr [RBP + -0x38],RDI
MOV qword ptr [RBP + -0x40],RSI
MOV qword ptr [RBP + -0x48],RDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101df8
MOV qword ptr [RBP + -0x2... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int *piVar1;
int *piVar2;
long lVar3;
long lVar4;
ulong uVar5;
vector<std::pair<i... |
3,801 | func0 | #include <vector>
#include <utility>
#include <cassert>
#include <algorithm>
using namespace std;
| vector<pair<int, int>> func0(const vector<pair<int, int>>& test_list1, const vector<pair<int, int>>& test_list2) {
vector<pair<int, int>> res;
for (size_t i = 0; i < test_list1.size(); ++i) {
res.push_back({ max(test_list1[i].first, test_list2[i].first),
max(test_list1[i].sec... | int main() {
{
vector<pair<int,int>> result = func0({{2, 4}, {6, 7}, {5, 1}},
{{5, 4}, {8, 10}, {8, 14}});
vector<pair<int,int>> expected = {{5, 4}, {8, 10}, {8, 14}};
assert(result == expected);
}
{
ve... | O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, std::vector<std::pair<int, int>, std::allocator<std::pair<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 ... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_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]
c... | _QWORD * func0(_QWORD *a1, long long *a2, _QWORD *a3)
{
long long v3; // rax
unsigned long long v6; // rbp
_QWORD *v7; // rsi
_DWORD *v8; // rdx
_DWORD *v9; // rax
_DWORD *v10; // rsi
_DWORD *v11; // rcx
_QWORD v13[7]; // [rsp+0h] [rbp-38h] BYREF
v13[1] = __readfsqword(0x28u);
*a1 = 0LL;
a1[1] = ... | 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 0x001012e2
MOV R12,RSI
... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int8 *puVar1;
long lVar2;
int *piVar3;
long *in_RDX;
int *piVar4;
ulong uVar5;
... |
3,802 | func0 | #include <vector>
#include <utility>
#include <cassert>
#include <algorithm>
using namespace std;
| vector<pair<int, int>> func0(const vector<pair<int, int>>& test_list1, const vector<pair<int, int>>& test_list2) {
vector<pair<int, int>> res;
for (size_t i = 0; i < test_list1.size(); ++i) {
res.push_back({ max(test_list1[i].first, test_list2[i].first),
max(test_list1[i].sec... | int main() {
{
vector<pair<int,int>> result = func0({{2, 4}, {6, 7}, {5, 1}},
{{5, 4}, {8, 10}, {8, 14}});
vector<pair<int,int>> expected = {{5, 4}, {8, 10}, {8, 14}};
assert(result == expected);
}
{
ve... | O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, std::vector<std::pair<int, int>, std::allocator<std::pair<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 ... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
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
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi]
cmp ... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdi
long long v7; // r8
long long v8; // rsi
long long v9; // rbx
long long v10; // rsi
int *v11; // r9
int *v12; // rax
int v13; // edx
int v14; // ecx
int v15; // eax
int v16; // edx
_QWORD v18[7]; // [rsp+0h] [rbp-38... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
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
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x001017a0
MOV R12,RSI
MOV R13,R... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int iVar2;
int *piVar3;
long *in_RDX;
ulong uVar4;
int8 *puVar5;
lon... |
3,803 | func0 | #include <vector>
#include <utility>
#include <cassert>
#include <algorithm>
using namespace std;
| vector<pair<int, int>> func0(const vector<pair<int, int>>& test_list1, const vector<pair<int, int>>& test_list2) {
vector<pair<int, int>> res;
for (size_t i = 0; i < test_list1.size(); ++i) {
res.push_back({ max(test_list1[i].first, test_list2[i].first),
max(test_list1[i].sec... | int main() {
{
vector<pair<int,int>> result = func0({{2, 4}, {6, 7}, {5, 1}},
{{5, 4}, {8, 10}, {8, 14}});
vector<pair<int,int>> expected = {{5, 4}, {8, 10}, {8, 14}};
assert(result == expected);
}
{
ve... | O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&, std::vector<std::pair<int, int>, std::allocator<std::pair<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 %ra... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EES5_:
endbr64
push r14
pxor xmm0, xmm0
push r13
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
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rdi, [rsi]
cmp ... | long long func0(long long a1, long long *a2, _QWORD *a3)
{
long long v4; // rdi
long long v7; // r8
long long v8; // rsi
long long v9; // rbx
long long v10; // rsi
int *v11; // r9
int *v12; // rax
int v13; // edx
int v14; // ecx
int v15; // eax
int v16; // edx
_QWORD v18[7]; // [rsp+0h] [rbp-38... | func0:
ENDBR64
PUSH R14
PXOR XMM0,XMM0
PUSH R13
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
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,qword ptr [RSI]
CMP qword ptr [RSI + 0x8],RDI
JZ 0x001017c0
MOV R12,RSI
MOV R13,R... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&,
std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1,vector *param_2)
{
int iVar1;
int iVar2;
int *piVar3;
long *in_RDX;
ulong uVar4;
int8 *puVar5;
lon... |
3,804 | func0 |
#include <vector>
#include <cassert>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
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(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
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
mov -0x48(%rbp),%eax
mov -0x44(%rbp),%edx
sub %eax,%edx
mov -0x48(%rbp),%eax
cmp %... | _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
mov eax, [rbp+var_58]
mov edx, [rbp+var_54]
sub edx, eax
mov eax, [rbp+var_58]
cmp ... | 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
MOV EAX,dword ptr [RBP + -0x58]
MOV EDX,dword ptr [RBP + -0x54]
SUB EDX,EAX
MOV EAX,dword ptr ... | /* 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_... |
3,805 | func0 |
#include <vector>
#include <cassert>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
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(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x8,%rsp
mov %edx,%ebx
mov %edi,%ebp
sub %esi,%ebp
cmp %esi,%ebp
cmovg %esi,%ebp
lea 0x1(%rbp),%eax
cltq
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1224 <_Z5func0iii+0x7b>
mov %edi,%r12d
mov $0x0,%r8... | _Z5func0iii:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 8
mov ebp, edi
sub ebp, esi
cmp ebp, esi
cmovg ebp, esi
lea r13d, [rbp+1]
movsxd r13, r13d
mov rax, r13
shr rax, 3Dh
jnz short loc_1219
mov r12d, edi
mov ebx, edx
mov r8d, 0
test r13, r13
jz ... | long long func0(int a1, int a2, int a3)
{
int v3; // ebp
unsigned long long v4; // 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 = a1 - a2;
if ( a1 - a2 > a2 )... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBP,EDI
SUB EBP,ESI
CMP EBP,ESI
CMOVG EBP,ESI
LEA R13D,[RBP + 0x1]
MOVSXD R13,R13D
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101219
MOV R12D,EDI
MOV EBX,EDX
MOV R8D,0x0
TEST R13,R13
JZ 0x00101202
SHL R13,0x2
MOV RDI,R13
CALL 0x001010a0
MOV R8,RAX
LEA RDX,[RAX + ... | /* 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 iVar6;
int4 *in_R8;
int4 *in_R9;
int unaff_R12D;
ulong uVar7;
ulong uVar8;
bool bVar9;
iVar6 = param_1 - param_2;
if (param_2 < ... |
3,806 | func0 |
#include <vector>
#include <cassert>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
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(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
push %r12
push %rbp
mov %edi,%ebp
push %rbx
sub %esi,%ebp
sub $0x8,%rsp
cmp %esi,%ebp
cmovg %esi,%ebp
lea 0x1(%rbp),%r13d
movslq %r13d,%r13
cmp %rax,%r13
ja 136b <_Z5func0iii+0xeb>
test %r13,%r13
je 10c0 <_Z5fun... | _Z5func0iii:
endbr64
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub ebp, esi
sub rsp, 8
cmp ebp, esi
cmovg ebp, esi
lea r13d, [rbp+1]
movsxd r13, r13d
mov rax, r13
shr rax, 3Dh
jnz loc_1385
test r13, r13
jz _Z5func0iii_cold; func0(int,int,int) [clone]
shl ... | long long func0(int a1, int a2, int a3)
{
int v3; // ebp
unsigned long long v4; // 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 i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB EBP,ESI
SUB RSP,0x8
CMP EBP,ESI
CMOVG EBP,ESI
LEA R13D,[RBP + 0x1]
MOVSXD R13,R13D
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101385
TEST R13,R13
JZ 0x001010e0
SHL R13,0x2
MOV R12D,EDI
MOV EBX,EDX
MOV RDI,R13
CALL 0x001010c0
MOV RDX,R13
XOR ESI,ESI
MOV RDI,RAX
CA... | /* 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... |
3,807 | func0 |
#include <vector>
#include <cassert>
| int func0(int n, int r, int p) {
if (r > n - r)
r = n - r;
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(11, 3, 14) == 11);
assert(func0(18, 14, 19) == 1);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
movabs $0x1fffffffffffffff,%rax
push %r13
push %r12
push %rbp
mov %edi,%ebp
push %rbx
sub %esi,%ebp
sub $0x8,%rsp
cmp %esi,%ebp
cmovg %esi,%ebp
lea 0x1(%rbp),%r13d
movslq %r13d,%r13
cmp %rax,%r13
ja 137b <_Z5func0iii+0xdb>
test %r13,%r13
je 10e0 <_Z5fun... | _Z5func0iii:
endbr64
push r13
push r12
push rbp
mov ebp, edi
push rbx
sub ebp, esi
sub rsp, 8
cmp ebp, esi
cmovg ebp, esi
lea r13d, [rbp+1]
movsxd r13, r13d
mov rax, r13
shr rax, 3Dh
jnz loc_1385
test r13, r13
jz _Z5func0iii_cold; func0(int,int,int) [clone]
shl ... | long long func0(int a1, int a2, int a3)
{
int v3; // ebp
unsigned long long v4; // 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 i... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
MOV EBP,EDI
PUSH RBX
SUB EBP,ESI
SUB RSP,0x8
CMP EBP,ESI
CMOVG EBP,ESI
LEA R13D,[RBP + 0x1]
MOVSXD R13,R13D
MOV RAX,R13
SHR RAX,0x3d
JNZ 0x00101385
TEST R13,R13
JZ 0x001010e0
SHL R13,0x2
MOV R12D,EDI
MOV EBX,EDX
MOV RDI,R13
CALL 0x001010c0
MOV RDX,R13
XOR ESI,ESI
MOV RDI,RAX
CA... | /* 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... |
3,808 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> ar, int n) {
int res = 0;
std::sort(ar.begin(), ar.end());
for (int i = 0 ; i < n; ++i) {
int count = 1;
for (int j = i; j < n - 1; ++j) {
if (ar[j] == ar[j + 1]) {
count += 1;
} else {
break;
... | int main() {
assert(func0({1, 2, 3, 4}, 4) == 1);
assert(func0({5, 6, 9, 3, 4, 3, 4}, 7) == 2);
assert(func0({1, 2, 3}, 3) == 1);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x38,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
movl $0x0,-0x28(%rbp)
mov -0x38(%rbp),%rax
mov %rax,%rdi
callq 17be <_ZNSt6vectorI... | _Z5func0St6vectorIiSaIiEEi:
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 [rbp+var_28], 0
mov rax, [rbp+var_38]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vec... | long long func0(long long a1, int a2)
{
long long v2; // rbx
long long v3; // rax
int v4; // ebx
unsigned int v6; // [rsp+18h] [rbp-28h] BYREF
int v7; // [rsp+1Ch] [rbp-24h] BYREF
int i; // [rsp+20h] [rbp-20h]
int j; // [rsp+24h] [rbp-1Ch]
unsigned long long v10; // [rsp+28h] [rbp-18h]
v10 = __readf... | func0:
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 dword ptr [RBP + -0x28],0x0
MOV RAX,qword ptr [RBP + -0x38]
MOV RDI,RAX
CALL 0x00101724
MOV RBX,RAX
MOV RAX,qword ptr [RBP... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int iVar1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int *piVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
long in_FS_OFFSET;
int local_30;
int local_2c;
int local_28;
... |
3,809 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> ar, int n) {
int res = 0;
std::sort(ar.begin(), ar.end());
for (int i = 0 ; i < n; ++i) {
int count = 1;
for (int j = i; j < n - 1; ++j) {
if (ar[j] == ar[j + 1]) {
count += 1;
} else {
break;
... | int main() {
assert(func0({1, 2, 3, 4}, 4) == 1);
assert(func0({5, 6, 9, 3, 4, 3, 4}, 7) == 2);
assert(func0({1, 2, 3}, 3) == 1);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
mov %rdi,%rbx
mov %esi,%ebp
mov 0x8(%rdi),%r13
mov (%rdi),%r14
cmp %r14,%r13
je 1310 <_Z5func0St6vectorIiSaIiEEi+0xa7>
mov %r13,%r12
sub %r14,%r12
mov %r12,%rax
sar $0x2... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
push rbx
mov rbx, rdi
mov ebp, esi
mov r13, [rdi+8]
mov r14, [rdi]
cmp r13, r14
jz loc_12D6
mov r12, r13
sub r12, r14
mov rdx, r12
sar rdx, 2
mov eax, 40h ; '@'
jz short loc_1265
bsr ... | long long func0(char **a1, int a2)
{
char *v4; // r13
char *v5; // r14
int v6; // eax
unsigned long long v7; // rax
char *v8; // r12
int v9; // ecx
char *v10; // rax
int v11; // edx
char *v12; // rsi
int v13; // ecx
long long v14; // r8
long long v15; // rsi
int v16; // edi
int v17; // ebp
... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
MOV EBP,ESI
MOV R13,qword ptr [RDI + 0x8]
MOV R14,qword ptr [RDI]
CMP R13,R14
JZ 0x001012d6
MOV R12,R13
SUB R12,R14
MOV RDX,R12
SAR RDX,0x2
MOV EAX,0x40
JZ 0x00101265
BSR RAX,RDX
XOR EAX,0x3f
LAB_00101265:
MOV EDX,0x3f
SUB EDX,EAX
MOVSXD RDX,EDX
AD... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
int *piVar3;
int *piVar4;
uint uVar5;
int *piVar6;
_Iter_less_iter in_ECX;
_Iter_less_iter extraout_EDX;
int iVar7;
int iVar8;
ulong uVar9;
int iVar10;
long lVar11;
__... |
3,810 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> ar, int n) {
int res = 0;
std::sort(ar.begin(), ar.end());
for (int i = 0 ; i < n; ++i) {
int count = 1;
for (int j = i; j < n - 1; ++j) {
if (ar[j] == ar[j + 1]) {
count += 1;
} else {
break;
... | int main() {
assert(func0({1, 2, 3, 4}, 4) == 1);
assert(func0({5, 6, 9, 3, 4, 3, 4}, 7) == 2);
assert(func0({1, 2, 3}, 3) == 1);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
mov 0x8(%rdi),%r13
mov %esi,%ebx
mov (%rdi),%r14
cmp %r14,%r13
je 150c <_Z5func0St6vectorIiSaIiEEi+0x9c>
mov %r13,%r12
mov $0x3f,%edx
mov %r13,%rsi
mov %r1... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov r13, [rdi+8]
mov ebx, esi
mov r14, [rdi]
cmp r13, r14
jz loc_17FC
mov r12, r13
mov rdx, 0FFFFFFFFFFFFFFFEh
sub r12, r14
mov rax, r12
sar rax, 2
jz short loc_... | long long func0(char **a1, int a2)
{
char *v3; // r13
char *v5; // r14
long long v6; // rdx
unsigned long long v7; // rax
char *v8; // r12
int v9; // ecx
int v10; // edx
char *v11; // rax
char *v12; // rsi
int v13; // edi
long long v14; // r10
int v15; // r9d
int v16; // r8d
int v17; // edx... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV R13,qword ptr [RDI + 0x8]
MOV EBX,ESI
MOV R14,qword ptr [RDI]
CMP R13,R14
JZ 0x001017fc
MOV R12,R13
MOV RDX,-0x2
SUB R12,R14
MOV RAX,R12
SAR RAX,0x2
JZ 0x00101791
BSR RAX,RAX
CDQE
LEA RDX,[RAX + RAX*0x1]
LAB_00101791:
MOV RSI,R13
MOV RDI,R14
CA... | /* func0(std::vector<int, std::allocator<int> >, int) */
int func0(vector param_1,int param_2)
{
int *piVar1;
int *piVar2;
ulong uVar3;
int *piVar4;
int *piVar5;
_Iter_less_iter in_ECX;
int iVar6;
_Iter_less_iter extraout_EDX;
int iVar7;
long lVar8;
__normal_iterator _Var9;
int iVar10;
int4 ... |
3,811 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(std::vector<int> ar, int n) {
int res = 0;
std::sort(ar.begin(), ar.end());
for (int i = 0 ; i < n; ++i) {
int count = 1;
for (int j = i; j < n - 1; ++j) {
if (ar[j] == ar[j + 1]) {
count += 1;
} else {
break;
... | int main() {
assert(func0({1, 2, 3, 4}, 4) == 1);
assert(func0({5, 6, 9, 3, 4, 3, 4}, 7) == 2);
assert(func0({1, 2, 3}, 3) == 1);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >, int):
endbr64
push %r15
push %r14
push %r13
mov %rdi,%r13
push %r12
push %rbp
push %rbx
mov %esi,%ebx
sub $0x18,%rsp
mov 0x8(%rdi),%r12
mov (%rdi),%rbp
cmp %rbp,%r12
je 156c <_Z5func0St6vectorIiSaIiEEi+0x11c>
mov %r12,%r14
mov $0x3f,%... | _Z5func0St6vectorIiSaIiEEi:
endbr64
push r15
push r14
push r13
push r12
push rbp
mov rbp, rdi
push rbx
mov ebx, esi
sub rsp, 18h
mov r13, [rdi+8]
mov r15, [rdi]
cmp r13, r15
jz loc_178C
mov r14, r13
lea r12, [r15+4]
sub r14, r15
mov rax, r14
sar rax, 2
... | long long func0(char **a1, int a2)
{
char *v4; // r13
char *v5; // r15
char *v6; // r12
unsigned long long v7; // rdx
char *v8; // r14
int v9; // ecx
char *v10; // rsi
int v11; // edx
char *j; // rax
char *v13; // rcx
int v14; // esi
int v15; // edx
char *v16; // rdi
char *v17; // rax
sig... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
MOV RBP,RDI
PUSH RBX
MOV EBX,ESI
SUB RSP,0x18
MOV R13,qword ptr [RDI + 0x8]
MOV R15,qword ptr [RDI]
CMP R13,R15
JZ 0x0010178c
MOV R14,R13
LEA R12,[R15 + 0x4]
SUB R14,R15
MOV RAX,R14
SAR RAX,0x2
JZ 0x001018c1
BSR RDX,RAX
MOV RSI,R13
MOV RDI,R15
MOVSXD RDX,EDX
A... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(std::vector<int, std::allocator<int> >, int) */
uint func0(vector param_1,int param_2,int param_3,int param_4,int param_5,
int param_6,int param_7,int param_8,int param_9,int param_10
,int4 param_11)
{
... |
3,812 | func0 |
#include <iostream>
#include <cassert>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return 0; // Using 0 to represent None
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == 0); // Expecting 0 instead of None
assert(func0(2000, 5000) == 0); // Expecting 0 instead of None
std::cout << "All tests passed!" << std::endl;
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
jle 11e7 <_Z5func0ii+0x1e>
mov -0x4(%rbp),%eax
sub -0x8(%rbp),%eax
jmp 11ec <_Z5func0ii+0x23>
mov $0x0,%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]
jle short loc_11A7
mov eax, [rbp+var_4]
sub eax, [rbp+var_8]
jmp short loc_11AC
loc_11A7:
mov eax, 0
loc_11AC:
pop rbp
retn | long long func0(int a1, int a2)
{
if ( a1 <= a2 )
return 0LL;
else
return (unsigned int)(a1 - a2);
} | 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]
JLE 0x001011a7
MOV EAX,dword ptr [RBP + -0x4]
SUB EAX,dword ptr [RBP + -0x8]
JMP 0x001011ac
LAB_001011a7:
MOV EAX,0x0
LAB_001011ac:
POP RBP
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
if (param_2 < param_1) {
iVar1 = param_1 - param_2;
}
else {
iVar1 = 0;
}
return iVar1;
} |
3,813 | func0 |
#include <iostream>
#include <cassert>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return 0; // Using 0 to represent None
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == 0); // Expecting 0 instead of None
assert(func0(2000, 5000) == 0); // Expecting 0 instead of None
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
mov %edi,%eax
sub %esi,%eax
cmp %esi,%edi
mov $0x0,%edx
cmovle %edx,%eax
retq
| _Z5func0ii:
endbr64
mov eax, edi
sub eax, esi
cmp edi, esi
mov edx, 0
cmovle eax, edx
retn | long long func0(int a1, int a2)
{
long long result; // rax
result = (unsigned int)(a1 - a2);
if ( a1 <= a2 )
return 0LL;
return result;
} | func0:
ENDBR64
MOV EAX,EDI
SUB EAX,ESI
CMP EDI,ESI
MOV EDX,0x0
CMOVLE EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1 - param_2;
if (param_1 <= param_2) {
iVar1 = 0;
}
return iVar1;
} |
3,814 | func0 |
#include <iostream>
#include <cassert>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return 0; // Using 0 to represent None
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == 0); // Expecting 0 instead of None
assert(func0(2000, 5000) == 0); // Expecting 0 instead of None
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
mov %edi,%eax
mov $0x0,%edx
sub %esi,%eax
cmp %esi,%edi
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0ii:
endbr64
mov eax, edi
xor edx, edx
sub eax, esi
cmp edi, esi
cmovle eax, edx
retn | long long func0(int a1, int a2)
{
long long result; // rax
result = (unsigned int)(a1 - a2);
if ( a1 <= a2 )
return 0LL;
return result;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EDX,EDX
SUB EAX,ESI
CMP EDI,ESI
CMOVLE EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1 - param_2;
if (param_1 <= param_2) {
iVar1 = 0;
}
return iVar1;
} |
3,815 | func0 |
#include <iostream>
#include <cassert>
| int func0(int actual_cost, int sale_amount) {
if (actual_cost > sale_amount) {
return actual_cost - sale_amount;
} else {
return 0; // Using 0 to represent None
}
}
| int main() {
assert(func0(1500, 1200) == 300);
assert(func0(100, 200) == 0); // Expecting 0 instead of None
assert(func0(2000, 5000) == 0); // Expecting 0 instead of None
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
mov %edi,%eax
mov $0x0,%edx
sub %esi,%eax
cmp %esi,%edi
cmovle %edx,%eax
retq
nopw %cs:0x0(%rax,%rax,1)
nopl (%rax)
| _Z5func0ii:
endbr64
mov eax, edi
xor edx, edx
sub eax, esi
cmp edi, esi
cmovle eax, edx
retn | long long func0(int a1, int a2)
{
long long result; // rax
result = (unsigned int)(a1 - a2);
if ( a1 <= a2 )
return 0LL;
return result;
} | func0:
ENDBR64
MOV EAX,EDI
XOR EDX,EDX
SUB EAX,ESI
CMP EDI,ESI
CMOVLE EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
int iVar1;
iVar1 = param_1 - param_2;
if (param_1 <= param_2) {
iVar1 = 0;
}
return iVar1;
} |
3,816 | func0 |
#include <iostream>
#include <cassert>
| bool func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; ++fctr) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == true);
assert(func0(13) == false);
assert(func0(9) == false);
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
jge 11c3 <_Z5func0i+0x3a>
mov -0x14(%rbp),%eax
cltd
idivl -0x4(%rbp)
mov %edx,%eax
test %eax,%eax
jne 11bd <_Z5func0i+0x34>
mov -0x4(%rb... | _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_117B
loc_1164:
mov eax, [rbp+var_14]
cdq
idiv [rbp+var_4]
mov eax, edx
test eax, eax
jnz short loc_1177
mov eax, [rbp+var_4]
add [rbp+var_8], eax
loc_1177:
... | bool func0(int a1)
{
int v2; // [rsp+Ch] [rbp-8h]
int i; // [rsp+10h] [rbp-4h]
v2 = 0;
for ( i = 1; i < a1; ++i )
{
if ( !(a1 % i) )
v2 += i;
}
return v2 > a1;
} | 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 0x0010117b
LAB_00101164:
MOV EAX,dword ptr [RBP + -0x14]
CDQ
IDIV dword ptr [RBP + -0x4]
MOV EAX,EDX
TEST EAX,EAX
JNZ 0x00101177
MOV EAX,dword ptr [RBP + -0x4]
ADD dword ptr [RBP + -0x8]... | /* func0(int) */
int4 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) {
if (param_1 % local_c == 0) {
local_10 = local_10 + local_c;
}
}
return CONCAT31((int3)((uint)local_10 >> 8),param_1 < local_10);
} |
3,817 | func0 |
#include <iostream>
#include <cassert>
| bool func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; ++fctr) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == true);
assert(func0(13) == false);
assert(func0(9) == false);
return 0;
}
| O1 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 11b6 <_Z5func0i+0x2d>
mov $0x1,%ecx
mov $0x0,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 119c <_Z5func0i+0x13>
cmp %esi,%edi
setl %al
retq
mov $0x0,%esi
jmp 11b0 <... | _Z5func0i:
endbr64
cmp edi, 1
jle short loc_1176
mov ecx, 1
mov esi, 0
loc_115C:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_115C
loc_1170:
cmp edi, esi
setl al
retn
loc_1176:
mov esi, 0
jmp sh... | bool func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
{
v2 = 0;
}
else
{
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
}
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101176
MOV ECX,0x1
MOV ESI,0x0
LAB_0010115c:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x0010115c
LAB_00101170:
CMP EDI,ESI
SETL AL
RET
LAB_00101176:
MOV ESI,0x0
JMP 0x00101170 | /* func0(int) */
bool func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 < 2) {
iVar2 = 0;
}
else {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
}
return param_1 < iVar2... |
3,818 | func0 |
#include <iostream>
#include <cassert>
| bool func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; ++fctr) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == true);
assert(func0(13) == false);
assert(func0(9) == false);
return 0;
}
| O2 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 12f0 <_Z5func0i+0x30>
mov $0x1,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 12d0 <_Z5func0i+0x10>
cmp %esi,%edi
setl %al
retq
nopw 0x0(%rax,%rax,1)
xor ... | _Z5func0i:
endbr64
cmp edi, 1
jle short loc_1270
mov ecx, 1
xor esi, esi
loc_1250:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1250
cmp edi, esi
setl al
retn
loc_1270:
xor esi, esi
cmp edi, esi... | bool func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
return a1 < 0;
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101270
MOV ECX,0x1
XOR ESI,ESI
LAB_00101250:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101250
CMP EDI,ESI
SETL AL
RET
LAB_00101270:
XOR ESI,ESI
CMP EDI,ESI
SETL AL
RET | /* func0(int) */
bool func0(int param_1)
{
int iVar1;
int iVar2;
if (1 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return param_1 < iVar2;
}
return param_1 < 0;
} |
3,819 | func0 |
#include <iostream>
#include <cassert>
| bool func0(int n) {
int fctrsum = 0;
for (int fctr = 1; fctr < n; ++fctr) {
if (n % fctr == 0) {
fctrsum += fctr;
}
}
return fctrsum > n;
}
| int main() {
assert(func0(12) == true);
assert(func0(13) == false);
assert(func0(9) == false);
return 0;
}
| O3 | cpp | func0(int):
endbr64
cmp $0x1,%edi
jle 11f0 <_Z5func0i+0x30>
mov $0x1,%ecx
xor %esi,%esi
mov %edi,%eax
cltd
idiv %ecx
lea (%rsi,%rcx,1),%eax
test %edx,%edx
cmove %eax,%esi
add $0x1,%ecx
cmp %ecx,%edi
jne 11d0 <_Z5func0i+0x10>
cmp %esi,%edi
setl %al
retq
nopw 0x0(%rax,%rax,1)
xor ... | _Z5func0i:
endbr64
cmp edi, 1
jle short loc_1170
mov ecx, 1
xor esi, esi
loc_1150:
mov eax, edi
cdq
idiv ecx
lea eax, [rsi+rcx]
test edx, edx
cmovz esi, eax
add ecx, 1
cmp edi, ecx
jnz short loc_1150
cmp edi, esi
setl al
retn
loc_1170:
xor esi, esi
cmp edi, esi... | bool func0(int a1)
{
int v1; // ecx
int v2; // esi
if ( a1 <= 1 )
return a1 < 0;
v1 = 1;
v2 = 0;
do
{
if ( !(a1 % v1) )
v2 += v1;
++v1;
}
while ( a1 != v1 );
return a1 < v2;
} | func0:
ENDBR64
CMP EDI,0x1
JLE 0x00101170
MOV ECX,0x1
XOR ESI,ESI
LAB_00101150:
MOV EAX,EDI
CDQ
IDIV ECX
LEA EAX,[RSI + RCX*0x1]
TEST EDX,EDX
CMOVZ ESI,EAX
ADD ECX,0x1
CMP EDI,ECX
JNZ 0x00101150
CMP EDI,ESI
SETL AL
RET
LAB_00101170:
XOR ESI,ESI
CMP EDI,ESI
SETL AL
RET | /* func0(int) */
bool func0(int param_1)
{
int iVar1;
int iVar2;
if (1 < param_1) {
iVar1 = 1;
iVar2 = 0;
do {
if (param_1 % iVar1 == 0) {
iVar2 = iVar2 + iVar1;
}
iVar1 = iVar1 + 1;
} while (param_1 != iVar1);
return param_1 < iVar2;
}
return param_1 < 0;
} |
3,820 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text) {
std::vector<std::string> result;
std::regex re("[A-Z][^A-Z]*");
std::match_results<std::string::const_iterator> m;
auto begin = text.cbegin();
while (regex_search(begin, text.cend(), m, re)) {
result.emplace_back(m[0]);
... | int main() {
assert((func0("LearnToBuildAnythingWithGoogle") == std::vector<std::string>{"Learn", "To", "Build", "Anything", "With", "Google"}));
assert((func0("ApmlifyingTheBlack+DeveloperCommunity") == std::vector<std::string>{"Apmlifying", "The", "Black+", "Developer", "Community"}));
assert((func0("U... | 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 $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %rsi,-0x80(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
mov -0x78(%rbp),%rax
mov %rax,%rdi
callq ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 78h
mov [rbp+var_78], rdi
mov [rbp+var_80], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
mov rax, [rbp+var_78]
mov rdi, rax
call _ZNSt6vectorINSt7__cxx11... | long long func0(long long a1, long long a2)
{
long long v2; // rax
long long v3; // rax
long long i; // [rsp+18h] [rbp-68h]
_BYTE v6[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v7[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v8; // [rsp+68h] [rbp-18h]
v8 = __readfsqword(0x28u);
std::vector<std::st... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x78],RDI
MOV qword ptr [RBP + -0x80],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x78]
MOV RDI,RAX
CALL 0x001066c6
LEA RAX,[RBP + -0x60]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
... | /* func0(std::string const&) */
string * func0(string *param_1)
{
bool bVar1;
__normal_iterator _Var2;
sub_match *psVar3;
long lVar4;
long in_FS_OFFSET;
int8 local_70;
regex local_68 [32];
match_results<__normal_iterator<char_const*,std::string>,std::allocator<std::sub_match<__normal_iterator<char_con... |
3,821 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text) {
std::vector<std::string> result;
std::regex re("[A-Z][^A-Z]*");
std::match_results<std::string::const_iterator> m;
auto begin = text.cbegin();
while (regex_search(begin, text.cend(), m, re)) {
result.emplace_back(m[0]);
... | int main() {
assert((func0("LearnToBuildAnythingWithGoogle") == std::vector<std::string>{"Learn", "To", "Build", "Anything", "With", "Google"}));
assert((func0("ApmlifyingTheBlack+DeveloperCommunity") == std::vector<std::string>{"Apmlifying", "The", "Black+", "Developer", "Community"}));
assert((func0("U... | O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x1e8,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x1d8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 1E8h
mov rbx, rdi
mov r14, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qwor... | _QWORD * func0(_QWORD *a1, long long *a2)
{
char *v4; // rsi
long long v5; // rdx
long long v6; // rax
long long v7; // r12
volatile signed __int32 *v8; // rcx
long long v9; // rdx
signed __int32 v10; // eax
_DWORD *v11; // r12
volatile signed __int32 *v12; // rcx
long long v13; // rdx
signed __in... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x1e8
MOV RBX,RDI
MOV R14,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
LEA R12,[RBP + -0x1f8]
MOV RDI,R12
CALL 0x001046f0
MOV qword p... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
long *plVar3;
_Sp_counted_base<(_Lock_policy)2> *p_Var4;
bool bVar5;
int iVar6;
sub_match *psVar7;
int8 *in_RSI;
int8 uVar8;
long in_FS_OFFSET;
int4 local_208 [2];
locale lo... |
3,822 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text) {
std::vector<std::string> result;
std::regex re("[A-Z][^A-Z]*");
std::match_results<std::string::const_iterator> m;
auto begin = text.cbegin();
while (regex_search(begin, text.cend(), m, re)) {
result.emplace_back(m[0]);
... | int main() {
assert((func0("LearnToBuildAnythingWithGoogle") == std::vector<std::string>{"Learn", "To", "Build", "Anything", "With", "Google"}));
assert((func0("ApmlifyingTheBlack+DeveloperCommunity") == std::vector<std::string>{"Apmlifying", "The", "Black+", "Developer", "Community"}));
assert((func0("U... | 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 $0x1e8,%rsp
mov %fs:0x28,%rax
mov %rax,0x1d8(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
lea 0x20... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
pxor xmm0, xmm0
mov rbp, rsp
push r15
mov r15, rsi
push r14
lea r14, [rbp+var_208]
push r13
push r12
push rbx
mov rbx, rdi
sub rsp, 1E8h
mov rax, fs:28h
mov [rbp+var_38], rax
xor eax, ea... | long long func0(long long a1, long long *a2)
{
char *v4; // rsi
__m128i v5; // xmm0
volatile signed __int32 *v6; // r12
long long v7; // rdx
volatile signed __int32 *v8; // rcx
signed __int32 v9; // eax
long long v10; // r12
long long v11; // rdx
volatile signed __int32 *v12; // rcx
signed __int32 ... | func0:
ENDBR64
PUSH RBP
PXOR XMM0,XMM0
MOV RBP,RSP
PUSH R15
MOV R15,RSI
PUSH R14
LEA R14,[RBP + -0x208]
PUSH R13
PUSH R12
PUSH RBX
MOV RBX,RDI
SUB RSP,0x1e8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,R14
CALL 0x001036d0
LE... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
long *plVar2;
int auVar3 [16];
bool bVar4;
int iVar5;
sub_match *psVar6;
sub_match *psVar7;
int8 *in_RSI;
int8 uVar8;
int8 uVar9;
long in_FS_OFFSET;
int4 local_218 [2];
locale local_2... |
3,823 | func0 |
#include <iostream>
#include <vector>
#include <string>
#include <regex>
#include <assert.h>
| std::vector<std::string> func0(const std::string& text) {
std::vector<std::string> result;
std::regex re("[A-Z][^A-Z]*");
std::match_results<std::string::const_iterator> m;
auto begin = text.cbegin();
while (regex_search(begin, text.cend(), m, re)) {
result.emplace_back(m[0]);
... | int main() {
assert((func0("LearnToBuildAnythingWithGoogle") == std::vector<std::string>{"Learn", "To", "Build", "Anything", "With", "Google"}));
assert((func0("ApmlifyingTheBlack+DeveloperCommunity") == std::vector<std::string>{"Apmlifying", "The", "Black+", "Developer", "Community"}));
assert((func0("U... | O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
pxor %xmm0,%xmm0
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
mov %rsi,%rbx
sub $0x218,%rsp
mov %fs:0x28,%rax
mov %rax,0x208(%rsp)
xor %eax,%eax
movq $0x0... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
pxor xmm0, xmm0
mov r15, rsi
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 2E8h
mov rax, fs:28h
mov [rsp+318h+var_40], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
lea ... | long long func0(long long a1, long long *a2)
{
__m128i v4; // xmm0
long long v5; // rdi
void *v6; // rdi
void **v7; // rbx
unsigned long long v8; // rbp
void *v9; // rdi
long long v10; // r12
long long v11; // rbx
_QWORD *v12; // rdx
unsigned long long v13; // rbx
long long v14; // rcx
long lon... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
MOV R15,RSI
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x2e8
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x2d8],RAX
XOR EAX,EAX
MOV qword ptr [RDI + 0x10],0x0
LEA RBX,[RSP + 0x78]
MOVUPS xmmword ptr [RDI],XMM0
MOV RDI,RBX
MOV qword ptr [RSP + 0x28],RBX
C... | /* func0(std::string const&) */
string * func0(string *param_1)
{
ulong *puVar1;
int8 uVar2;
void *pvVar3;
int *__src;
int auVar4 [16];
bool bVar5;
int auVar6 [16];
char cVar7;
int8 *puVar8;
long lVar9;
int (*pauVar10) [16];
int8 *puVar11;
void *pvVar12;
long *plVar13;
ulong *__dest;
s... |
3,824 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
return log2(n & -n) + 1;
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x10,%rsp
mov %edi,-0x4(%rbp)
mov -0x4(%rbp),%eax
neg %eax
and -0x4(%rbp),%eax
cvtsi2sd %eax,%xmm0
callq 10b0 <log2@plt>
movsd 0xeb7(%rip),%xmm1
addsd %xmm1,%xmm0
cvttsd2si %xmm0,%eax
leaveq
retq
| _Z5func0i:
endbr64
push rbp
mov rbp, rsp
sub rsp, 10h
mov [rbp+var_4], edi
mov eax, [rbp+var_4]
neg eax
and eax, [rbp+var_4]
pxor xmm2, xmm2
cvtsi2sd xmm2, eax
movq rax, xmm2
movq xmm0, rax; x
call _log2
movsd xmm1, cs:qword_2070
addsd xmm0, xmm1
cvttsd2si eax, xmm0
leave
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x10
MOV dword ptr [RBP + -0x4],EDI
MOV EAX,dword ptr [RBP + -0x4]
NEG EAX
AND EAX,dword ptr [RBP + -0x4]
PXOR XMM2,XMM2
CVTSI2SD XMM2,EAX
MOVQ RAX,XMM2
MOVQ XMM0,RAX
CALL 0x00101070
MOVSD XMM1,qword ptr [0x00102070]
ADDSD XMM0,XMM1
CVTTSD2SI EAX,XMM0
LEAVE
RET | /* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = log2((double)(-param_1 & param_1));
return (int)(dVar1 + DAT_00102070);
} |
3,825 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
return log2(n & -n) + 1;
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O1 | cpp | func0(int):
endbr64
sub $0x8,%rsp
mov %edi,%eax
neg %edi
and %eax,%edi
pxor %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
callq 10b0 <log2@plt>
addsd 0xebc(%rip),%xmm0
cvttsd2si %xmm0,%eax
add $0x8,%rsp
retq
| _Z5func0i:
endbr64
sub rsp, 8
mov eax, edi
neg eax
and eax, edi
pxor xmm0, xmm0
cvtsi2sd xmm0, eax; x
call _log2
addsd xmm0, cs:qword_2060
cvttsd2si eax, xmm0
add rsp, 8
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
SUB RSP,0x8
MOV EAX,EDI
NEG EAX
AND EAX,EDI
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
CALL 0x00101070
ADDSD XMM0,qword ptr [0x00102060]
CVTTSD2SI EAX,XMM0
ADD RSP,0x8
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = log2((double)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102060);
} |
3,826 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
return log2(n & -n) + 1;
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O2 | cpp | func0(int):
endbr64
mov %edi,%r8d
neg %edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
and %r8d,%edi
cvtsi2sd %edi,%xmm0
callq 1090 <log2@plt>
addsd 0xe03(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
| _Z5func0i:
endbr64
mov eax, edi
pxor xmm0, xmm0
sub rsp, 8
neg eax
and eax, edi
cvtsi2sd xmm0, eax; x
call _log2
addsd xmm0, cs:qword_2008
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
MOV EAX,EDI
PXOR XMM0,XMM0
SUB RSP,0x8
NEG EAX
AND EAX,EDI
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = log2((double)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102008);
} |
3,827 | func0 |
#include <iostream>
#include <cmath>
#include <cassert>
| int func0(int n) {
return log2(n & -n) + 1;
}
| int main() {
assert(func0(12) == 3);
assert(func0(18) == 2);
assert(func0(16) == 5);
return 0;
}
| O3 | cpp | func0(int):
endbr64
mov %edi,%r8d
neg %edi
pxor %xmm0,%xmm0
sub $0x8,%rsp
and %r8d,%edi
cvtsi2sd %edi,%xmm0
callq 1090 <log2@plt>
addsd 0xe03(%rip),%xmm0
add $0x8,%rsp
cvttsd2si %xmm0,%eax
retq
xchg %ax,%ax
| _Z5func0i:
endbr64
mov eax, edi
pxor xmm0, xmm0
sub rsp, 8
neg eax
and eax, edi
cvtsi2sd xmm0, eax; x
call _log2
addsd xmm0, cs:qword_2008
add rsp, 8
cvttsd2si eax, xmm0
retn | long long func0(int a1)
{
return (unsigned int)(int)(log2((double)(a1 & -a1)) + 1.0);
} | func0:
ENDBR64
MOV EAX,EDI
PXOR XMM0,XMM0
SUB RSP,0x8
NEG EAX
AND EAX,EDI
CVTSI2SD XMM0,EAX
CALL 0x00101050
ADDSD XMM0,qword ptr [0x00102008]
ADD RSP,0x8
CVTTSD2SI EAX,XMM0
RET | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int) */
int func0(int param_1)
{
double dVar1;
dVar1 = log2((double)(-param_1 & param_1));
return (int)(dVar1 + _DAT_00102008);
} |
3,828 | func0 | #include <string>
#include <cassert>
| std::string func0(int num) {
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
std::string syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
std::string roman_num = "";
int i = 0;
while (num > 0) {
while (num >= val[i]) {
ro... | int main() {
assert(func0(1) == "I");
assert(func0(50) == "L");
assert(func0(4) == "IV");
return 0;
}
| O0 | cpp | func0[abi:cxx11](int):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x218,%rsp
mov %rdi,-0x228(%rbp)
mov %esi,-0x22c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movl $0x3e8,-0x210(%rbp)
movl $0x384,-0x20c(%rbp)
movl $0x1f4,-0x208(%rbp)
movl $0x19... | _Z5func0B5cxx11i:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 228h
mov [rbp+var_238], rdi
mov [rbp+var_23C], esi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov [rbp+var_210], 3E8h
mov [rbp+var_20C], 384h
mov [rbp+var_208], 1F4h
mov [r... | long long func0[abi:cxx11](long long a1, int a2)
{
_OWORD *i; // rbx
char v5; // [rsp+1Bh] [rbp-225h] BYREF
int v6; // [rsp+1Ch] [rbp-224h]
char *v7; // [rsp+20h] [rbp-220h]
char *v8; // [rsp+28h] [rbp-218h]
_DWORD v9[16]; // [rsp+30h] [rbp-210h]
_OWORD v10[2]; // [rsp+70h] [rbp-1D0h] BYREF
long long v... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x228
MOV qword ptr [RBP + -0x238],RDI
MOV dword ptr [RBP + -0x23c],ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV dword ptr [RBP + -0x210],0x3e8
MOV dword ptr [RBP + -0x20c],0x384
MOV dword ptr [RBP + -0x... | /* func0[abi:cxx11](int) */
string * func0_abi_cxx11_(int param_1)
{
string *this;
int in_ESI;
int4 in_register_0000003c;
string *this_00;
long in_FS_OFFSET;
int local_244;
allocator local_22d;
int local_22c;
allocator *local_228;
allocator *local_220;
int local_218 [16];
string local_1d8 [32]... |
3,829 | func0 | #include <string>
#include <cassert>
| std::string func0(int num) {
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
std::string syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
std::string roman_num = "";
int i = 0;
while (num > 0) {
while (num >= val[i]) {
ro... | int main() {
assert(func0(1) == "I");
assert(func0(50) == "L");
assert(func0(4) == "IV");
return 0;
}
| O1 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x1f8,%rsp
mov %rdi,%r13
mov %esi,%ebx
mov %fs:0x28,%rax
mov %rax,0x1e8(%rsp)
xor %eax,%eax
movl $0x3e8,(%rsp)
movl $0x384,0x4(%rsp)
movl $0x1f4,0x8(%rsp)
movl $0x190,0xc(%rsp)
movl $0... | _Z5func0B5cxx11i:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 1F8h
mov r13, rdi
mov ebx, esi
mov rax, fs:28h
mov [rsp+228h+var_40], rax
xor eax, eax
mov [rsp+228h+var_228], 3E8h
mov [rsp+228h+var_224], 384h
mov [rsp+228h+var_220], 1F4h
mov... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2, long long a3, long long a4, long long a5, long long a6)
{
int v6; // ebx
long long v7; // rcx
long long v8; // r8
long long v9; // r9
long long v10; // rcx
long long v11; // r8
long long v12; // r9
long long v13; // rcx
long long v14; // r8
long long v15... | func0[abi:cxx11]:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x1f8
MOV R13,RDI
MOV EBX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1e8],RAX
XOR EAX,EAX
MOV dword ptr [RSP],0x3e8
MOV dword ptr [RSP + 0x4],0x384
MOV dword ptr [RSP + 0x8],0x1f4
MOV dword ptr [RSP + 0xc],0x190
MOV dwor... | /* WARNING: Type propagation algorithm not settling */
/* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int8 uVar2;
long *****ppppplVar3;
long ****pppplVar4;
int in_ESI;
int4 in_register_0000003c;
long *plVar5;
int *piVar6;
long in_FS_OFFSET;
bool bVar7;
int local_22... |
3,830 | func0 | #include <string>
#include <cassert>
| std::string func0(int num) {
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
std::string syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
std::string roman_num = "";
int i = 0;
while (num > 0) {
while (num >= val[i]) {
ro... | int main() {
assert(func0(1) == "I");
assert(func0(50) == "L");
assert(func0(4) == "IV");
return 0;
}
| O2 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
mov $0x4d43,%edx
mov $0x44,%ecx
mov $0x43,%r8d
push %r14
mov $0x4358,%r9d
mov $0x4c,%r10d
mov $0x4c58,%r11d
push %r13
mov %rdi,%r13
mov $0x4443,%edi
mov $0x5649,%r14d
push %r12
mov $0x56,%r12d
push %rbp
mov $0x5849,%ebp
push %rbx
mov ... | _Z5func0B5cxx11i:
endbr64
push r15
lea rdx, unk_2006
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
mov ebx, esi
lea rsi, [rdx-1]
sub rsp, 208h
movdqa xmm0, cs:xmmword_2090
mov rax, fs:28h
mov [rsp+238h+var_40], rax
xor eax, eax
lea rdi, [rsp+238h+var_1E... | _QWORD * func0[abi:cxx11](_QWORD *a1, int a2)
{
int v2; // ebx
_QWORD *v3; // rbp
int *v4; // r15
int v5; // r12d
void **i; // rbx
_OWORD v8[3]; // [rsp+10h] [rbp-228h] BYREF
int v9; // [rsp+40h] [rbp-1F8h]
_QWORD v10[2]; // [rsp+50h] [rbp-1E8h] BYREF
char v11; // [rsp+60h] [rbp-1D8h] BYREF
char *v1... | func0[abi:cxx11]:
ENDBR64
PUSH R15
LEA RDX,[0x102006]
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
MOV EBX,ESI
LEA RSI,[RDX + -0x1]
SUB RSP,0x208
MOVDQA XMM0,xmmword ptr [0x00102090]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x1f8],RAX
XOR EAX,EAX
LEA RDI,[RSP + 0x50]
LEA RAX,[RSP + 0x60]
MOV dword p... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int **ppuVar2;
int **ppuVar3;
int in_ESI;
int4 in_register_0000003c;
long *plVar4;
int *piVar5;
long in_FS_OFFSET;
bool bVar6;
int8 loc... |
3,831 | func0 | #include <string>
#include <cassert>
| std::string func0(int num) {
int val[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
std::string syb[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
std::string roman_num = "";
int i = 0;
while (num > 0) {
while (num >= val[i]) {
ro... | int main() {
assert(func0(1) == "I");
assert(func0(50) == "L");
assert(func0(4) == "IV");
return 0;
}
| O3 | cpp | func0[abi:cxx11](int):
endbr64
push %r15
mov $0x4d43,%edx
mov $0x44,%ecx
mov $0x4443,%r8d
push %r14
mov $0x43,%r9d
mov $0x4358,%r10d
mov $0x4c,%r11d
push %r13
mov $0x56,%r14d
mov %rdi,%r13
push %r12
mov $0x5849,%r12d
push %rbp
mov $0x58,%ebp
push %rbx
mov $0x4c58,%ebx
sub ... | _Z5func0B5cxx11i:
endbr64
push r15
mov edx, 4D43h
mov ecx, 44h ; 'D'
mov r8d, 4443h
push r14
mov r9d, 43h ; 'C'
mov r10d, 4358h
mov r11d, 4Ch ; 'L'
push r13
mov r14d, 5849h
mov r15d, 56h ; 'V'
mov r13, rdi
push r12
mov r12d, 58h ; 'X'
push rbp
push rbx
mov e... | long long func0[abi:cxx11](long long a1, int a2)
{
_QWORD *v2; // rbp
int v3; // ebx
int *v4; // r15
int v5; // r12d
void **i; // rbx
void **v7; // rax
_OWORD v9[3]; // [rsp+10h] [rbp-228h] BYREF
int v10; // [rsp+40h] [rbp-1F8h]
_QWORD v11[2]; // [rsp+50h] [rbp-1E8h] BYREF
__int16 v12; // [rsp+60h]... | func0[abi:cxx11]:
ENDBR64
PUSH R15
MOV EDX,0x4d43
MOV ECX,0x44
MOV R8D,0x4443
PUSH R14
MOV R9D,0x43
MOV R10D,0x4358
MOV R11D,0x4c
PUSH R13
MOV R14D,0x5849
MOV R15D,0x56
MOV R13,RDI
PUSH R12
MOV R12D,0x58
PUSH RBP
PUSH RBX
MOV EBX,0x4c58
SUB RSP,0x208
MOVDQA XMM0,xmmword ptr [0x00102090]
MOV RAX,qword ptr FS:[0x28]
MOV ... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int) */
long * func0_abi_cxx11_(int param_1)
{
int iVar1;
int8 ***pppuVar2;
int in_ESI;
int4 in_register_0000003c;
long *plVar3;
int *piVar4;
long in_FS_OFFSET;
int8 local_228;
int8 uStack_220;
... |
3,832 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| double func0(std::vector<int> lst) {
double sum = std::accumulate(lst.begin(), lst.end(), 0);
return sum / lst.size();
}
| int main() {
assert(func0({15, 9, 55, 41, 35, 20, 62, 49}) == 35.75);
assert(func0({4, 5, 1, 2, 9, 7, 10, 8}) == 5.75);
assert(func0({1, 2, 3}) == 2);
return 0;
}
| O0 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x28,%rsp
mov %rdi,-0x28(%rbp)
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 161c <_ZNSt6vectorIiSaIiEE3endEv>
mov %rax,%rbx
mov -0x28(%rbp),%rax
mov %rax,%rdi
callq 15d0 <_ZNSt6vectorIiSaIiEE5beginEv>... | _Z5func0St6vectorIiSaIiEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 28h
mov [rbp+var_28], rdi
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE3endEv; std::vector<int>::end(void)
mov rbx, rax
mov rax, [rbp+var_28]
mov rdi, rax
call _ZNSt6vectorIiSaIiEE5begin... | __int128 __usercall func0@<xmm0>(long long a1@<rdi>)
{
long long v1; // rbx
long long v2; // rax
long long v3; // rax
double v4; // xmm0_8
__int128 v5; // xmm1
double v7; // [rsp+18h] [rbp-18h]
v1 = std::vector<int>::end(a1);
v2 = std::vector<int>::begin(a1);
v7 = (double)(int)std::accumulate<__gnu_c... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x28
MOV qword ptr [RBP + -0x28],RDI
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x001016ba
MOV RBX,RAX
MOV RAX,qword ptr [RBP + -0x28]
MOV RDI,RAX
CALL 0x0010166e
MOV EDX,0x0
MOV RSI,RBX
MOV RDI,RAX
CALL 0x0010170a
PXOR XMM0,XMM0
CVTSI2SD XMM0,EAX
MOVSD qword p... | /* func0(std::vector<int, std::allocator<int> >) */
double func0(vector param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
int iVar3;
ulong uVar4;
int4 in_register_0000003c;
vector<int,std::allocator<int>> *this;
this = (vector<int,std::allocator<int>> *)CONCAT44(in_register_0000003c,param_... |
3,833 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| double func0(std::vector<int> lst) {
double sum = std::accumulate(lst.begin(), lst.end(), 0);
return sum / lst.size();
}
| int main() {
assert(func0({15, 9, 55, 41, 35, 20, 62, 49}) == 35.75);
assert(func0({4, 5, 1, 2, 9, 7, 10, 8}) == 5.75);
assert(func0({1, 2, 3}) == 2);
return 0;
}
| O1 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rsi
cmp %rcx,%rsi
je 124b <_Z5func0St6vectorIiSaIiEE+0x42>
mov %rsi,%rax
mov $0x0,%edx
add (%rax),%edx
add $0x4,%rax
cmp %rax,%rcx
jne 1221 <_Z5func0St6vectorIiSaIiEE+0x18>
pxor %xmm0,%xmm0
cvtsi2sd %e... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi+8]
mov rsi, [rdi]
cmp rsi, rcx
jz short loc_124B
mov rax, rsi
mov edx, 0
loc_1221:
add edx, [rax]
add rax, 4
cmp rax, rcx
jnz short loc_1221
loc_122C:
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
sub rcx, rsi
sar rcx, 2
js s... | double func0(long long a1)
{
_DWORD *v1; // rcx
_DWORD *v2; // rax
int v3; // edx
long long v4; // rcx
double v5; // xmm1_8
v1 = *(_DWORD **)(a1 + 8);
if ( *(_DWORD **)a1 == v1 )
{
v3 = 0;
}
else
{
v2 = *(_DWORD **)a1;
v3 = 0;
do
v3 += *v2++;
while ( v2 != v1 );
}
v... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
CMP RSI,RCX
JZ 0x0010124b
MOV RAX,RSI
MOV EDX,0x0
LAB_00101221:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RAX,RCX
JNZ 0x00101221
LAB_0010122c:
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
SUB RCX,RSI
SAR RCX,0x2
JS 0x00101252
PXOR XMM1,XMM1
CVTSI2SD XMM1,RCX
LAB_00... | /* func0(std::vector<int, std::allocator<int> >) */
double func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
int iVar4;
int4 in_register_0000003c;
piVar1 = *(int **)(CONCAT44(in_register_0000003c,param_1) + 8);
piVar2 = *(int **)CONCAT44(in_register_0000003c,param_1);
if (piVar2 == piV... |
3,834 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| double func0(std::vector<int> lst) {
double sum = std::accumulate(lst.begin(), lst.end(), 0);
return sum / lst.size();
}
| int main() {
assert(func0({15, 9, 55, 41, 35, 20, 62, 49}) == 35.75);
assert(func0({4, 5, 1, 2, 9, 7, 10, 8}) == 5.75);
assert(func0({1, 2, 3}) == 2);
return 0;
}
| O2 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rcx
mov (%rdi),%rsi
cmp %rcx,%rsi
je 15a0 <_Z5func0St6vectorIiSaIiEE+0x70>
mov %rsi,%rax
xor %edx,%edx
nopl (%rax)
add (%rax),%edx
add $0x4,%rax
cmp %rax,%rcx
jne 1548 <_Z5func0St6vectorIiSaIiEE+0x18>
pxor %xmm0,%xm... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rcx, [rdi+8]
mov rsi, [rdi]
cmp rsi, rcx
jz short loc_1410
mov rax, rsi
xor edx, edx
nop dword ptr [rax]
loc_13B8:
add edx, [rax]
add rax, 4
cmp rcx, rax
jnz short loc_13B8
pxor xmm0, xmm0
cvtsi2sd xmm0, edx
loc_13CB:
sub rcx, rs... | double func0(long long a1)
{
_DWORD *v1; // rcx
_DWORD *v2; // rax
int v3; // edx
double v4; // xmm0_8
long long v5; // rcx
v1 = *(_DWORD **)(a1 + 8);
if ( *(_DWORD **)a1 == v1 )
{
v4 = 0.0;
}
else
{
v2 = *(_DWORD **)a1;
v3 = 0;
do
v3 += *v2++;
while ( v1 != v2 );
v... | func0:
ENDBR64
MOV RCX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
CMP RSI,RCX
JZ 0x00101410
MOV RAX,RSI
XOR EDX,EDX
NOP dword ptr [RAX]
LAB_001013b8:
ADD EDX,dword ptr [RAX]
ADD RAX,0x4
CMP RCX,RAX
JNZ 0x001013b8
PXOR XMM0,XMM0
CVTSI2SD XMM0,EDX
LAB_001013cb:
SUB RCX,RSI
SAR RCX,0x2
JS 0x001013e8
PXOR XMM1,XMM1
CVTS... | /* func0(std::vector<int, std::allocator<int> >) */
double func0(vector param_1)
{
int *piVar1;
int *piVar2;
int *piVar3;
ulong uVar4;
int iVar5;
int4 in_register_0000003c;
double dVar6;
piVar1 = *(int **)(CONCAT44(in_register_0000003c,param_1) + 8);
piVar2 = *(int **)CONCAT44(in_register_0000003... |
3,835 | func0 |
#include <vector>
#include <numeric>
#include <assert.h>
| double func0(std::vector<int> lst) {
double sum = std::accumulate(lst.begin(), lst.end(), 0);
return sum / lst.size();
}
| int main() {
assert(func0({15, 9, 55, 41, 35, 20, 62, 49}) == 35.75);
assert(func0({4, 5, 1, 2, 9, 7, 10, 8}) == 5.75);
assert(func0({1, 2, 3}) == 2);
return 0;
}
| O3 | cpp | func0(std::vector<int, std::allocator<int> >):
endbr64
mov 0x8(%rdi),%rdx
mov (%rdi),%rsi
cmp %rdx,%rsi
je 17b0 <_Z5func0St6vectorIiSaIiEE+0x100>
lea -0x4(%rdx),%rcx
mov %rsi,%rax
movabs $0x3ffffffffffffffc,%r8
sub %rsi,%rcx
shr $0x2,%rcx
lea 0x1(%rcx),%rdi
test %r8,%rcx
je 17b6 <_Z5fu... | _Z5func0St6vectorIiSaIiEE:
endbr64
mov rdx, [rdi+8]
mov rsi, [rdi]
cmp rsi, rdx
jz loc_1750
lea rcx, [rdx-4]
mov rax, rsi
sub rcx, rsi
mov rdi, rcx
shr rdi, 2
add rdi, 1
cmp rcx, 8
jbe loc_1756
mov rcx, rdi
pxor xmm0, xmm0
shr rcx, 2
shl rcx, 4
add rcx... | double func0(const __m128i **a1)
{
const __m128i *v1; // rdx
const __m128i *v2; // rsi
const __m128i *v3; // rax
unsigned long long v4; // rdi
__m128i v5; // xmm0
__m128i v6; // xmm2
__m128i v7; // xmm0
int v8; // eax
const __m128i *v9; // rcx
double v10; // xmm0_8
long long v11; // rdx
v1 = a... | func0:
ENDBR64
MOV RDX,qword ptr [RDI + 0x8]
MOV RSI,qword ptr [RDI]
CMP RSI,RDX
JZ 0x00101750
LEA RCX,[RDX + -0x4]
MOV RAX,RSI
SUB RCX,RSI
MOV RDI,RCX
SHR RDI,0x2
ADD RDI,0x1
CMP RCX,0x8
JBE 0x00101756
MOV RCX,RDI
PXOR XMM0,XMM0
SHR RCX,0x2
SHL RCX,0x4
ADD RCX,RSI
NOP dword ptr [RAX]
LAB_001016b8:
MOVDQU XMM2,xmmword ... | /* func0(std::vector<int, std::allocator<int> >) */
double func0(vector param_1)
{
int *piVar1;
int *piVar2;
int iVar3;
int *piVar4;
int *piVar5;
int *piVar6;
int *piVar7;
ulong uVar8;
int4 in_register_0000003c;
ulong uVar9;
int iVar10;
int iVar12;
double dVar11;
int iVar13;
int iVar14;
... |
3,836 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O0 | cpp | func0(int):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x18,%rsp
mov %edi,-0x14(%rbp)
cmpl $0x0,-0x14(%rbp)
jne 11a6 <_Z5func0i+0x1d>
mov $0x0,%eax
jmp 11d1 <_Z5func0i+0x48>
cmpl $0x1,-0x14(%rbp)
jne 11b3 <_Z5func0i+0x2a>
mov $0x1,%eax
jmp 11d1 <_Z5func0i+0x48>
mov -0x14(%rbp),... | _Z5func0i:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 18h
mov [rbp+var_14], edi
cmp [rbp+var_14], 0
jnz short loc_1166
mov eax, 0
jmp short loc_1191
loc_1166:
cmp [rbp+var_14], 1
jnz short loc_1173
mov eax, 1
jmp short loc_1191
loc_1173:
mov eax, [rbp+var_14]
s... | long long func0(int a1)
{
int v2; // ebx
if ( !a1 )
return 0LL;
if ( a1 == 1 )
return 1LL;
v2 = func0(a1 - 1);
return v2 + (unsigned int)func0(a1 - 2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x18
MOV dword ptr [RBP + -0x14],EDI
CMP dword ptr [RBP + -0x14],0x0
JNZ 0x00101166
MOV EAX,0x0
JMP 0x00101191
LAB_00101166:
CMP dword ptr [RBP + -0x14],0x1
JNZ 0x00101173
MOV EAX,0x1
JMP 0x00101191
LAB_00101173:
MOV EAX,dword ptr [RBP + -0x14]
SUB EAX,0x1
MOV EDI,EA... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if (param_1 == 0) {
iVar2 = 0;
}
else if (param_1 == 1) {
iVar2 = 1;
}
else {
iVar1 = func0(param_1 + -1);
iVar2 = func0(param_1 + -2);
iVar2 = iVar2 + iVar1;
}
return iVar2;
} |
3,837 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O1 | cpp | func0(int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %edi,%ebx
test %edi,%edi
je 11b4 <_Z5func0i+0x2b>
cmp $0x1,%edi
je 11b4 <_Z5func0i+0x2b>
lea -0x1(%rdi),%edi
callq 1189 <_Z5func0i>
mov %eax,%ebp
lea -0x2(%rbx),%edi
callq 1189 <_Z5func0i>
lea 0x0(%rbp,%rax,1),%ebx
mov %eb... | _Z5func0i:
endbr64
push rbp
push rbx
sub rsp, 8
mov ebx, edi
test edi, edi
jz short loc_1174
cmp edi, 1
jz short loc_1174
lea edi, [rdi-1]; int
call _Z5func0i; func0(int)
mov ebp, eax
lea edi, [rbx-2]; int
call _Z5func0i; func0(int)
lea ebx, [rbp+rax+0]
loc_1174:
mov... | long long func0(unsigned int a1)
{
unsigned int v1; // ebx
int v2; // ebp
v1 = a1;
if ( a1 >= 2 )
{
v2 = func0(a1 - 1);
return v2 + (unsigned int)func0(a1 - 2);
}
return v1;
} | func0:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV EBX,EDI
TEST EDI,EDI
JZ 0x00101174
CMP EDI,0x1
JZ 0x00101174
LEA EDI,[RDI + -0x1]
CALL 0x00101149
MOV EBP,EAX
LEA EDI,[RBX + -0x2]
CALL 0x00101149
LEA EBX,[RBP + RAX*0x1]
LAB_00101174:
MOV EAX,EBX
ADD RSP,0x8
POP RBX
POP RBP
RET | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
if ((param_1 != 0) && (param_1 != 1)) {
iVar1 = func0(param_1 + -1);
iVar2 = func0(param_1 + -2);
param_1 = iVar1 + iVar2;
}
return param_1;
} |
3,838 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O2 | cpp | func0(int):
endbr64
push %r12
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 12b0 <_Z5func0i+0x40>
mov %edi,%ebx
cmp $0x1,%edi
je 12c0 <_Z5func0i+0x50>
xor %r12d,%r12d
lea -0x1(%rbx),%edi
callq 1270 <_Z5func0i>
add %eax,%r12d
sub $0x2,%ebx
je 12a2 <_Z5func0i+0x32>
cmp $0x1,%ebx
jne... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
mov r12d, edi
push rbp
push rbx
sub rsp, 58h
test edi, edi
jz loc_1429
cmp edi, 1
jz loc_1429
lea r15d, [rdi-1]
xor r12d, r12d
loc_121D:
cmp r15d, 1
jz loc_1425
lea r13d, [r15-1]
xor r14d, r14d
mov... | long long func0(unsigned int a1)
{
unsigned int v1; // r12d
unsigned int v2; // r15d
int v3; // r12d
unsigned int v4; // ebp
int v5; // r12d
unsigned int v6; // ecx
int v7; // r14d
unsigned int v8; // ebp
unsigned int v9; // edi
int v10; // r15d
unsigned int v11; // r13d
unsigned int v12; // r1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBP
PUSH RBX
SUB RSP,0x58
TEST EDI,EDI
JZ 0x00101429
CMP EDI,0x1
JZ 0x00101429
LEA R15D,[RDI + -0x1]
XOR R12D,R12D
LAB_0010121d:
CMP R15D,0x1
JZ 0x00101425
LEA R13D,[R15 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x1c],R12D
MOV dword ptr [RSP + 0x20],... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int... |
3,839 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int n) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 1;
}
return func0(n - 1) + func0(n - 2);
}
| int main() {
assert(func0(4) == 3);
assert(func0(3) == 2);
assert(func0(5) == 5);
return 0;
}
| O3 | cpp | func0(int):
endbr64
push %r12
push %rbx
sub $0x8,%rsp
test %edi,%edi
je 12b0 <_Z5func0i+0x40>
mov %edi,%ebx
cmp $0x1,%edi
je 12c0 <_Z5func0i+0x50>
xor %r12d,%r12d
lea -0x1(%rbx),%edi
callq 1270 <_Z5func0i>
add %eax,%r12d
sub $0x2,%ebx
je 12a2 <_Z5func0i+0x32>
cmp $0x1,%ebx
jne... | _Z5func0i:
endbr64
push r15
push r14
push r13
push r12
mov r12d, edi
push rbp
push rbx
sub rsp, 58h
test edi, edi
jz loc_1429
cmp edi, 1
jz loc_1429
lea r15d, [rdi-1]
xor r12d, r12d
loc_121D:
cmp r15d, 1
jz loc_1425
lea r13d, [r15-1]
xor r14d, r14d
mov... | long long func0(unsigned int a1)
{
unsigned int v1; // r12d
unsigned int v2; // r15d
int v3; // r12d
unsigned int v4; // ebp
int v5; // r12d
unsigned int v6; // ecx
int v7; // r14d
unsigned int v8; // ebp
unsigned int v9; // edi
int v10; // r15d
unsigned int v11; // r13d
unsigned int v12; // r1... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12D,EDI
PUSH RBP
PUSH RBX
SUB RSP,0x58
TEST EDI,EDI
JZ 0x00101429
CMP EDI,0x1
JZ 0x00101429
LEA R15D,[RDI + -0x1]
XOR R12D,R12D
LAB_0010121d:
CMP R15D,0x1
JZ 0x00101425
LEA R13D,[R15 + -0x1]
XOR R14D,R14D
MOV dword ptr [RSP + 0x1c],R12D
MOV dword ptr [RSP + 0x20],... | /* func0(int) */
int func0(int param_1)
{
int iVar1;
int iVar2;
int iVar3;
int iVar4;
int iVar5;
int iVar6;
int iVar7;
int iVar8;
int iVar9;
int iVar10;
int iVar11;
int iVar12;
int iVar13;
int iVar14;
int iVar15;
int iVar16;
int iVar17;
int iVar18;
int iVar19;
int iVar20;
int... |
3,840 | func0 |
#include <iostream>
#include <string>
#include <unordered_map>
#include <assert.h>
using namespace std;
| int func0(string s) {
unordered_map<char, int> rom_val = {
{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50},
{'C', 100}, {'D', 500}, {'M', 1000}
};
int int_val = 0;
for (int i = 0; i < s.length(); i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom... | int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0xa8,%rsp
mov %rdi,-0xb8(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movq $0x0,-0x60(%rbp)
movq $0x0,-0x58(%rbp)
movq ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0B8h
mov [rbp+var_B8], rdi
mov rcx, fs:28h
mov [rbp+var_18], rcx
xor ecx, ecx
pxor xmm0, xmm0
movaps [rbp+var_50], xmm0
movaps [rbp+var_40], xmm0
movaps [rbp+var_30], xmm0
mo... | long long func0(long long a1)
{
long long v1; // rax
int v2; // ebx
long long v3; // rax
long long v5; // rax
int v6; // ebx
long long v7; // rax
_DWORD *v8; // rax
long long v9; // rax
_DWORD *v10; // rax
unsigned long long v11; // rbx
unsigned int v12; // ebx
char v14; // [rsp+1Dh] [rbp-A3h] ... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xb8
MOV qword ptr [RBP + -0xb8],RDI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RCX
XOR ECX,ECX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RBP + -0x50],XMM0
MOVAPS xmmword ptr [RBP + -0x40],XMM0
MOVAPS xmmword ptr [RBP + -0x30],XMM0
MOVQ qword ptr [RBP + -0x20],... | /* func0(std::string) */
int func0(ulong param_1)
{
int iVar1;
bool bVar2;
char *pcVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
long in_FS_OFFSET;
allocator local_ab;
int local_aa;
__new_allocator<std::pair<char_const,int>> local_a9;
int local_a8;
int local_a4;
__new_allocator<std::pair<char... |
3,841 | func0 |
#include <iostream>
#include <string>
#include <unordered_map>
#include <assert.h>
using namespace std;
| int func0(string s) {
unordered_map<char, int> rom_val = {
{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50},
{'C', 100}, {'D', 500}, {'M', 1000}
};
int int_val = 0;
for (int i = 0; i < s.length(); i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom... | int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x88,%rsp
mov %rdi,%r12
mov %fs:0x28,%rax
mov %rax,0x78(%rsp)
xor %eax,%eax
movq $0x0,0x40(%rsp)
movq $0x0,0x48(%rsp)
movq $0x... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
xor eax, eax
pxor xmm0, xmm0
movaps [rsp+0C8h+var_78], xmm0
movaps [rsp+0C8h+var_68]... | long long func0(_QWORD *a1)
{
unsigned long long bkt; // rax
unsigned long long v2; // rbx
unsigned long long *v3; // rbx
unsigned int v4; // r13d
unsigned long long i; // rbx
int v7; // r15d
int v8; // r15d
long long **v9; // [rsp+8h] [rbp-C0h] BYREF
long long *v10; // [rsp+10h] [rbp-B8h] BYREF
lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
PXOR XMM0,XMM0
MOVAPS xmmword ptr [RSP + 0x50],XMM0
MOVAPS xmmword ptr [RSP + 0x60],XMM0
MOVAPS xmmword ptr [RSP + 0x70],XMM0
MOV dword ptr [RSP + 0x80],0x... | /* func0(std::string) */
int func0(long *param_1)
{
ulong uVar1;
int *piVar2;
pair_conflict *ppVar3;
int iVar4;
int iVar5;
long in_FS_OFFSET;
int8 *local_b8;
ulong local_b0;
int8 local_a8;
int8 local_a0;
int4 local_98 [2];
int8 local_90;
int8 local_88 [2];
int local_78 [4];
int4 uStack_7... |
3,842 | func0 |
#include <iostream>
#include <string>
#include <unordered_map>
#include <assert.h>
using namespace std;
| int func0(string s) {
unordered_map<char, int> rom_val = {
{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50},
{'C', 100}, {'D', 500}, {'M', 1000}
};
int int_val = 0;
for (int i = 0; i < s.length(); i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom... | int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
mov $0x7,%esi
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
lea 0x40(%rsp),%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
xor ecx, ecx
push r14
xor r14d, r14d
push r13
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
mov rax, 100000049h
lea rsi, [rsp+0C8h+var_78]
le... | long long func0(_QWORD *a1)
{
unsigned int v1; // r14d
_QWORD *v2; // rsi
long long v3; // rdx
long long v4; // rbp
_DWORD *i; // rax
unsigned long long v6; // r12
int v7; // r15d
long long v8; // rdx
_DWORD *v9; // rax
long long v10; // rdx
long long v11; // rsi
int v12; // r15d
long long v1... | func0:
ENDBR64
PUSH R15
XOR ECX,ECX
PUSH R14
XOR R14D,R14D
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,0x100000049
LEA RSI,[RSP + 0x50]
LEA R13,[RSP + 0x10]
LEA RDX,[RSP + 0x88]
SUB RSP,0x8
MOV RDI,R13
MOV qword ptr [RSP + 0x58],RAX
MOV... | /* func0(std::string) */
int func0(long *param_1)
{
ulong uVar1;
int iVar2;
int *piVar3;
ulong uVar4;
ulong uVar5;
int iVar6;
long in_FS_OFFSET;
equal_to local_bb;
allocator local_ba;
int local_b9;
pair local_b8 [64];
int8 local_78;
int8 local_70;
int8 local_68;
int8 local_60;
int8 loc... |
3,843 | func0 |
#include <iostream>
#include <string>
#include <unordered_map>
#include <assert.h>
using namespace std;
| int func0(string s) {
unordered_map<char, int> rom_val = {
{'I', 1}, {'V', 5}, {'X', 10}, {'L', 50},
{'C', 100}, {'D', 500}, {'M', 1000}
};
int int_val = 0;
for (int i = 0; i < s.length(); i++) {
if (i > 0 && rom_val[s[i]] > rom_val[s[i - 1]]) {
int_val += rom... | int main() {
assert(func0("MMMCMLXXXVI") == 3986);
assert(func0("MMMM") == 4000);
assert(func0("C") == 100);
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
pxor %xmm0,%xmm0
mov $0x7,%esi
push %r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %fs:0x28,%rax
mov %rax,0x98(%rsp)
xor %eax,%eax
lea 0x40(%rsp),%r... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
xor ecx, ecx
push r14
push r13
xor r13d, r13d
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 98h
mov rax, fs:28h
mov [rsp+0C8h+var_40], rax
mov rax, 100000049h
lea rsi, [rsp+0C8h+var_78]
le... | long long func0(_QWORD *a1)
{
unsigned int v1; // r13d
long long v2; // rbp
_DWORD *i; // rax
long long v4; // rdx
unsigned long long v5; // r12
int v6; // r15d
long long v7; // rdx
_DWORD *v8; // rax
long long v9; // rdx
long long v10; // rsi
int v11; // r15d
long long v12; // rdx
_DWORD *v1... | func0:
ENDBR64
PUSH R15
XOR ECX,ECX
PUSH R14
PUSH R13
XOR R13D,R13D
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x98
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
MOV RAX,0x100000049
LEA RSI,[RSP + 0x50]
LEA R14,[RSP + 0x10]
LEA RDX,[RSP + 0x88]
SUB RSP,0x8
MOV RDI,R14
MOV qword ptr [RSP + 0x58],RAX
MOV... | /* func0(std::string) */
int func0(long *param_1)
{
ulong uVar1;
int iVar2;
int8 *puVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
int iVar7;
long in_FS_OFFSET;
equal_to local_bb;
allocator local_ba;
int local_b9;
int *local_b8;
long local_b0;
int8 *local_a8;
int8 local_a0;
int local_88 ... |
3,844 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int l, int r) {
return (r / 2) * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2 ;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O0 | cpp | func0(int, int):
endbr64
push %rbp
mov %rsp,%rbp
mov %edi,-0x4(%rbp)
mov %esi,-0x8(%rbp)
mov -0x8(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
mov %eax,%ecx
mov -0x8(%rbp),%eax
mov %eax,%edx
shr $0x1f,%edx
add %edx,%eax
sar %eax
add $0x1,%eax
imul %eax,... | _Z5func0ii:
endbr64
push rbp
mov rbp, rsp
mov [rbp+var_4], edi
mov [rbp+var_8], esi
mov eax, [rbp+var_8]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
mov ecx, eax
mov eax, [rbp+var_8]
mov edx, eax
shr edx, 1Fh
add eax, edx
sar eax, 1
add eax, 1
imul ... | long long func0(int a1, int a2)
{
return (unsigned int)((a2 / 2 + 1) * (a2 / 2) + (a1 - 1) / 2 * (a1 + 1) / -2);
} | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
MOV dword ptr [RBP + -0x4],EDI
MOV dword ptr [RBP + -0x8],ESI
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
MOV ECX,EAX
MOV EAX,dword ptr [RBP + -0x8]
MOV EDX,EAX
SHR EDX,0x1f
ADD EAX,EDX
SAR EAX,0x1
ADD EAX,0x1
IMUL ECX,EAX
MOV EDX,ECX
MOV EAX,dword... | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_2 / 2) * (param_2 / 2 + 1) - ((param_1 + 1) * ((param_1 + -1) / 2)) / 2;
} |
3,845 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int l, int r) {
return (r / 2) * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2 ;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O1 | cpp | func0(int, int):
endbr64
mov %edi,%edx
mov %esi,%eax
shr $0x1f,%eax
lea (%rax,%rsi,1),%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
sar %edi
add $0x1,%edx
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
add %edx,%edi
sar %edi
lea... | _Z5func0ii:
endbr64
mov edx, edi
mov eax, esi
shr eax, 1Fh
lea ecx, [rax+rsi]
sar ecx, 1
lea eax, [rdi-1]
mov edi, eax
shr edi, 1Fh
add edi, eax
sar edi, 1
add edx, 1
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar edx, 1
lea eax, [rcx+1]
imul ... | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EDX,EDI
MOV EAX,ESI
SHR EAX,0x1f
LEA ECX,[RAX + RSI*0x1]
SAR ECX,0x1
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SHR EDI,0x1f
ADD EDI,EAX
SAR EDI,0x1
ADD EDX,0x1
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
LEA EAX,[RCX + 0x1]
IMUL EAX,ECX
SUB EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
3,846 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int l, int r) {
return (r / 2) * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2 ;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O2 | cpp | func0(int, int):
endbr64
mov %esi,%eax
mov %edi,%edx
shr $0x1f,%eax
add $0x1,%edx
add %esi,%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
lea 0x1(%rcx),%eax
sar %edi
imul %ecx,%eax
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
ad... | _Z5func0ii:
endbr64
mov eax, esi
mov edx, edi
shr eax, 1Fh
add edx, 1
lea ecx, [rax+rsi]
lea eax, [rdi-1]
mov edi, eax
sar ecx, 1
shr edi, 1Fh
add edi, eax
lea eax, [rcx+1]
sar edi, 1
imul eax, ecx
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar... | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EAX,ESI
MOV EDX,EDI
SHR EAX,0x1f
ADD EDX,0x1
LEA ECX,[RAX + RSI*0x1]
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SAR ECX,0x1
SHR EDI,0x1f
ADD EDI,EAX
LEA EAX,[RCX + 0x1]
SAR EDI,0x1
IMUL EAX,ECX
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
SUB EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
3,847 | func0 |
#include <iostream>
#include <assert.h>
| int func0(int l, int r) {
return (r / 2) * (r / 2 + 1) - (l - 1) / 2 * (l + 1) / 2 ;
}
| int main() {
assert(func0(2, 5) == 6);
assert(func0(3, 8) == 18);
assert(func0(4, 6) == 10);
return 0;
}
| O3 | cpp | func0(int, int):
endbr64
mov %esi,%eax
mov %edi,%edx
shr $0x1f,%eax
add $0x1,%edx
add %esi,%eax
sar %eax
mov %eax,%ecx
lea -0x1(%rdi),%eax
mov %eax,%edi
shr $0x1f,%edi
add %eax,%edi
lea 0x1(%rcx),%eax
sar %edi
imul %ecx,%eax
imul %edx,%edi
mov %edi,%edx
shr $0x1f,%edx
ad... | _Z5func0ii:
endbr64
mov eax, esi
mov edx, edi
shr eax, 1Fh
add edx, 1
lea ecx, [rax+rsi]
lea eax, [rdi-1]
mov edi, eax
sar ecx, 1
shr edi, 1Fh
add edi, eax
lea eax, [rcx+1]
sar edi, 1
imul eax, ecx
imul edi, edx
mov edx, edi
shr edx, 1Fh
add edx, edi
sar... | long long func0(int a1, int a2)
{
return (unsigned int)(a2 / 2 * (a2 / 2 + 1) - (a1 + 1) * ((a1 - 1) / 2) / 2);
} | func0:
ENDBR64
MOV EAX,ESI
MOV EDX,EDI
SHR EAX,0x1f
ADD EDX,0x1
LEA ECX,[RAX + RSI*0x1]
LEA EAX,[RDI + -0x1]
MOV EDI,EAX
SAR ECX,0x1
SHR EDI,0x1f
ADD EDI,EAX
LEA EAX,[RCX + 0x1]
SAR EDI,0x1
IMUL EAX,ECX
IMUL EDI,EDX
MOV EDX,EDI
SHR EDX,0x1f
ADD EDX,EDI
SAR EDX,0x1
SUB EAX,EDX
RET | /* func0(int, int) */
int func0(int param_1,int param_2)
{
return (param_2 / 2 + 1) * (param_2 / 2) - (((param_1 + -1) / 2) * (param_1 + 1)) / 2;
} |
3,848 | func0 |
#include <cassert>
#include <string>
#include <utility>
| std::pair<std::string, int> func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
if (discriminant > 0) {
return std::make_pair("Two solutions", discriminant);
} else if (discriminant == 0) {
return std::make_pair("one solution", discriminant);
} else {
re... | int main() {
assert(func0(4, 8, 2) == std::make_pair(std::string("Two solutions"), 32));
assert(func0(5, 7, 9) == std::make_pair(std::string("no real solution"), -131));
assert(func0(0, 0, 9) == std::make_pair(std::string("one solution"), 0));
}
| O0 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x50,%rsp
mov %rdi,-0x38(%rbp)
mov %esi,-0x3c(%rbp)
mov %edx,-0x40(%rbp)
mov %ecx,-0x44(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x40(%rbp),%eax
imul %eax,%eax
mov %eax,%edx
mov -0x3c(%rbp... | _Z5func0B5cxx11iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 50h
mov [rbp+var_38], rdi
mov [rbp+var_3C], esi
mov [rbp+var_40], edx
mov [rbp+var_44], ecx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_40]
imul eax, eax
mov ecx, eax
mov eax, [rbp+va... | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
long long v4; // rdx
long long v5; // rdx
int v7; // [rsp+2Ch] [rbp-24h] BYREF
long long v8; // [rsp+30h] [rbp-20h] BYREF
long long v9; // [rsp+38h] [rbp-18h]
unsigned long long v10; // [rsp+48h] [rbp-8h]
v10 = __readfsqword(0x28u);
v7... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x50
MOV qword ptr [RBP + -0x38],RDI
MOV dword ptr [RBP + -0x3c],ESI
MOV dword ptr [RBP + -0x40],EDX
MOV dword ptr [RBP + -0x44],ECX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x40]
IMUL EAX,EAX
MOV ECX,EAX
MOV ... | /* func0[abi:cxx11](int, int, int) */
pair<std::string,int> * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
pair pVar1;
int4 extraout_var;
int4 extraout_var_00;
int4 extraout_var_01;
int in_ECX;
int4 in_register_0000003c;
pair<std::string,int> *this;
long in_FS_OFFSET;
int local_2c;
int8... |
3,849 | func0 |
#include <cassert>
#include <string>
#include <utility>
| std::pair<std::string, int> func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
if (discriminant > 0) {
return std::make_pair("Two solutions", discriminant);
} else if (discriminant == 0) {
return std::make_pair("one solution", discriminant);
} else {
re... | int main() {
assert(func0(4, 8, 2) == std::make_pair(std::string("Two solutions"), 32));
assert(func0(5, 7, 9) == std::make_pair(std::string("no real solution"), -131));
assert(func0(0, 0, 9) == std::make_pair(std::string("one solution"), 0));
}
| O1 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %rbp
push %rbx
sub $0x8,%rsp
mov %rdi,%rbp
imul %edx,%edx
imul %ecx,%esi
shl $0x2,%esi
mov %edx,%ebx
sub %esi,%ebx
test %ebx,%ebx
jg 1269 <_Z5func0B5cxx11iii+0x40>
jne 128d <_Z5func0B5cxx11iii+0x64>
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
l... | _Z5func0B5cxx11iii:
endbr64
push rbp
push rbx
sub rsp, 8
mov rbp, rdi
imul edx, edx
imul esi, ecx
shl esi, 2
mov ebx, edx
sub ebx, esi
test ebx, ebx
jg short loc_12A9
jnz short loc_12CD
lea rax, [rdi+10h]
mov [rdi], rax
lea rdx, aOneSolution+0Ch; ""
lea rsi, [... | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
int v4; // edx
int v5; // esi
int v6; // ebx
v4 = a3 * a3;
v5 = 4 * a4 * a2;
v6 = v4 - v5;
if ( v4 - v5 > 0 )
{
*(_QWORD *)a1 = a1 + 16;
std::string::_M_construct<char const*>(a1, "Two solutions");
*(_DWORD *)(a1 + 32) = v6... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV RBP,RDI
IMUL EDX,EDX
IMUL ESI,ECX
SHL ESI,0x2
MOV EBX,EDX
SUB EBX,ESI
TEST EBX,EBX
JG 0x001012a9
JNZ 0x001012cd
LEA RAX,[RDI + 0x10]
MOV qword ptr [RDI],RAX
LEA RDX,[0x10214b]
LEA RSI,[RDX + -0xc]
CALL 0x001015fe
MOV dword ptr [RBP + 0x20],0x0
JMP 0x001012c3
L... | /* func0[abi:cxx11](int, int, int) */
long func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
long lVar1;
int in_ECX;
int iVar2;
int4 in_register_0000003c;
lVar1 = CONCAT44(in_register_0000003c,param_1);
iVar2 = param_3 * param_3 + param_2 * in_ECX * -4;
if (iVar2 < 1) {
if (iVar2 == 0) {
... |
3,850 | func0 |
#include <cassert>
#include <string>
#include <utility>
| std::pair<std::string, int> func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
if (discriminant > 0) {
return std::make_pair("Two solutions", discriminant);
} else if (discriminant == 0) {
return std::make_pair("one solution", discriminant);
} else {
re... | int main() {
assert(func0(4, 8, 2) == std::make_pair(std::string("Two solutions"), 32));
assert(func0(5, 7, 9) == std::make_pair(std::string("no real solution"), -131));
assert(func0(0, 0, 9) == std::make_pair(std::string("one solution"), 0));
}
| O2 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %r12
imul %edx,%edx
mov %rdi,%r12
push %rbx
imul %ecx,%esi
mov %edx,%ebx
sub $0x18,%rsp
shl $0x2,%esi
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
sub %esi,%ebx
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
test %ebx,%ebx
jg 16d0 <_Z5... | _Z5func0B5cxx11iii:
endbr64
imul esi, ecx
push rbp
lea rax, [rdi+10h]
imul edx, edx
push rbx
mov rbx, rdi
shl esi, 2
sub edx, esi
sub rsp, 8
mov [rdi], rax
mov ebp, edx
test edx, edx
jg short loc_15E0
jz short loc_15B8
lea rdx, aNoRealSolution+10h; ""
lea rsi... | long long func0[abi:cxx11](long long a1, int a2, int a3, int a4)
{
int v4; // edx
int v5; // ebp
v4 = a3 * a3 - 4 * a4 * a2;
*(_QWORD *)a1 = a1 + 16;
v5 = v4;
if ( v4 > 0 )
{
std::string::_M_construct<char const*>(a1, "Two solutions");
*(_DWORD *)(a1 + 32) = v5;
return a1;
}
else
{
... | func0[abi:cxx11]:
ENDBR64
IMUL ESI,ECX
PUSH RBP
LEA RAX,[RDI + 0x10]
IMUL EDX,EDX
PUSH RBX
MOV RBX,RDI
SHL ESI,0x2
SUB EDX,ESI
SUB RSP,0x8
MOV qword ptr [RDI],RAX
MOV EBP,EDX
TEST EDX,EDX
JG 0x001015e0
JZ 0x001015b8
LEA RDX,[0x10202f]
LEA RSI,[RDX + -0x10]
CALL 0x001014c0
MOV dword ptr [RBX + 0x20],EBP
ADD RSP,0x8
MOV ... | /* func0[abi:cxx11](int, int, int) */
long func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
long lVar1;
int in_ECX;
int iVar2;
int4 in_register_0000003c;
lVar1 = CONCAT44(in_register_0000003c,param_1);
iVar2 = param_3 * param_3 + param_2 * in_ECX * -4;
*(long *)CONCAT44(in_register_0000003c,pa... |
3,851 | func0 |
#include <cassert>
#include <string>
#include <utility>
| std::pair<std::string, int> func0(int x, int y, int z) {
int discriminant = (y * y) - (4 * x * z);
if (discriminant > 0) {
return std::make_pair("Two solutions", discriminant);
} else if (discriminant == 0) {
return std::make_pair("one solution", discriminant);
} else {
re... | int main() {
assert(func0(4, 8, 2) == std::make_pair(std::string("Two solutions"), 32));
assert(func0(5, 7, 9) == std::make_pair(std::string("no real solution"), -131));
assert(func0(0, 0, 9) == std::make_pair(std::string("one solution"), 0));
}
| O3 | cpp | func0[abi:cxx11](int, int, int):
endbr64
push %r12
imul %edx,%edx
mov %rdi,%r12
push %rbx
imul %ecx,%esi
mov %edx,%ebx
sub $0x18,%rsp
shl $0x2,%esi
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
sub %esi,%ebx
lea 0x10(%rdi),%rax
mov %rax,(%rdi)
test %ebx,%ebx
jg 16d0 <_Z5... | _Z5func0B5cxx11iii:
endbr64
push rbp
imul esi, ecx
push rbx
imul edx, edx
mov rbx, rdi
shl esi, 2
sub rsp, 18h
sub edx, esi
mov rax, fs:28h
mov [rsp+28h+var_20], rax
xor eax, eax
lea rax, [rdi+10h]
mov ebp, edx
mov [rdi], rax
test edx, edx
jg loc_15A0
jz ... | char * func0[abi:cxx11](char *a1, int a2, int a3, int a4)
{
int v4; // edx
int v5; // ebp
__m128i *v6; // rax
long long v7; // rdx
__m128i si128; // xmm0
long long v9; // rax
_QWORD v11[5]; // [rsp+0h] [rbp-28h] BYREF
v4 = a3 * a3 - 4 * a4 * a2;
v11[1] = __readfsqword(0x28u);
v5 = v4;
*(_QWORD *)... | func0[abi:cxx11]:
ENDBR64
PUSH RBP
IMUL ESI,ECX
PUSH RBX
IMUL EDX,EDX
MOV RBX,RDI
SHL ESI,0x2
SUB RSP,0x18
SUB EDX,ESI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA RAX,[RDI + 0x10]
MOV EBP,EDX
MOV qword ptr [RDI],RAX
TEST EDX,EDX
JG 0x001015a0
JZ 0x00101570
XOR EDX,EDX
MOV RSI,RSP
MOV qword... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0[abi:cxx11](int, int, int) */
ulong * func0_abi_cxx11_(int param_1,int param_2,int param_3)
{
int8 uVar1;
int8 uVar2;
int8 *puVar3;
int in_ECX;
int iVar4;
int4 in_register_0000003c;
ulong *puVar5;
long in_FS_O... |
3,852 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string s) {
std::string word;
size_t pos = 0;
while ((pos = s.find(' ')) != std::string::npos) {
word = s.substr(0, pos);
s.erase(0, pos + 1);
}
word = s;
if (word.length() % 2 == 0) {
return true;
} else {
return false;
}... | int main() {
assert(func0("program") == false);
assert(func0("solution") == true);
assert(func0("data") == true);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O0 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %rbp
mov %rsp,%rbp
push %rbx
sub $0x78,%rsp
mov %rdi,-0x78(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x60(%rbp),%rax
mov %rax,%rdi
callq 2390 <_ZNSt7__cxx1112basic_stri... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
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_60]
mov rdi, rax
call __ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIc... | _BOOL8 func0(long long a1)
{
_BOOL4 v1; // ebx
long long v3; // [rsp+18h] [rbp-68h]
_BYTE v4[32]; // [rsp+20h] [rbp-60h] BYREF
_BYTE v5[40]; // [rsp+40h] [rbp-40h] BYREF
unsigned long long v6; // [rsp+68h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::string::basic_string(v4);
while ( 1 )
{
v3 = std... | 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 + -0x60]
MOV RDI,RAX
CALL 0x001022f0
MOV qword ptr [RBP + -0x68],0x0
JMP 0x001024b3
LAB_0010245f:
LEA RAX,[RBP + -0x40]
MOV RDX,qword ptr [RBP + ... | /* func0(std::string) */
bool func0(string *param_1)
{
uint uVar1;
long lVar2;
long in_FS_OFFSET;
string local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
std::string::string(local_68);
while (lVar2 = std::string::find((char)param_1,0x20), lVar2 != -1)... |
3,853 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string s) {
std::string word;
size_t pos = 0;
while ((pos = s.find(' ')) != std::string::npos) {
word = s.substr(0, pos);
s.erase(0, pos + 1);
}
word = s;
if (word.length() % 2 == 0) {
return true;
} else {
return false;
}... | int main() {
assert(func0("program") == false);
assert(func0("solution") == true);
assert(func0("data") == true);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r12
push %rbp
push %rbx
sub $0x50,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%rax
mov %rax,(%rsp)
movq $0x0,0x8(%rsp)
movb $0x0,0x10(%rsp)
lea ... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r12
push rbp
push rbx
sub rsp, 50h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+68h+var_20], rax
xor eax, eax
lea rax, [rsp+68h+var_58]
mov [rsp+68h+var_68], rax
mov [rsp+68h+var_60], 0
mov byte ptr [rsp+68h... | _BOOL8 func0(_QWORD *a1)
{
char *v2; // rax
long long v3; // rcx
unsigned long long v4; // rdx
unsigned int v5; // edx
unsigned long long v6; // rdi
char *v7; // rax
char *v8; // rcx
unsigned int v9; // edx
unsigned int v10; // edx
unsigned int v11; // eax
unsigned long long v12; // rbx
unsigne... | func0:
ENDBR64
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x50
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x48],RAX
XOR EAX,EAX
LEA RAX,[RSP + 0x10]
MOV qword ptr [RSP],RAX
MOV qword ptr [RSP + 0x8],0x0
MOV byte ptr [RSP + 0x10],0x0
LEA R12,[RSP + 0x20]
JMP 0x001014da
LAB_00101329:
MOV RAX,qword ptr [RSP]
LEA... | /* func0(std::string) */
uint func0(int8 *param_1)
{
ulong *puVar1;
ulong uVar2;
uint uVar3;
long lVar4;
ulong uVar5;
uint uVar6;
ulong uVar7;
long in_FS_OFFSET;
ulong *local_68;
ulong local_60;
ulong local_58 [2];
ulong *local_48;
int8 local_40;
ulong local_38 [4];
local_38[3] = *(lo... |
3,854 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string s) {
std::string word;
size_t pos = 0;
while ((pos = s.find(' ')) != std::string::npos) {
word = s.substr(0, pos);
s.erase(0, pos + 1);
}
word = s;
if (word.length() % 2 == 0) {
return true;
} else {
return false;
}... | int main() {
assert(func0("program") == false);
assert(func0("solution") == true);
assert(func0("data") == true);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x50,%rsp
mov %fs:0x28,%rax
mov %rax,0x48(%rsp)
xor %eax,%eax
lea 0x10(%rsp),%r14
movb $0x0,0x10(%rsp)
lea 0x20(%rsp),%r13... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
mov r13, rdi
push r12
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea r15, [rsp+0A8h+var_80+8]
lea rax, [rsp+0A8h+var_68]
mov qwor... | _BOOL8 func0(long long a1)
{
unsigned long long v2; // rax
unsigned long long v3; // rbp
size_t v4; // rbx
__int8 *v5; // r14
long long *v6; // rax
long long *v7; // rax
long long *v8; // rcx
__m128i v9; // xmm0
long long v10; // rcx
unsigned long long v11; // rdx
__int8 *v12; // rax
long long ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RDI
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R15,[RSP + 0x30]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x20],R15
MOV byte ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + ... | /* func0(std::string) */
uint func0(int8 *param_1)
{
int *__src;
ulong *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
uint uVar6;
long in_FS_OFFSET;
ulong local_90;
ulong *local_88;
ulong local_80;
ulong auStack_78 [2];
ulong *local_68;
int8 local_60;
ulong auStack_58 [5];
... |
3,855 | func0 |
#include <iostream>
#include <string>
#include <assert.h>
| bool func0(std::string s) {
std::string word;
size_t pos = 0;
while ((pos = s.find(' ')) != std::string::npos) {
word = s.substr(0, pos);
s.erase(0, pos + 1);
}
word = s;
if (word.length() % 2 == 0) {
return true;
} else {
return false;
}... | int main() {
assert(func0("program") == false);
assert(func0("solution") == true);
assert(func0("data") == true);
std::cout << "All tests passed!" << std::endl;
return 0;
}
| O3 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
endbr64
push %r15
push %r14
push %r13
push %r12
push %rbp
mov %rdi,%rbp
push %rbx
sub $0x68,%rsp
mov %fs:0x28,%rax
mov %rax,0x58(%rsp)
xor %eax,%eax
lea 0x20(%rsp),%r14
movb $0x0,0x20(%rsp)
lea 0x4... | _Z5func0NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
mov r12, rdi
push rbp
push rbx
sub rsp, 78h
mov rax, fs:28h
mov [rsp+0A8h+var_40], rax
xor eax, eax
lea r15, [rsp+0A8h+var_80+8]
lea rax, [rsp+0A8h+var_68]
mov qwor... | _BOOL8 func0(long long a1)
{
unsigned long long v2; // rax
unsigned long long v3; // rbp
size_t v4; // rbx
__int8 *v5; // r14
long long *v6; // rax
long long *v7; // rax
long long *v8; // rcx
__m128i v9; // xmm0
long long v10; // rcx
unsigned long long v11; // rdx
long long *v12; // rdi
long lo... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x78
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x68],RAX
XOR EAX,EAX
LEA R15,[RSP + 0x30]
LEA RAX,[RSP + 0x40]
MOV qword ptr [RSP + 0x28],0x0
MOV qword ptr [RSP + 0x20],R15
MOV byte ptr [RSP + 0x30],0x0
MOV qword ptr [RSP + ... | /* func0(std::string) */
uint func0(int8 *param_1)
{
int *__src;
ulong *puVar1;
uint uVar2;
ulong uVar3;
ulong uVar4;
long lVar5;
uint uVar6;
long in_FS_OFFSET;
ulong local_90;
ulong *local_88;
ulong local_80;
ulong auStack_78 [2];
ulong *local_68;
int8 local_60;
ulong auStack_58 [5];
... |
3,856 | func0 |
#include <cassert>
#include <regex>
#include <string>
#include <algorithm>
| std::string func0(const std::string& text) {
std::regex re1("(.)([A-Z][a-z]+)");
std::string str1 = std::regex_replace(text, re1, "$1_$2");
std::regex re2("([a-z0-9])([A-Z])");
std::string result = std::regex_replace(str1, re2, "$1_$2");
std::transform(result.begin(), result.end(), result.begin... | int main() {
assert(func0("PythonProgram") == "python_program");
assert(func0("pythonLanguage") == "python_language");
assert(func0("ProgrammingLanguage") == "programming_language");
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 %r12
push %rbx
add $0xffffffffffffff80,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x80(%rbp),%ra... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r12
push rbx
add rsp, 0FFFFFFFFFFFFFF80h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_18], rax
xor eax, eax
lea rax, [rbp+var_80]
mov edx, 10h
lea ... | long long func0(long long a1, long long a2)
{
long long v2; // r12
long long v3; // rbx
long long v4; // rax
_BYTE v6[32]; // [rsp+10h] [rbp-80h] BYREF
_BYTE v7[32]; // [rsp+30h] [rbp-60h] BYREF
_BYTE v8[40]; // [rsp+50h] [rbp-40h] BYREF
unsigned long long v9; // [rsp+78h] [rbp-18h]
v9 = __readfsqword... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R12
PUSH RBX
ADD RSP,-0x80
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
LEA RAX,[RBP + -0x80]
MOV EDX,0x10
LEA RCX,[0x134051]
MOV RSI,RCX
MOV RDI,RAX
LAB_00104b6b:
CALL 0x0010622e
LEA RAX,... | /* func0(std::string const&) */
string * func0(string *param_1)
{
__normal_iterator _Var1;
__normal_iterator _Var2;
__normal_iterator _Var3;
int8 in_RSI;
long in_FS_OFFSET;
regex local_88 [32];
regex local_68 [32];
string local_48 [40];
long local_20;
local_20 = *(long *)(in_FS_OFFSET + 0x28);
... |
3,857 | func0 |
#include <cassert>
#include <regex>
#include <string>
#include <algorithm>
| std::string func0(const std::string& text) {
std::regex re1("(.)([A-Z][a-z]+)");
std::string str1 = std::regex_replace(text, re1, "$1_$2");
std::regex re2("([a-z0-9])([A-Z])");
std::string result = std::regex_replace(str1, re2, "$1_$2");
std::transform(result.begin(), result.end(), result.begin... | int main() {
assert(func0("PythonProgram") == "python_program");
assert(func0("pythonLanguage") == "python_language");
assert(func0("ProgrammingLanguage") == "programming_language");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x218,%rsp
mov %rdi,%rbx
mov %rsi,%rbp
mov %fs:0x28,%rax
mov %rax,0x208(%rsp)
xor %eax,%eax
lea 0x30(%rsp),%r13
mov %r13,%rdi
callq 4710 <_... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r14
push r12
push rbx
sub rsp, 208h
mov r14, rdi
mov rbx, rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
lea r12, [rbp+var_218]
mov rdi, r12; this
call __ZNSt6loc... | long long func0(long long a1, long long a2)
{
long long v3; // rdx
long long v4; // rax
long long v5; // rdi
long long v6; // rdx
long long v7; // rax
long long v8; // rdi
_BYTE *v9; // r12
_BYTE *i; // rbx
int v12; // [rsp+0h] [rbp-220h] BYREF
_BYTE v13[8]; // [rsp+8h] [rbp-218h] BYREF
long long... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R14
PUSH R12
PUSH RBX
SUB RSP,0x208
MOV R14,RDI
MOV RBX,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
LEA R12,[RBP + -0x218]
MOV RDI,R12
CALL 0x00104730
MOV qword ptr [RBP + -0x210],0x0
MOV qword ptr [RBP + -0x208],0x0
LEA RDI,[RBP + -0x1c0]
MOV R8D... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
_Sp_counted_base<(_Lock_policy)2> *p_Var2;
int iVar3;
char *pcVar4;
int8 *in_RSI;
char *pcVar5;
long in_FS_OFFSET;
int4 local_228 [2];
locale local_220 [2];
int8 local_218;
_Sp_counted_ba... |
3,858 | func0 |
#include <cassert>
#include <regex>
#include <string>
#include <algorithm>
| std::string func0(const std::string& text) {
std::regex re1("(.)([A-Z][a-z]+)");
std::string str1 = std::regex_replace(text, re1, "$1_$2");
std::regex re2("([a-z0-9])([A-Z])");
std::string result = std::regex_replace(str1, re2, "$1_$2");
std::transform(result.begin(), result.end(), result.begin... | int main() {
assert(func0("PythonProgram") == "python_program");
assert(func0("pythonLanguage") == "python_language");
assert(func0("ProgrammingLanguage") == "programming_language");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x248,%rsp
mov %fs:0x28,%rax
mov %rax,0x238(%rsp)
xor %eax,%eax
lea 0x60(%rsp),%rbp
lea ... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push r15
push r14
push r13
push r12
lea r12, [rbp+var_228]
push rbx
mov rbx, rdi
mov rdi, r12; this
sub rsp, 238h
mov [rbp+var_238], rsi
mov rax, fs:28h
mov [rbp+var_38], rax
x... | char ** func0(char **a1)
{
char *v2; // rsi
__m128i v3; // xmm0
volatile signed __int32 *v4; // r13
long long v5; // rdx
volatile signed __int32 *v6; // rcx
signed __int32 v7; // eax
long long v8; // r13
long long v9; // rdx
volatile signed __int32 *v10; // rcx
signed __int32 v11; // eax
char *v12... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R15
PUSH R14
PUSH R13
PUSH R12
LEA R12,[RBP + -0x228]
PUSH RBX
MOV RBX,RDI
MOV RDI,R12
SUB RSP,0x238
MOV qword ptr [RBP + -0x238],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x38],RAX
XOR EAX,EAX
CALL 0x00104710
LEA RDX,[0x11a687]
PXOR XMM0,XMM0
LEA RDI,[RBP + -0x1d0]
... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Sp_counted_base<(_Lock_policy)2> *p_Var1;
int8 uVar2;
int auVar3 [16];
int iVar4;
int8 *in_RSI;
char *pcVar5;
char *pcVar6;
long in_FS_OFFSET;
int4 local_238 [2];
locale local_230 [2];
int local_228 [16];
int4 local_218 [2];
... |
3,859 | func0 |
#include <cassert>
#include <regex>
#include <string>
#include <algorithm>
| std::string func0(const std::string& text) {
std::regex re1("(.)([A-Z][a-z]+)");
std::string str1 = std::regex_replace(text, re1, "$1_$2");
std::regex re2("([a-z0-9])([A-Z])");
std::string result = std::regex_replace(str1, re2, "$1_$2");
std::transform(result.begin(), result.end(), result.begin... | int main() {
assert(func0("PythonProgram") == "python_program");
assert(func0("pythonLanguage") == "python_language");
assert(func0("ProgrammingLanguage") == "programming_language");
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
sub $0x248,%rsp
mov %rsi,0x8(%rsp)
lea 0x60(%rsp),%rbp
lea 0x48(%rsp),%r13
mov %rbp,%rdi
lea 0xa0(%rsp),%rbx
m... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
mov r13, rsi
push r12
push rbp
push rbx
mov rbx, rdi
sub rsp, 228h
mov rax, fs:28h
mov [rsp+258h+var_40], rax
xor eax, eax
lea r12, [rsp+258h+var_230]
lea rbp, [rsp+258h+v... | char ** func0(char **a1, long long *a2)
{
__m128i v4; // xmm0
long long v5; // rdi
void *v6; // rdi
void **v7; // r14
unsigned long long v8; // r15
void *v9; // rdi
long long v10; // rsi
long long v11; // rdx
__m128i v12; // xmm0
long long v13; // rdi
void *v14; // rdi
void **v15; // r15
unsig... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
MOV R13,RSI
PUSH R12
PUSH RBP
PUSH RBX
MOV RBX,RDI
SUB RSP,0x228
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x218],RAX
XOR EAX,EAX
LEA R12,[RSP + 0x28]
LEA RBP,[RSP + 0x80]
MOV RDI,R12
CALL 0x00104730
PXOR XMM0,XMM0
MOV RCX,R12
MOV RDI,RBP
LEA RDX,[0x11b682]
MOV R8D,0x10
... | /* func0(std::string const&) */
string * func0(string *param_1)
{
int8 uVar1;
int auVar2 [16];
int iVar3;
char *pcVar4;
int8 *in_RSI;
ulong in_R9;
int8 *puVar5;
int8 *puVar6;
char *pcVar7;
long in_FS_OFFSET;
match_flag_type in_stack_fffffffffffffda8;
int4 local_238 [2];
locale local_230 [2];... |
3,860 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& tuple1) {
std::vector<std::vector<std::string>> result;
for (const auto& t : tuple1) {
if (!t.empty()) {
result.push_back(t);
}
}
return result;
}
| int main() {
std::vector<std::vector<std::string>> input1 = { {}, {}, {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
std::vector<std::vector<std::string>> expected1 = { {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
assert(func0(input1) == expected1);
std::vector<std::vector<std::string>> input2 = { {},... | 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, 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
cal... | long long func0(long long a1, long long a2)
{
long long v3; // [rsp+18h] [rbp-38h] BYREF
_QWORD v4[2]; // [rsp+20h] [rbp-30h] BYREF
long long v5; // [rsp+30h] [rbp-20h]
unsigned long long v6; // [rsp+38h] [rbp-18h]
v6 = __readfsqword(0x28u);
std::vector<std::vector<std::string>>::vector(a1);
v4[1] = a2;... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0x48
MOV qword ptr [RBP + -0x48],RDI
MOV qword ptr [RBP + -0x50],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x48]
MOV RDI,RAX
CALL 0x0010375c
MOV RAX,qword ptr [RBP + -0x50]
MOV qword ptr [RBP + -0x28],RAX
MO... | /* 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::vector<std::string,std::allocator<std::string>>,std::allocator<std::vector<... |
3,861 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& tuple1) {
std::vector<std::vector<std::string>> result;
for (const auto& t : tuple1) {
if (!t.empty()) {
result.push_back(t);
}
}
return result;
}
| int main() {
std::vector<std::vector<std::string>> input1 = { {}, {}, {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
std::vector<std::vector<std::string>> expected1 = { {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
assert(func0(input1) == expected1);
std::vector<std::vector<std::string>> input2 = { {},... | 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, 8
mov r13, rdi
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
mov r... | _QWORD * func0(_QWORD *a1, _QWORD *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r15
struct _Unwind_Exception *v5; // rbx
long long v6; // rbp
long long v7; // rax
_QWORD *v8; // r12
unsigned long long v9; // rbp
long long v10; // rax
*a1 = 0LL;
a1[1] = 0LL;
a1[2] = 0LL;
v2 = (_QWORD *)*a2;
v3 = (_... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV R13,RDI
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R15,qword ptr [RSI + 0x8]
CMP R15,RBX
JNZ 0x001013b7
LAB_00101361:
MOV RAX,R13
ADD RSP,0x8
POP RBX
POP RBP
POP R12... | /* 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;
long lVar2;
long lVar3;
int8 *puVar4;
int8 uVar5;
string *psVar6;
vector *pvVar7;
ulo... |
3,862 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& tuple1) {
std::vector<std::vector<std::string>> result;
for (const auto& t : tuple1) {
if (!t.empty()) {
result.push_back(t);
}
}
return result;
}
| int main() {
std::vector<std::vector<std::string>> input1 = { {}, {}, {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
std::vector<std::vector<std::string>> expected1 = { {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
assert(func0(input1) == expected1);
std::vector<std::vector<std::string>> input2 = { {},... | 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
mov r12, rdi
push rbp
push rbx
sub rsp, 8
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r14, [... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r14
signed long long v4; // rbp
unsigned long long v5; // rax
long long v6; // rbp
long long v7; // r13
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = (_QWORD *)*a2;
v3 = (_QWORD *)a2[1];
if ( v3 != (_QWORD *)*a... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
CMP R14,RBX
JZ 0x0010219b
MOV R15,0x7fffffffffffffe0
JMP 0x0010216c
LAB_00102110:
PXOR XMM0,XMM0
... | /* 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;
int (*pauVar2) [16];
string *psVar3;
int8 uVar4;
vector *pvVar5;
ulong uVar6;
int8 *in_... |
3,863 | func0 |
#include <vector>
#include <string>
#include <cassert>
| std::vector<std::vector<std::string>> func0(const std::vector<std::vector<std::string>>& tuple1) {
std::vector<std::vector<std::string>> result;
for (const auto& t : tuple1) {
if (!t.empty()) {
result.push_back(t);
}
}
return result;
}
| int main() {
std::vector<std::vector<std::string>> input1 = { {}, {}, {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
std::vector<std::vector<std::string>> expected1 = { {""}, {"a", "b"}, {"a", "b", "c"}, {"d"} };
assert(func0(input1) == expected1);
std::vector<std::vector<std::string>> input2 = { {},... | 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
mov r12, rdi
push rbp
push rbx
sub rsp, 8
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
mov rbx, [rsi]
mov r14, [... | long long func0(long long a1, _QWORD *a2)
{
_QWORD *v2; // rbx
_QWORD *v3; // r14
signed long long v4; // rbp
unsigned long long v5; // rax
long long v6; // rbp
long long v7; // r13
*(_QWORD *)(a1 + 16) = 0LL;
*(_OWORD *)a1 = 0LL;
v2 = (_QWORD *)*a2;
v3 = (_QWORD *)a2[1];
if ( v3 != (_QWORD *)*a... | func0:
ENDBR64
PUSH R15
PXOR XMM0,XMM0
PUSH R14
PUSH R13
PUSH R12
MOV R12,RDI
PUSH RBP
PUSH RBX
SUB RSP,0x8
MOV qword ptr [RDI + 0x10],0x0
MOVUPS xmmword ptr [RDI],XMM0
MOV RBX,qword ptr [RSI]
MOV R14,qword ptr [RSI + 0x8]
CMP R14,RBX
JZ 0x001022cb
MOV R15,0x7fffffffffffffe0
JMP 0x0010229c
LAB_00102240:
PXOR XMM0,XMM0
... | /* 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;
int (*pauVar2) [16];
string *psVar3;
int8 uVar4;
vector *pvVar5;
ulong uVar6;
int8 *in_... |
3,864 | func0 |
#include <iostream>
#include <string>
#include <set>
#include <assert.h>
| std::string func0(const std::string& string) {
std::set<char> vowels = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
std::set<char> stringSet;
for (char c : string) {
if (vowels.find(c) != vowels.end()) {
stringSet.insert(c);
if (stringSet.size() >= 5) {
... | int main() {
assert(func0("SEEquoiaL") == "accepted");
assert(func0("program") == "not accepted");
assert(func0("fine") == "not accepted");
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 %r13
push %r12
push %rbx
sub $0xc8,%rsp
mov %rdi,-0xd8(%rbp)
mov %rsi,-0xe0(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
movb $0x41,-0x32(%rbp)... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push rbp
mov rbp, rsp
push rbx
sub rsp, 0E8h
mov [rbp+var_E8], rdi
mov [rbp+var_F0], rsi
mov rcx, fs:28h
mov [rbp+var_18], rcx
xor ecx, ecx
mov [rbp+var_22], 41h ; 'A'
mov [rbp+var_21], 45h ; 'E'
mov [r... | long long func0(long long a1, long long a2)
{
char v3; // [rsp+1Fh] [rbp-D1h] BYREF
long long v4; // [rsp+20h] [rbp-D0h] BYREF
long long v5; // [rsp+28h] [rbp-C8h] BYREF
long long v6; // [rsp+30h] [rbp-C0h] BYREF
long long v7; // [rsp+38h] [rbp-B8h] BYREF
long long v8; // [rsp+40h] [rbp-B0h]
_BYTE *v9; /... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH RBX
SUB RSP,0xe8
MOV qword ptr [RBP + -0xe8],RDI
MOV qword ptr [RBP + -0xf0],RSI
MOV RCX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x18],RCX
XOR ECX,ECX
MOV byte ptr [RBP + -0x22],0x41
MOV byte ptr [RBP + -0x21],0x45
MOV byte ptr [RBP + -0x20],0x49
MOV byte ptr [RBP + -0x1f],0x4... | /* func0(std::string const&) */
string * func0(string *param_1)
{
char cVar1;
bool bVar2;
char *pcVar3;
ulong uVar4;
long in_FS_OFFSET;
char local_d9;
int8 local_d8;
int8 local_d0;
int8 local_c8;
int8 local_c0 [2];
__new_allocator<char> *local_b0;
int8 *local_a8;
int8 *local_a0;
set<char,s... |
3,865 | func0 |
#include <iostream>
#include <string>
#include <set>
#include <assert.h>
| std::string func0(const std::string& string) {
std::set<char> vowels = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
std::set<char> stringSet;
for (char c : string) {
if (vowels.find(c) != vowels.end()) {
stringSet.insert(c);
if (stringSet.size() >= 5) {
... | int main() {
assert(func0("SEEquoiaL") == "accepted");
assert(func0("program") == "not accepted");
assert(func0("fine") == "not accepted");
return 0;
}
| O1 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x98,%rsp
mov %rdi,%r13
mov %rsi,%r12
mov %fs:0x28,%rax
mov %rax,0x88(%rsp)
xor %eax,%eax
movb $0x41,0x7e(%rsp)
movb $0x45,0x7f(%rsp)
movb $... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov r13, rdi
mov r12, rsi
mov rax, fs:28h
mov [rsp+0B8h+var_30], rax
xor eax, eax
mov [rsp+0B8h+var_3A], 41h ; 'A'
mov [rsp+0B8h+var_39], 45h ; 'E'
mov ... | _QWORD * func0(_QWORD *a1, char **a2)
{
unsigned long long *v2; // rbx
long long insert_hint_unique_pos; // rax
long long v4; // rdx
char *v5; // r12
char *v6; // rbx
long long v7; // rax
char *v8; // rcx
long long insert_unique_pos; // rax
long long v10; // rdx
char v11; // dl
char v13; // [rsp+7... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV R13,RDI
MOV R12,RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOV byte ptr [RSP + 0x7e],0x41
MOV byte ptr [RSP + 0x7f],0x45
MOV byte ptr [RSP + 0x80],0x49
MOV byte ptr [RSP + 0x81],0x4f
MOV byte ptr [RSP + 0x82],0x55
MOV by... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Rb_tree_node *p_Var1;
_Rb_tree_node *p_Var2;
_Rb_tree_node *p_Var3;
_Alloc_node *p_Var4;
int8 *in_RSI;
_Alloc_node *p_Var5;
long in_FS_OFFSET;
int auVar6 [16];
_Alloc_node local_b1;
_Rb_tree_node_base *local_b0;
_Rb_tree<char,cha... |
3,866 | func0 |
#include <iostream>
#include <string>
#include <set>
#include <assert.h>
| std::string func0(const std::string& string) {
std::set<char> vowels = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
std::set<char> stringSet;
for (char c : string) {
if (vowels.find(c) != vowels.end()) {
stringSet.insert(c);
if (stringSet.size() >= 5) {
... | int main() {
assert(func0("SEEquoiaL") == "accepted");
assert(func0("program") == "not accepted");
assert(func0("fine") == "not accepted");
return 0;
}
| O2 | cpp | func0(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&):
endbr64
push %r15
push %r14
mov %rsi,%r14
push %r13
push %r12
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,0x8(%rsp)
lea 0x28(%rsp),%rbp
lea 0x8e(%rsp),%rbx
lea 0x20(%rsp),%r13
lea 0x98(%rsp),%... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_C0], rdi
lea r13, [rsp+0C8h+var_B0]
lea rbp, [rsp+0C8h+var_50]
mov [rsp+0C8h+var_C8], rsi
lea r15, [rsp+0C8h+var_B8]
mov ... | long long func0(long long a1, unsigned __int8 **a2)
{
char *v2; // rbp
long long i; // rax
char v4; // r14
int *v5; // rbx
long long insert_unique_pos; // rax
int *v7; // rdx
bool v8; // al
bool v9; // r12
long long v10; // rax
unsigned __int8 *v11; // rbp
unsigned __int8 *v12; // r14
unsigned ... | func0:
ENDBR64
PUSH R15
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],RDI
LEA R13,[RSP + 0x18]
LEA RBP,[RSP + 0x78]
MOV qword ptr [RSP],RSI
LEA R15,[RSP + 0x10]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOV RAX,qword ptr [0x00102100]
MOV dword ptr [RSP ... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Rb_tree_node_base *p_Var1;
_Rb_tree_node_base _Var2;
void *pvVar3;
void *pvVar4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
_Rb_tree_node_base *p_Var8;
_Rb_tree_node_base *p_Var9;
int8 *in_R... |
3,867 | func0 |
#include <iostream>
#include <string>
#include <set>
#include <assert.h>
| std::string func0(const std::string& string) {
std::set<char> vowels = {'A', 'E', 'I', 'O', 'U', 'a', 'e', 'i', 'o', 'u'};
std::set<char> stringSet;
for (char c : string) {
if (vowels.find(c) != vowels.end()) {
stringSet.insert(c);
if (stringSet.size() >= 5) {
... | int main() {
assert(func0("SEEquoiaL") == "accepted");
assert(func0("program") == "not accepted");
assert(func0("fine") == "not accepted");
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
push %rbp
push %rbx
sub $0xa8,%rsp
mov %rdi,0x18(%rsp)
lea 0x28(%rsp),%r13
lea 0x8e(%rsp),%rbx
mov %rsi,0x8(%rsp)
lea 0x20(%rsp),%r14
lea 0x98(%... | _Z5func0RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE:
endbr64
push r15
mov r15, rsi
push r14
xor r14d, r14d
push r13
push r12
push rbp
push rbx
sub rsp, 98h
mov [rsp+0C8h+var_C0], rdi
lea r13, [rsp+0C8h+var_B0]
lea rbp, [rsp+0C8h+var_50]
mov rax, fs:28h
mov [r... | long long func0(long long a1, long long a2)
{
long long v2; // r14
char *v3; // rbp
char v4; // r12
int *v5; // rbx
bool v6; // r14
long long v7; // rax
char *v8; // r12
long long v9; // rax
int *v10; // rbx
char *v11; // r15
char *v12; // rax
char v13; // bp
char *v14; // rsi
char *v15; //... | func0:
ENDBR64
PUSH R15
MOV R15,RSI
PUSH R14
XOR R14D,R14D
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x98
MOV qword ptr [RSP + 0x8],RDI
LEA R13,[RSP + 0x18]
LEA RBP,[RSP + 0x78]
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x88],RAX
XOR EAX,EAX
MOV RAX,qword ptr [0x00102108]
MOV dword ptr [RSP + 0x18],0x0
MOV qwo... | /* func0(std::string const&) */
string * func0(string *param_1)
{
_Rb_tree_node_base _Var1;
_Rb_tree_node_base *p_Var2;
_Rb_tree_node_base *p_Var3;
_Rb_tree_node_base *p_Var4;
_Rb_tree_node_base *p_Var5;
_Rb_tree_node_base *p_Var6;
_Rb_tree_node_base *p_Var7;
_Rb_tree_node_base *p_Var8;
_Rb_tree_nod... |
3,868 | func0 |
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::min(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O0 | cpp | func0(int, int, int):
endbr64
push %rbp
mov %rsp,%rbp
sub $0x20,%rsp
mov %edi,-0x14(%rbp)
mov %esi,-0x18(%rbp)
mov %edx,-0x1c(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x8(%rbp)
xor %eax,%eax
mov -0x18(%rbp),%eax
sub $0x1,%eax
mov %eax,-0x10(%rbp)
lea -0x1c(%rbp),%rdx
lea -0x10(%rbp),%r... | _Z5func0iii:
endbr64
push rbp
mov rbp, rsp
sub rsp, 20h
mov [rbp+var_14], edi
mov [rbp+var_18], esi
mov [rbp+var_1C], edx
mov rax, fs:28h
mov [rbp+var_8], rax
xor eax, eax
mov eax, [rbp+var_18]
sub eax, 1
mov [rbp+var_10], eax
lea rdx, [rbp+var_1C]
lea rax, [rbp+va... | long long func0(int a1, int a2, int a3)
{
int v4; // [rsp+4h] [rbp-1Ch] BYREF
int v5; // [rsp+8h] [rbp-18h]
int v6; // [rsp+Ch] [rbp-14h]
int v7; // [rsp+10h] [rbp-10h] BYREF
int v8; // [rsp+14h] [rbp-Ch]
unsigned long long v9; // [rsp+18h] [rbp-8h]
v6 = a1;
v5 = a2;
v4 = a3;
v9 = __readfsqword(0x... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
SUB RSP,0x20
MOV dword ptr [RBP + -0x14],EDI
MOV dword ptr [RBP + -0x18],ESI
MOV dword ptr [RBP + -0x1c],EDX
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x8],RAX
XOR EAX,EAX
MOV EAX,dword ptr [RBP + -0x18]
SUB EAX,0x1
MOV dword ptr [RBP + -0x10],EAX
LEA RDX,[RBP + -0x1c]
LEA RA... | /* func0(int, int, int) */
ulong func0(int param_1,int param_2,int param_3)
{
int *piVar1;
long in_FS_OFFSET;
int local_24;
int local_20;
int local_1c;
int local_18;
int local_14;
long local_10;
local_10 = *(long *)(in_FS_OFFSET + 0x28);
local_18 = param_2 + -1;
local_24 = param_3;
local_20... |
3,869 | func0 |
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::min(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O1 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
cmp %edx,%ecx
mov %edx,%eax
cmovle %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_2 + -1 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
3,870 | func0 |
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::min(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O2 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovle %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_2 + -1 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
3,871 | func0 |
#include <algorithm>
#include <cassert>
| int func0(int A, int B, int N) {
int x = std::min(B - 1, N);
return (A * x) / B;
}
| int main() {
assert(func0(11, 10, 9) == 9);
assert(func0(5, 7, 4) == 2);
assert(func0(2, 2, 1) == 1);
return 0;
}
| O3 | cpp | func0(int, int, int):
endbr64
lea -0x1(%rsi),%ecx
mov %edx,%eax
cmp %edx,%ecx
cmovle %ecx,%eax
imul %edi,%eax
cltd
idiv %esi
retq
nopw %cs:0x0(%rax,%rax,1)
| _Z5func0iii:
endbr64
mov eax, edx
lea edx, [rsi-1]
cmp edx, eax
cmovle eax, edx
imul eax, edi
cdq
idiv esi
retn | long long func0(int a1, int a2, int a3)
{
int v3; // eax
v3 = a3;
if ( a2 - 1 <= a3 )
v3 = a2 - 1;
return (unsigned int)(a1 * v3 / a2);
} | func0:
ENDBR64
MOV EAX,EDX
LEA EDX,[RSI + -0x1]
CMP EDX,EAX
CMOVLE EAX,EDX
IMUL EAX,EDI
CDQ
IDIV ESI
RET | /* func0(int, int, int) */
int [16] func0(int param_1,int param_2,int param_3)
{
int auVar1 [16];
if (param_2 + -1 <= param_3) {
param_3 = param_2 + -1;
}
auVar1._0_8_ = (long)(param_3 * param_1) / (long)param_2 & 0xffffffff;
auVar1._8_8_ = (long)(param_3 * param_1) % (long)param_2 & 0xffffffff;
r... |
3,872 | func0 |
#include <cassert>
#include <vector>
| std::vector<std::vector<int>> func0(const std::vector<std::pair<int, int>>& test_list) {
std::vector<std::vector<int>> res;
for(const auto& sub : test_list){
if(!res.empty() && res.back()[0] == sub.first){
res.back().push_back(sub.second);
}
else{
res.empla... | int main(){
std::vector<std::pair<int, int>> input1 = { {5, 6}, {5, 7}, {6, 8}, {6, 10}, {7, 13} };
std::vector<std::vector<int>> expected1 = { {5, 6, 7}, {6, 8, 10}, {7, 13} };
assert(func0(input1) == expected1);
std::vector<std::pair<int, int>> input2 = { {6, 7}, {6, 8}, {7, 9}, {7, 11}, {8,... | O0 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %rbp
mov %rsp,%rbp
push %r13
push %r12
push %rbx
sub $0x78,%rsp
mov %rdi,-0x88(%rbp)
mov %rsi,-0x90(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x28(%rbp)
xor %eax,%eax
mov -0x88(%rbp),%rax
mov %... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push rbp
mov rbp, rsp
push r13
push r12
push rbx
sub rsp, 78h
mov [rbp+var_88], rdi
mov [rbp+var_90], rsi
mov rax, fs:28h
mov [rbp+var_28], rax
xor eax, eax
mov rax, [rbp+var_88]
mov rdi, rax
call _ZNSt6vectorIS_IiSaIiEE... | long long func0(long long a1, long long a2)
{
long long v2; // rax
_DWORD *v3; // rax
long long v5; // rax
char v7; // [rsp+17h] [rbp-79h] BYREF
long long v8; // [rsp+18h] [rbp-78h] BYREF
_QWORD v9[2]; // [rsp+20h] [rbp-70h] BYREF
_DWORD *v10; // [rsp+30h] [rbp-60h]
char *v11; // [rsp+38h] [rbp-58h]
... | func0:
ENDBR64
PUSH RBP
MOV RBP,RSP
PUSH R13
PUSH R12
PUSH RBX
SUB RSP,0x78
MOV qword ptr [RBP + -0x88],RDI
MOV qword ptr [RBP + -0x90],RSI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RBP + -0x28],RAX
XOR EAX,EAX
MOV RAX,qword ptr [RBP + -0x88]
MOV RDI,RAX
CALL 0x00102270
MOV RAX,qword ptr [RBP + -0x90]
MOV qword ptr [R... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1)
{
char cVar1;
bool bVar2;
vector<int,std::allocator<int>> *pvVar3;
int *piVar4;
vector<std::pair<int,int>,std::allocator<std::pair<int,int>>> *in_RSI;
long in_FS_OFFSET;
__new_allo... |
3,873 | func0 |
#include <cassert>
#include <vector>
| std::vector<std::vector<int>> func0(const std::vector<std::pair<int, int>>& test_list) {
std::vector<std::vector<int>> res;
for(const auto& sub : test_list){
if(!res.empty() && res.back()[0] == sub.first){
res.back().push_back(sub.second);
}
else{
res.empla... | int main(){
std::vector<std::pair<int, int>> input1 = { {5, 6}, {5, 7}, {6, 8}, {6, 10}, {7, 13} };
std::vector<std::vector<int>> expected1 = { {5, 6, 7}, {6, 8, 10}, {7, 13} };
assert(func0(input1) == expected1);
std::vector<std::pair<int, int>> input2 = { {6, 7}, {6, 8}, {7, 9}, {7, 11}, {8,... | O1 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r13
push %r12
push %rbp
push %rbx
sub $0x28,%rsp
mov %rdi,%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)
movq $0x0,0x10(%rdi)
mov (%rsi),%rb... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r13
push r12
push rbp
push rbx
sub rsp, 28h
mov rbp, rdi
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov qword ptr [rdi], 0
mov qword ptr [rdi+8], 0
mov qword ptr [rdi+10h], 0
mov rbx, [rsi]
mov r13, [rs... | _QWORD * func0(_QWORD *a1, long long **a2)
{
long long *v3; // rbx
long long *v4; // r13
_DWORD *v6; // rsi
_QWORD *v7; // rdx
_QWORD *v8; // rsi
long long v9; // rdi
long long v10; // r12
_QWORD *v11; // rax
void *v12; // [rsp+0h] [rbp-48h] BYREF
_QWORD *v13; // [rsp+8h] [rbp-40h]
char *v14; // [... | func0:
ENDBR64
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x28
MOV RBP,RDI
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x18],RAX
XOR EAX,EAX
MOV qword ptr [RDI],0x0
MOV qword ptr [RDI + 0x8],0x0
MOV qword ptr [RDI + 0x10],0x0
MOV RBX,qword ptr [RSI]
MOV R13,qword ptr [RSI + 0x8]
CMP R13,RBX
JNZ 0x00101398
LAB_001... | /* func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&) */
vector * func0(vector *param_1)
{
int *piVar1;
int *piVar2;
int8 *puVar3;
long lVar4;
int8 uVar5;
int *piVar6;
int8 *in_RSI;
long in_FS_OFFSET;
int8 *local_48;
int8 *local_40;
int8 *local_38;
long local... |
3,874 | func0 |
#include <cassert>
#include <vector>
| std::vector<std::vector<int>> func0(const std::vector<std::pair<int, int>>& test_list) {
std::vector<std::vector<int>> res;
for(const auto& sub : test_list){
if(!res.empty() && res.back()[0] == sub.first){
res.back().push_back(sub.second);
}
else{
res.empla... | int main(){
std::vector<std::pair<int, int>> input1 = { {5, 6}, {5, 7}, {6, 8}, {6, 10}, {7, 13} };
std::vector<std::vector<int>> expected1 = { {5, 6, 7}, {6, 8, 10}, {7, 13} };
assert(func0(input1) == expected1);
std::vector<std::pair<int, int>> input2 = { {6, 7}, {6, 8}, {7, 9}, {7, 11}, {8,... | O2 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r13
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,(%rdi)
movq $0x0,0x8(%rdi)... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r12, [rsi+8]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
... | long long * func0(long long *a1, long long a2)
{
_DWORD *v3; // rbx
_DWORD *v4; // r12
long long v5; // rax
long long i; // rdi
long long v7; // r13
_QWORD *v8; // rax
_QWORD *v9; // rdx
_QWORD *v10; // rsi
_QWORD *v11; // rsi
long long v12; // rsi
int v13; // eax
long long v14; // rsi
void *v... | func0:
MOV RDI,RSP
CALL 0x00101f80
LAB_00101208:
MOV RDI,RBP
CALL 0x00101c50
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101232
MOV RDI,RBX
LAB_00101223:
CALL 0x001011f0 | /* 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,long param_9)
{
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vecto... |
3,875 | func0 |
#include <cassert>
#include <vector>
| std::vector<std::vector<int>> func0(const std::vector<std::pair<int, int>>& test_list) {
std::vector<std::vector<int>> res;
for(const auto& sub : test_list){
if(!res.empty() && res.back()[0] == sub.first){
res.back().push_back(sub.second);
}
else{
res.empla... | int main(){
std::vector<std::pair<int, int>> input1 = { {5, 6}, {5, 7}, {6, 8}, {6, 10}, {7, 13} };
std::vector<std::vector<int>> expected1 = { {5, 6, 7}, {6, 8, 10}, {7, 13} };
assert(func0(input1) == expected1);
std::vector<std::pair<int, int>> input2 = { {6, 7}, {6, 8}, {7, 9}, {7, 11}, {8,... | O3 | cpp | func0(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int> > > const&):
endbr64
push %r13
pxor %xmm0,%xmm0
push %r12
mov %rdi,%r12
push %rbp
push %rbx
sub $0x28,%rsp
mov (%rsi),%rbx
mov 0x8(%rsi),%rbp
mov %fs:0x28,%rax
mov %rax,0x18(%rsp)
xor %eax,%eax
movq $0x0,0x10(%rdi... | _Z5func0RKSt6vectorISt4pairIiiESaIS1_EE:
endbr64
push r13
pxor xmm0, xmm0
push r12
push rbp
mov rbp, rdi
push rbx
sub rsp, 28h
mov rbx, [rsi]
mov r12, [rsi+8]
mov rax, fs:28h
mov [rsp+48h+var_30], rax
xor eax, eax
mov qword ptr [rdi+10h], 0
movups xmmword ptr [rdi], xmm0
... | long long * func0(long long *a1, long long a2)
{
_DWORD *v3; // rbx
_DWORD *v4; // r12
long long v5; // rax
long long i; // rdi
long long v7; // r13
_QWORD *v8; // rax
_QWORD *v9; // rdx
_QWORD *v10; // rsi
_QWORD *v11; // rsi
long long v12; // rsi
int v13; // eax
long long v14; // rsi
void *v... | func0:
MOV RDI,R13
CALL 0x00101d90
LAB_00101240:
MOV RDI,RBP
CALL 0x00101d10
MOV RAX,qword ptr [RSP + 0x18]
SUB RAX,qword ptr FS:[0x28]
JNZ 0x00101260
MOV RDI,RBX
LAB_0010125b:
CALL 0x001011f0
LAB_00101260:
CALL 0x001011b0 | /* 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,long param_9)
{
vector<std::vector<int,std::allocator<int>>,std::allocator<std::vecto... |
3,876 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
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
jge 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]
jge 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]
JGE 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;
} |
3,877 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
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;
} |
3,878 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
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;
} |
3,879 | func0 |
#include <assert.h>
| int func0(int x, int y) {
if (x < y) {
return x;
}
return y;
}
| int main() {
assert(func0(10, 20) == 10);
assert(func0(19, 15) == 15);
assert(func0(-10, -20) == -20);
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;
} |
3,880 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
std::vector<int> dp(n + 10, -1);
dp[0] = 0;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = std::max(dp[i] + 1, dp[i + a]);
}
if (i + b <= n) {
dp[i + b... | int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
return 0;
}
| O0 | cpp | func0(int, 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 %ecx,-0x50(%rbp)
mov %fs:0x28,%rax
mov %rax,-0x18(%rbp)
xor %eax,%eax
lea -0x39(%rbp),%rax
mov %rax,%rdi
callq 161c <_ZNSaIiEC1Ev>
... | _Z5func0iiii:
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 [rbp+var_60], ecx
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+... | long long func0(int a1, int a2, int a3, int a4)
{
long long v4; // rbx
long long v5; // rbx
long long v6; // rbx
unsigned int v7; // ebx
char v11; // [rsp+1Fh] [rbp-41h] BYREF
int v12; // [rsp+20h] [rbp-40h] BYREF
int i; // [rsp+24h] [rbp-3Ch]
char *v14; // [rsp+28h] [rbp-38h]
_BYTE v15[24]; // [rsp+... | 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 dword ptr [RBP + -0x60],ECX
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
... | /* func0(int, int, int, int) */
int4 func0(int param_1,int param_2,int param_3,int param_4)
{
int iVar1;
int4 uVar2;
int4 *puVar3;
int *piVar4;
int *piVar5;
long in_FS_OFFSET;
allocator local_49;
int local_48;
int local_44;
allocator *local_40;
vector<int,std::allocator<int>> local_38 [24];
lo... |
3,881 | func0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <assert.h>
| int func0(int n, int a, int b, int c) {
std::vector<int> dp(n + 10, -1);
dp[0] = 0;
for (int i = 0; i < n; i++) {
if (dp[i] != -1) {
if (i + a <= n) {
dp[i + a] = std::max(dp[i] + 1, dp[i + a]);
}
if (i + b <= n) {
dp[i + b... | int main() {
assert(func0(7, 5, 2, 5) == 2);
assert(func0(17, 2, 1, 3) == 17);
assert(func0(18, 16, 3, 6) == 6);
return 0;
}
| O1 | cpp | func0(int, int, int, int):
endbr64
push %r14
push %r13
push %r12
push %rbp
push %rbx
sub $0x10,%rsp
mov %edx,%r12d
mov %fs:0x28,%rax
mov %rax,0x8(%rsp)
xor %eax,%eax
lea 0xa(%rdi),%eax
cltq
movabs $0x1fffffffffffffff,%rdx
cmp %rdx,%rax
ja 1296 <_Z5func0iiii+0x8d>
mov %edi,%ebx
mov ... | _Z5func0iiii:
endbr64
push r14
push r13
push r12
push rbp
push rbx
sub rsp, 10h
mov rax, fs:28h
mov [rsp+38h+var_30], rax
xor eax, eax
lea ebp, [rdi+0Ah]
movsxd rbp, ebp
mov rax, rbp
shr rax, 3Dh
jnz short loc_1258
mov ebx, edi
mov r12d, esi
mov r13d, edx
mov ... | long long func0(int a1, int a2, int a3, int a4)
{
unsigned long long v4; // rbp
int *v9; // rax
int *v10; // r8
int *v11; // rdx
int *v12; // rax
int v13; // edi
int v14; // esi
int v15; // ecx
int *v16; // rdx
int *v17; // r13
int *v18; // rdx
int *v19; // r12
int v20; // edx
int *v21; // ... | func0:
ENDBR64
PUSH R14
PUSH R13
PUSH R12
PUSH RBP
PUSH RBX
SUB RSP,0x10
MOV RAX,qword ptr FS:[0x28]
MOV qword ptr [RSP + 0x8],RAX
XOR EAX,EAX
LEA EBP,[RDI + 0xa]
MOVSXD RBP,EBP
MOV RAX,RBP
SHR RAX,0x3d
JNZ 0x00101258
MOV EBX,EDI
MOV R12D,ESI
MOV R13D,EDX
MOV R14D,ECX
TEST RBP,RBP
JZ 0x0010130f
SHL RBP,0x2
MOV RDI,RBP
... | /* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* func0(int, int, int, int) */
int func0(int param_1,int param_2,int param_3,int param_4)
{
int *piVar1;
int iVar2;
int *piVar3;
int *piVar4;
ulong uVar5;
ulong uVar6;
int *piVar7;
long in_FS_OFFSET;
int local_34;
... |
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.