LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::filter_path_from_by_nodea(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
vector<Edge *> *Graph::filter_path_from_by_nodea(Node *n, vector<Edge *> *list)
{
    vector<Edge *> *rf = new vector<Edge *>;
    vector<Edge *>::iterator x = list->begin();
    for (; x != list->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), n->name->c_str()))
        {
            rf->push_back((*x));
        }
    }

    return rf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x18
popq %rdi
callq 0x5260
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x15966
movq (%r12), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x5360
testl %eax, %eax
jne 0x15960
movq %r15, %rdi
movq %r12, %rsi
callq 0x15a2e
addq $0x8, %r12
jmp 0x15933
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::path_from(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void Graph::path_from(Node *a, vector<Edge *> *r)
{

    vector<Edge *>::iterator x = edges->begin();
    for (; x != edges->end(); x++)
    {

        if (0 == strcmp((*x)->nodea->name->c_str(), a->name->c_str()))
        {

            r->push_back((*x));
            path_from((*x)->nodeb, r);
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r13
movq (%r13), %r12
cmpq 0x8(%r13), %r12
je 0x159ec
movq (%r12), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq (%r14), %rax
movq (%rax), %rsi
callq 0x5360
testl %eax, %eax
jne 0x159e6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x15a2e
movq (%r12), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1598a
movq (%r15), %r13
addq $0x8, %r12
jmp 0x159a3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/make_shared.cc
// Function: main
int main(int argc, char const *argv[])
{
	auto num = cplusplus_primer::make_shared<int>(42);
	std::cout << *num << std::endl;

	// basic_string(size_type count, CharT ch, const Allocator& alloc = Allocator());
	auto str = cplusplus_primer::make_shared<std::string>(10, 'c');
	std::cout << *str << std::endl;

	auto foo = cplusplus_primer::make_shared<Foo>(99);
	std::cout << foo->bar << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
leaq -0x30(%rbp), %rsi
movl $0x2a, (%rsi)
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x132b
movq (%rbx), %rax
movl (%rax), %esi
movq 0x2d71(%rip), %rdi      # 0x3fd8
callq 0x10e0
movq %rax, %rdi
callq 0x1050
leaq -0x20(%rbp), %rsi
movl $0xa, (%rsi)
leaq -0xc(%rbp), %rdx
movb $0x63, (%rdx)
leaq -0x30(%rbp), %rdi
callq 0x134a
movq -0x30(%rbp), %rsi
movq 0x2d3f(%rip), %rdi      # 0x3fd8
callq 0x1080
movq %rax, %rdi
callq 0x1050
leaq -0xc(%rbp), %rsi
movl $0x63, (%rsi)
leaq -0x20(%rbp), %rdi
callq 0x136c
movq -0x20(%rbp), %rax
movl (%rax), %esi
movq 0x2d12(%rip), %rdi      # 0x3fd8
callq 0x10e0
movq %rax, %rdi
callq 0x1050
leaq -0x18(%rbp), %rdi
callq 0x138c
leaq -0x28(%rbp), %rdi
callq 0x138c
leaq -0x38(%rbp), %rdi
callq 0x138c
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x1309
jmp 0x1317
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x138c
jmp 0x130c
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x138c
jmp 0x131a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x138c
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: main
int main(){
    bench(bench_lock);
    bench(bench_lock_guard);
    bench(bench_atomic);

    return 0;
}

// Assembly:
pushq %rax
callq 0x2329
callq 0x2487
callq 0x2609
callq 0x278b
callq 0x290d
callq 0x2a8f
callq 0x2c11
callq 0x2d93
callq 0x2f19
callq 0x3077
callq 0x31f9
callq 0x337b
callq 0x34fd
callq 0x367f
callq 0x3801
callq 0x3983
callq 0x3b09
callq 0x3c46
callq 0x3da7
callq 0x3f08
callq 0x4069
callq 0x41ca
callq 0x432b
callq 0x448c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: void bench_atomic<2>()
void bench_atomic(){
    std::mutex mutex;
    unsigned long throughput = 0;

    for(int i = 0; i < REPEAT; ++i){
        std::atomic<int> counter;
        counter.store(0);

        std::vector<std::thread> threads;

        Clock::time_point t0 = Clock::now();

        for(int i = 0; i < Threads; ++i){
            threads.push_back(std::thread([&](){
                for(int i = 0; i < OPERATIONS; ++i){
                    ++counter;
                }
            }));
        }

        for(auto& thread : threads){
            thread.join();
        }

        Clock::time_point t1 = Clock::now();

        milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);
        throughput += (Threads * OPERATIONS) / ms.count();
    }
    std::cout << "atomic with " << Threads << " threads throughput = " << (throughput / REPEAT) << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x10(%rsp), %r14
leaq 0x4(%rsp), %rbx
leaq 0x40(%rsp), %r15
leaq 0x38(%rsp), %r12
xorl %eax, %eax
movq $0x0, 0x8(%rsp)
cmpl $0x5, %eax
je 0x3d25
movq %rax, 0x30(%rsp)
xorl %eax, %eax
vxorps %xmm0, %xmm0, %xmm0
xchgl %eax, 0x4(%rsp)
vmovaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
callq 0x2030
movq %rax, 0x28(%rsp)
pushq $0x2
popq %rbp
subl $0x1, %ebp
jb 0x3cce
movq %rbx, 0x38(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5430
movq %r14, %rdi
movq %r15, %rsi
callq 0x468c
movq %r15, %rdi
callq 0x465c
jmp 0x3ca4
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r13
cmpq %r13, %rbp
je 0x3ceb
movq %rbp, %rdi
callq 0x2150
addq $0x8, %rbp
jmp 0x3cd8
callq 0x2030
subq 0x28(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
movq %r14, %rdi
cqto
idivq %rcx
xorl %edx, %edx
movq %rax, %rcx
movl $0x7a120, %eax          # imm = 0x7A120
idivq %rcx
addq %rax, 0x8(%rsp)
callq 0x466a
movq 0x30(%rsp), %rax
incl %eax
jmp 0x3c73
movq 0x72ac(%rip), %rdi      # 0xafd8
leaq 0x233a(%rip), %rsi      # 0x606d
callq 0x2110
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x2160
leaq 0x22e1(%rip), %rsi      # 0x602b
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
pushq $0x5
popq %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
callq 0x20b0
movq %rax, %rdi
callq 0x2080
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d83
movq %rax, %rbx
jmp 0x3d95
leaq 0x40(%rsp), %rdi
movq %rax, %rbx
callq 0x465c
leaq 0x10(%rsp), %rdi
callq 0x466a
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int tss_help(std::string name)
{
    std::cout << "Tom's simple shell\n"
              << "These shell commands are defined internally. Type 'help' to see this list.\n"
              << "Type 'help name' to find out more about the function 'name'.\n"
              << "The following are built in: "
              << tss_get()
              << std::endl;
    /// \todo Help for individual commands
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x49ae(%rip), %rdi      # 0x6fc0
leaq 0x19f0(%rip), %rsi      # 0x4009
callq 0x21a0
leaq 0x19f8(%rip), %rsi      # 0x401d
movq %rax, %rdi
callq 0x21a0
leaq 0x1a35(%rip), %rsi      # 0x4069
movq %rax, %rdi
callq 0x21a0
leaq 0x1a64(%rip), %rsi      # 0x40a7
movq %rax, %rdi
callq 0x21a0
movq %rax, %rbx
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2696
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x2318
pushq $0x1
popq %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2318
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_get[abi:cxx11]()
std::string tss_get()
{
    std::string str;
    for(auto elem : funcMap)
        str.append("\n " + elem.first);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x4b07(%rip), %r12      # 0x71c8
leaq -0x88(%rbp), %r14
leaq 0x19fd(%rip), %r15      # 0x40cc
leaq -0x48(%rbp), %r13
leaq 0x4ade(%rip), %rax      # 0x71b8
cmpq %rax, %r12
je 0x2722
leaq 0x20(%r12), %rsi
movq %r14, %rdi
callq 0x2d9a
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2dd4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22f0
movq %r13, %rdi
callq 0x2318
movq %r14, %rdi
callq 0x2d28
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
jmp 0x26d3
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2756
movq %rax, %r14
jmp 0x274a
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x2318
leaq -0x88(%rbp), %rdi
callq 0x2d28
movq %rbx, %rdi
callq 0x2318
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/frainfreeze[P]tss/./shell.h
// Function: shell::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string exec(std::string cmd) {
    // http://man7.org/linux/man-pages/man3/popen.3.html
    std::array<char, 128> buffer;
    std::string result;
    std::shared_ptr<FILE> pipe(popen(cmd.c_str(), "r"), pclose);

    if (!pipe) {
        throw std::runtime_error("popen() failed!");
    }
    
    while (!feof(pipe.get())) {
        if (fgets(buffer.data(), 128, pipe.get()) != nullptr)
            result += buffer.data();
    }
    
    return result;
    /// \todo Ignores stderr
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rdi
leaq 0x1913(%rip), %rsi      # 0x40d4
callq 0x20a0
movq 0x47fb(%rip), %rdx      # 0x6fc8
leaq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3544
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2833
leaq -0xa8(%rbp), %r14
callq 0x2260
testl %eax, %eax
jne 0x2819
movq -0x28(%rbp), %rdx
movq %r14, %rdi
movl $0x80, %esi
callq 0x2280
testq %rax, %rax
je 0x2813
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22e0
movq -0x28(%rbp), %rdi
jmp 0x27e9
leaq -0x20(%rbp), %rdi
callq 0x308a
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x2110
movq %rax, %r15
leaq 0x1891(%rip), %rsi      # 0x40d6
movq %rax, %rdi
callq 0x20d0
movq 0x479c(%rip), %rsi      # 0x6ff0
movq 0x4755(%rip), %rdx      # 0x6fb0
movq %r15, %rdi
callq 0x22a0
jmp 0x2877
movq %rax, %r14
movq %r15, %rdi
callq 0x2150
jmp 0x287a
movq %rax, %r14
jmp 0x2883
movq %rax, %r14
leaq -0x20(%rbp), %rdi
callq 0x308a
movq %rbx, %rdi
callq 0x2318
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/frainfreeze[P]tss/./shell.h
// Function: shell::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int parse(std::string input)
{
    std::string arg = input.substr(0, input.find(" "));
    if(arg=="exit"){
        return 0;
    } 
    else if(arg=="help"){
        return builtins::funcMap["help"]("");
    } 
    else if(arg=="cd"){
        builtins::tss_cd(input.substr(input.find_first_of(" \t")+1));
    } 
    else {
        std::cout << exec(input);   
        return 1; 
    }

    /// \todo Actual input parsing
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x1820(%rip), %rsi      # 0x40cd
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x2300
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21d0
leaq 0x1814(%rip), %rsi      # 0x40e6
movq %r15, %rdi
callq 0x2e85
testb %al, %al
jne 0x29b0
leaq 0x17de(%rip), %rsi      # 0x40c7
leaq -0x60(%rbp), %rdi
callq 0x2e85
testb %al, %al
je 0x295d
leaq 0x17ca(%rip), %rsi      # 0x40c7
leaq -0x40(%rbp), %rdi
leaq -0x1a(%rbp), %rdx
callq 0x2e4a
leaq 0x489f(%rip), %rdi      # 0x71b0
leaq -0x40(%rbp), %rsi
callq 0x2e96
movq %rax, %rbx
leaq 0x17c9(%rip), %rsi      # 0x40ed
leaq -0xa0(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x2e4a
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x2f00
movl %eax, %r14d
leaq -0xa0(%rbp), %rdi
callq 0x2318
leaq -0x40(%rbp), %rdi
callq 0x2318
jmp 0x29b0
leaq 0x1760(%rip), %rsi      # 0x40c4
leaq -0x60(%rbp), %rdi
callq 0x2e85
testb %al, %al
jne 0x29ca
leaq -0x80(%rbp), %rdi
movq %rbx, %rsi
callq 0x2210
leaq -0x40(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2794
movq 0x462f(%rip), %rdi      # 0x6fc0
leaq -0x40(%rbp), %rsi
callq 0x2190
leaq -0x40(%rbp), %rdi
callq 0x2318
leaq -0x80(%rbp), %rdi
callq 0x2318
pushq $0x1
popq %r14
leaq -0x60(%rbp), %rdi
callq 0x2318
movl %r14d, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x171a(%rip), %rsi      # 0x40eb
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2120
leaq 0x1(%rax), %rdx
leaq -0xc0(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0x21d0
leaq -0xc0(%rbp), %rbx
movq %rbx, %rdi
callq 0x25ef
movq %rbx, %rdi
callq 0x2318
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2318
jmp 0x2a2a
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x2318
jmp 0x2a37
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x2a3b
jmp 0x2a34
jmp 0x2a44
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2318
jmp 0x2a47
jmp 0x2a44
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2318
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/tests/pingpong.cpp
// Function: main
int
main()
{
	try
	{
		run();
	}
	catch (const std::exception& ex)
	{
		std::cerr << ex.what() << std::endl;
		exit(EXIT_FAILURE);
	}
}

// Assembly:
pushq %rbx
callq 0x240c
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x279a
movq %rbx, %rdi
callq 0x20a0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x486e(%rip), %rdi      # 0x6fe8
movq %rax, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21b0
movq %rax, %rbx
callq 0x2230
movq %rbx, %rdi
callq 0x2260
movq %rax, %rdi
callq 0x2a15
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::circular_queue_factory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, bool, std::function<int (gdc::circular_queue<unsigned long>&)>)
circular_queue_factory(
			const std::string& name,
			size_type capacity,
			bool sync = true,
			mdinit_type metadata_initializer = [](Q&) -> int { return 0; }) :
			_name(name),
			_capacity(capacity),
			_sync(sync),
			_metadata_initializer(metadata_initializer),
			_q(nullptr, null_queue_destroyer)
		{
			assert(!name.empty());
			assert(capacity >= 0);
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21d0
movq %r12, 0x20(%rbx)
movb %bpl, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x2bfe
leaq 0x234(%rip), %rax       # 0x2ab6
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
cmpq $0x0, 0x8(%r14)
je 0x289b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1857(%rip), %rdi      # 0x40f9
leaq 0x185e(%rip), %rsi      # 0x4107
leaq 0x191b(%rip), %rcx      # 0x41cb
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x2120
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<unsigned long>::push(unsigned long const*, unsigned long)
bool push(const_pointer data, size_type nbytes) noexcept
		{
			auto p = alloc(nbytes);
			
			if (p == nullptr)
			{
				return false;
			}
			
			std::memmove(p, data, nbytes);
			commit(nbytes);
			return true;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x3984
movq %rax, %r15
testq %rax, %rax
je 0x29a2
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2220
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a06
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::unmap_shared(gdc::circular_queue<unsigned long>*)
static void unmap_shared(Q* q)
		{
			if (q == nullptr)
			{
				return;
			}

			size_type capacity = q->capacity();
			size_type fp = footprint(capacity);

			if (::munmap(q, fp + capacity) == -1)
			{
				std::string what("munmap: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x35dd
movq %rdi, %rbx
movq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x3878
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
cmpl $-0x1, %eax
je 0x35e5
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xe75(%rip), %rsi       # 0x4461
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x27aa
callq 0x2030
movl (%rax), %edi
callq 0x2070
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22c0
pushq $0x18
popq %rdi
callq 0x20e0
movq %rax, %rbx
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x2b7a
leaq 0x36d4(%rip), %rsi      # 0x6d08
leaq -0xa9d(%rip), %rdx      # 0x2b9e
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x2150
jmp 0x3653
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::create_private(unsigned long, bool, std::function<int (gdc::circular_queue<unsigned long>&)>)
static Q* create_private(
			size_type capacity,
			bool sync,
			mdinit_type metadata_initializer)
		{
			static std::atomic<int> seq(0);
			int unique = seq.fetch_add(1, std::memory_order_relaxed);
			pid_t pid = ::getpid();
			char tmp_name[32];
			std::sprintf(tmp_name, "/.gdcq.%d.%d", pid, unique);
			create_shared(tmp_name, capacity, sync, metadata_initializer);
			Q* q = nullptr;

			try
			{
				q = map_shared(tmp_name);
			}
			catch (const circular_queue_error& ex)
			{
				delete_shared(tmp_name);
				throw;
			}

			try
			{
				delete_shared(tmp_name);
			}
			catch (const circular_queue_error& ex)
			{
				unmap_shared(q);
				delete_shared(tmp_name);
				throw;
			}

			return q;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x1
popq %r15
lock
xaddl %r15d, 0x3b39(%rip)     # 0x71c0
callq 0x2200
leaq 0xdd7(%rip), %rsi       # 0x446a
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movl %eax, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x2040
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0x27aa
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x2bfe
movzbl %bpl, %edx
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rcx
movq %rbx, %rsi
callq 0x2d76
leaq 0x50(%rsp), %rdi
callq 0x28ce
leaq 0x10(%rsp), %rdi
callq 0x20c0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x27aa
leaq 0x10(%rsp), %rdi
callq 0x30d0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x27aa
leaq 0x10(%rsp), %rdi
callq 0x2ab8
leaq 0x10(%rsp), %rdi
callq 0x20c0
movq %r14, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x376b
movq %rdx, %r15
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x3869
movq %rbx, %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x35ac
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x27aa
leaq 0x10(%rsp), %rdi
callq 0x2ab8
leaq 0x10(%rsp), %rdi
callq 0x20c0
callq 0x21f0
jmp 0x3825
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x37c8
jmp 0x37c5
movq %rax, %rbx
callq 0x2230
jmp 0x3869
movq %rdx, %r14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x37ea
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x3869
movq %rbx, %rdi
callq 0x20a0
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
callq 0x27aa
leaq 0x10(%rsp), %rdi
callq 0x2ab8
leaq 0x10(%rsp), %rdi
callq 0x20c0
callq 0x21f0
jmp 0x3836
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x3839
movq %rax, %rbx
callq 0x2230
jmp 0x3869
movq %rax, %rdi
callq 0x2a15
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x28ce
jmp 0x385a
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20c0
jmp 0x3869
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::footprint(unsigned long)
static size_type footprint(size_type capacity)
		{
			static long page_size = ::sysconf(_SC_PAGESIZE);
			if (page_size == -1)
			{
				return 0;
			}
			assert(page_size > 0);
			
			if (capacity == 0)
			{
				return page_size;
			}
			
			// Calculate the smallest multiple of page size such that
			// size >= page size + capacity.
			// The first page is for control data.
			// The other pages are for data.
			//
			// Examples:
			// capacity == 0 => footprint = page_size.
			// capacity == 1 => footprint = page_size.
			// capacity == page_size => footprint = page_size.
			// capacity == page_size + 1 => footprint = 2 * page_size.
			long footprint = page_size + (((capacity - 1) / page_size) + 1) * page_size;
			return footprint;
		}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb 0x3926(%rip), %al       # 0x71a8
testb %al, %al
je 0x38b9
movq 0x3913(%rip), %rcx      # 0x71a0
cmpq $-0x1, %rcx
je 0x38b2
testq %rcx, %rcx
jle 0x38e6
testq %rbx, %rbx
je 0x38b4
decq %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x2, %rax
imulq %rax, %rcx
jmp 0x38b4
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
leaq 0x38e8(%rip), %rdi      # 0x71a8
callq 0x2290
testl %eax, %eax
je 0x3886
pushq $0x1e
popq %rdi
callq 0x2110
movq %rax, 0x38c8(%rip)      # 0x71a0
leaq 0x38c9(%rip), %rdi      # 0x71a8
callq 0x2100
jmp 0x3886
leaq 0x717(%rip), %rdi       # 0x4004
leaq 0x813(%rip), %rsi       # 0x4107
leaq 0xa21(%rip), %rcx       # 0x431c
pushq $0x5a
popq %rdx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<unsigned long>::alloc(unsigned long) const
pointer alloc(size_type nbytes) const noexcept
		{
			assert(nbytes > 0);
			assert(nbytes < capacity());
			
			if (nbytes > space())
			{
				return nullptr;
			}
			
			auto wp = _q.wpos.load(std::memory_order_relaxed);
			auto d = data();
			auto p = &d[wp];
			auto pp = const_cast<char*>(p);
			return reinterpret_cast<pointer>(pp);
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x39c7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x39e6
movq %rbx, %rdi
callq 0x3a76
cmpq %r14, %rax
jae 0x39b0
xorl %eax, %eax
jmp 0x39bf
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x3abe
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xaa9(%rip), %rdi       # 0x4477
leaq 0xaad(%rip), %rsi       # 0x4482
leaq 0xac1(%rip), %rcx       # 0x449d
movl $0xf6, %edx
callq 0x2120
leaq 0xb07(%rip), %rdi       # 0x44f4
leaq 0xa8e(%rip), %rsi       # 0x4482
leaq 0xaa2(%rip), %rcx       # 0x449d
movl $0xf7, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<unsigned long>::commit(unsigned long)
void commit(size_type nbytes) noexcept
		{
			assert(nbytes > 0);
			assert(nbytes < capacity());
			auto wp = _q.wpos.load(std::memory_order_relaxed);
			wp = (wp + nbytes) % capacity();
			auto mo = _q.properties.sync ? std::memory_order_release : std::memory_order_relaxed;
			_q.wpos.store(wp, mo);
		}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x3a38
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3a57
movq 0x40(%rdi), %rax
addq %rsi, %rax
movq 0x80(%rdi), %rcx
xorl %edx, %edx
divq %rcx
cmpl $0x0, 0x88(%rdi)
movq %rdx, 0x40(%rdi)
popq %rax
retq
leaq 0xa38(%rip), %rdi       # 0x4477
leaq 0xa3c(%rip), %rsi       # 0x4482
leaq 0xb11(%rip), %rcx       # 0x455e
movl $0x108, %edx            # imm = 0x108
callq 0x2120
leaq 0xa96(%rip), %rdi       # 0x44f4
leaq 0xa1d(%rip), %rsi       # 0x4482
leaq 0xaf2(%rip), %rcx       # 0x455e
movl $0x109, %edx            # imm = 0x109
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH06_Functions/examples/ref-fcn.cc
// Function: main
int main() 
{
    string s("a value");
    cout << s << endl;   // prints a value

    get_val(s, 0) = 'A'; // changes s[0] to A
    cout << s << endl;   // prints A value

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0xe0c(%rip), %rsi       # 0x2004
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x1030
movq 0x2dc9(%rip), %rdi      # 0x3fd8
movq %rbx, %rsi
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %rsi
movq (%rsi), %rax
movb $0x41, (%rax)
movq 0x2da8(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
callq 0x1050
leaq -0x30(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1040
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Logs.cpp
// Function: Logs::panel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Logs::panel(std::string all)
{
    Zest::Settings settings;

    if (settings.verbose() == true)
        std::cout << all << std::endl;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x11(%rbp), %r14
movq %r14, %rdi
callq 0x2640
movq %r14, %rdi
callq 0x265c
testb %al, %al
je 0x2495
movq 0x9b53(%rip), %rdi      # 0xbfd8
movq %rbx, %rsi
callq 0x2130
movq %rax, %rdi
callq 0x20c0
leaq -0x11(%rbp), %rdi
callq 0x2656
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2656
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Zest.cpp
// Function: Zest::Zest::check_id_a(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Zest::Zest::check_id_a(std::string id)
{
    int index = 0;

    for (auto i = this->a_id.begin(); i != this->a_id.end(); i++) {
        if (*i == id) {
            this->a_id.erase(this->a_id.begin() + index);
            return (true);
        }
        index++;
    }

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rdi), %rbx
xorl %r13d, %r13d
movq 0x10(%r12), %r14
cmpq %r14, %rbx
je 0x26cb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ab9
testb %al, %al
jne 0x26bc
addq $0x20, %rbx
addq $-0x20, %r13
jmp 0x2699
movq -0x30(%rbp), %rdi
movq (%rdi), %rsi
subq %r13, %rsi
callq 0x2ae6
cmpq %r14, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Zest.cpp
// Function: Zest::Zest::html[abi:cxx11]()
std::string Zest::Zest::html()
{
    if (Zest::Zest::check(this->_html_) == true) {
        Zest::Zest::set_html(false);
        return ("</html>");
    }
    Zest::Zest::set_html(true);
    return ("<html>");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x2810
movb $0x0, (%rsi)
leaq 0x5861(%rip), %rsi      # 0x806b
leaq -0xa(%rbp), %rdx
jmp 0x281e
movb $0x1, (%rsi)
leaq 0x5859(%rip), %rsi      # 0x8073
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x2b2c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Zest.cpp
// Function: Zest::Zest::a(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Zest::Zest::a(std::string id)
{
    if (Zest::Zest::check_id_a(id) == true) {
        return ("</a>");
    }
    Zest::set_id_a(id);
    return ("<a>");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x2190
movq %r15, %rdi
movq %r14, %rsi
callq 0x2676
movl %eax, %r13d
leaq -0x70(%rbp), %rdi
callq 0x20b0
testb %r13b, %r13b
je 0x287e
leaq 0x57fe(%rip), %rsi      # 0x807a
jmp 0x28ac
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2190
addq $0x8, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2af0
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq 0x57d3(%rip), %rsi      # 0x807f
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x2b2c
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28cc
movq %rax, %rbx
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Zest.cpp
// Function: Zest::Zest::a(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Attributes::a)
std::string Zest::Zest::a(std::string id, Attributes::a attributes)
{

    if (Zest::Zest::check_id_a(id) == true) {
        return ("</a>");
    }

    Zest::set_id_a(id);
    return ("<a" + attributes.get_attributes() + ">");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xa8(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x2190
movq %r15, %rdi
movq %r13, %rsi
callq 0x2676
movl %eax, %r13d
leaq -0xa8(%rbp), %rdi
callq 0x20b0
testb %r13b, %r13b
je 0x2946
leaq 0x5742(%rip), %rsi      # 0x807a
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x2b2c
jmp 0x29ba
leaq -0x88(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2190
addq $0x8, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2af0
leaq -0x88(%rbp), %rdi
callq 0x20b0
leaq -0x68(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x492e
leaq 0x56fa(%rip), %rsi      # 0x8083
leaq -0x48(%rbp), %rdi
movq %r15, %rdx
callq 0x2b90
leaq 0x56b7(%rip), %rdx      # 0x8053
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x2b67
leaq -0x48(%rbp), %rdi
callq 0x20b0
leaq -0x68(%rbp), %rdi
callq 0x20b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x29e0
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0x29fc
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
jmp 0x29fc
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/Main.cpp
// Function: set_a_att(Attributes::a*)
int set_a_att(Attributes::a *a_attributes)
{
    a_attributes->id("my_class");
    a_attributes->download("DOWNLOAD");
    a_attributes->href("HREF");
    a_attributes->media("_test_.mp4");

    return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x514d(%rip), %rsi      # 0x80cf
leaq -0x90(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2b2c
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x3d1e
leaq -0x90(%rbp), %rdi
callq 0x20b0
leaq 0x5124(%rip), %rsi      # 0x80d8
leaq -0x70(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2b2c
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x3e02
leaq -0x70(%rbp), %rdi
callq 0x20b0
leaq 0x5104(%rip), %rsi      # 0x80e1
leaq -0x50(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2b2c
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x3eea
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq 0x50e0(%rip), %rsi      # 0x80e6
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x2b2c
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x40ba
leaq -0x30(%rbp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x305f
jmp 0x3066
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x305f
jmp 0x3066
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
jmp 0x305f
jmp 0x3066
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x20b0
jmp 0x3069
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::id(std::string value)
{
    Logs logs;

    this->id_t = value;

    if (Attributes::a::id() == value) {
        logs.done("a attribute id set");

        return (true);
    }
    logs.fail("a attribute id not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x3d93
leaq 0x4404(%rip), %rsi      # 0x8177
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x3db8
leaq 0x43f0(%rip), %rsi      # 0x818a
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x3de1
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x3df1
jmp 0x3dee
jmp 0x3dee
jmp 0x3dee
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::download(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::download(std::string value)
{
    Logs logs;

    this->download_t = value;

    if (Attributes::a::download() == value) {
        logs.done("a attribute download set");

        return (true);
    }
    logs.fail("a attribute download not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x3e7b
leaq 0x4346(%rip), %rsi      # 0x81a1
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x3ea0
leaq 0x4338(%rip), %rsi      # 0x81ba
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x3ec9
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x3ed9
jmp 0x3ed6
jmp 0x3ed6
jmp 0x3ed6
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::href(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::href(std::string value)
{
    Logs logs;

    this->href_t = value;

    if (Attributes::a::href() == value) {
        logs.done("a attribute href set");

        return (true);
    }
    logs.fail("a attribute href not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0x40, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x3f63
leaq 0x4294(%rip), %rsi      # 0x81d7
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x3f88
leaq 0x4282(%rip), %rsi      # 0x81ec
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x3fb1
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x3fc1
jmp 0x3fbe
jmp 0x3fbe
jmp 0x3fbe
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::hreflang(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::hreflang(std::string value)
{
    Logs logs;

    this->hreflang_t = value;

    if (Attributes::a::hreflang() == value) {
        logs.done("a attribute hreflang set");

        return (true);
    }
    logs.fail("a attribute hreflang not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0x60, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x404b
leaq 0x41da(%rip), %rsi      # 0x8205
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x4070
leaq 0x41cc(%rip), %rsi      # 0x821e
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4099
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x40a9
jmp 0x40a6
jmp 0x40a6
jmp 0x40a6
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::media(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::media(std::string value)
{
    Logs logs;

    this->media_t = value;

    if (Attributes::a::media() == value) {
        logs.done("a attribute media set");

        return (true);
    }
    logs.fail("a attribute media not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
subq $-0x80, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x4133
leaq 0x4128(%rip), %rsi      # 0x823b
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x4158
leaq 0x4117(%rip), %rsi      # 0x8251
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4181
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x4191
jmp 0x418e
jmp 0x418e
jmp 0x418e
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::ping(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::ping(std::string value)
{
    Logs logs;

    this->ping_t = value;

    if (Attributes::a::ping() == value) {
        logs.done("a attribute ping set");

        return (true);
    }
    logs.fail("a attribute ping not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0xa0, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x421e
leaq 0x406d(%rip), %rsi      # 0x826b
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x4243
leaq 0x405b(%rip), %rsi      # 0x8280
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x426c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x427c
jmp 0x4279
jmp 0x4279
jmp 0x4279
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::referrerpolicy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::referrerpolicy(std::string value)
{
    Logs logs;

    this->referrerpolicy_t = value;

    if (Attributes::a::referrerpolicy() == value) {
        logs.done("a attribute referrerpolicy set");

        return (true);
    }
    logs.fail("a attribute referrerpolicy not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0xc0, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x430a
leaq 0x3faf(%rip), %rsi      # 0x8299
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x432f
leaq 0x3fa7(%rip), %rsi      # 0x82b8
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4358
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x4368
jmp 0x4365
jmp 0x4365
jmp 0x4365
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::rel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::rel(std::string value)
{
    Logs logs;

    this->rel_t = value;

    if (Attributes::a::rel() == value) {
        logs.done("a attribute rel set");

        return (true);
    }
    logs.fail("a attribute rel not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0xe0, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x43f6
leaq 0x3f05(%rip), %rsi      # 0x82db
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x441b
leaq 0x3ef2(%rip), %rsi      # 0x82ef
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4444
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x4454
jmp 0x4451
jmp 0x4451
jmp 0x4451
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::target(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::target(std::string value)
{
    Logs logs;

    this->target_t = value;

    if (Attributes::a::target() == value) {
        logs.done("a attribute target set");

        return (true);
    }
    logs.fail("a attribute target not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x11(%rbp), %rdi
callq 0x244c
addq $0x100, %r14            # imm = 0x100
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20e0
leaq -0x78(%rbp), %rdi
movq %r14, %rsi
callq 0x2190
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ab9
movl %eax, %ebx
movq %r14, %rdi
callq 0x20b0
testb %bl, %bl
je 0x44e2
leaq 0x3e45(%rip), %rsi      # 0x8307
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x24bc
leaq -0x58(%rbp), %rdi
jmp 0x4507
leaq 0x3e35(%rip), %rsi      # 0x831e
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x2b2c
leaq -0x11(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2508
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x11(%rbp), %rdi
callq 0x2452
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x4530
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20b0
jmp 0x4540
jmp 0x453d
jmp 0x453d
jmp 0x453d
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop