LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rdi
leaq 0x178c(%rip), %rsi      # 0x40d4
callq 0x2090
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
movq 0x466c(%rip), %rdx      # 0x6fc8
movq %rax, %rsi
callq 0x391e
cmpq $0x0, -0x30(%rbp)
je 0x29ce
movq -0x30(%rbp), %rdi
callq 0x2220
testl %eax, %eax
jne 0x29ad
leaq -0xb0(%rbp), %r14
movq -0x30(%rbp), %rdx
movq %r14, %rdi
movl $0x80, %esi
callq 0x2240
testq %rax, %rax
je 0x29a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22c0
movq -0x30(%rbp), %rdi
callq 0x2220
testl %eax, %eax
je 0x297f
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x29bb
callq 0x34b0
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20f0
movq %rax, %r15
leaq 0x16f4(%rip), %rsi      # 0x40d6
movq %rax, %rdi
callq 0x20c0
movq 0x45ff(%rip), %rsi      # 0x6ff0
movq 0x45b8(%rip), %rdx      # 0x6fb0
movq %r15, %rdi
callq 0x2260
jmp 0x2a14
movq %rax, %r14
movq %r15, %rdi
callq 0x2130
jmp 0x2a17
movq %rax, %r14
jmp 0x2a25
movq %rax, %r14
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x2a25
callq 0x34b0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2a39
movq (%r12), %rsi
incq %rsi
callq 0x2180
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24bc
xorl %eax, %eax
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x299e
movq %rbx, %rdi
callq 0x20b0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x466c(%rip), %rdi      # 0x6fe8
movq %rax, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x21e0
movq %rax, %rbx
callq 0x2250
movq %rbx, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x2bbd
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x2c5a
movq %r12, 0x20(%rbx)
movb %bpl, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x2e3a
leaq 0x1ec(%rip), %rax       # 0x2c58
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
cmpq $0x0, 0x8(%r14)
je 0x2a8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1664(%rip), %rdi      # 0x40f9
leaq 0x166b(%rip), %rsi      # 0x4107
leaq 0x1728(%rip), %rcx      # 0x41cb
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x2120
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x2ac4
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e68
movq %rax, %r15
testq %rax, %rax
je 0x2b40
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3eea
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x3a1b
movq %rdi, %rbx
movq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x3ddc
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
cmpl $-0x1, %eax
je 0x3a25
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa2c(%rip), %rsi       # 0x4461
leaq 0xa2d(%rip), %rdx       # 0x4469
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2bc8
callq 0x2040
movl (%rax), %edi
callq 0x2080
movq %rbx, %rdi
movq %rax, %rsi
callq 0x22e0
movl $0x18, %edi
callq 0x20e0
movq %rax, %r14
leaq 0x8(%rax), %rdi
movq %rsp, %rsi
callq 0x21f0
leaq 0x32ca(%rip), %rax      # 0x6d48
movq %rax, (%r14)
leaq 0x32f0(%rip), %rax      # 0x6d78
movq %rax, 0x8(%r14)
leaq 0x3275(%rip), %rsi      # 0x6d08
leaq -0xcdc(%rip), %rdx      # 0x2dbe
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
jmp 0x3ab2
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3ac8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33d2(%rip), %al       # 0x71b8
testb %al, %al
je 0x3e1d
movq 0x33bf(%rip), %rcx      # 0x71b0
cmpq $-0x1, %rcx
je 0x3e16
testq %rcx, %rcx
jle 0x3e24
testq %rbx, %rbx
je 0x3e18
decq %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x2, %rax
imulq %rax, %rcx
jmp 0x3e18
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
callq 0x233f
jmp 0x3dea
leaq 0x1d9(%rip), %rdi       # 0x4004
leaq 0x2d5(%rip), %rsi       # 0x4107
leaq 0x4e3(%rip), %rcx       # 0x431c
movl $0x5a, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3eab
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3eca
movq %rbx, %rdi
callq 0x3f5a
cmpq %r14, %rax
jae 0x3e94
xorl %eax, %eax
jmp 0x3ea3
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x3fa2
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5c5(%rip), %rdi       # 0x4477
leaq 0x5c9(%rip), %rsi       # 0x4482
leaq 0x5dd(%rip), %rcx       # 0x449d
movl $0xf6, %edx
callq 0x2120
leaq 0x623(%rip), %rdi       # 0x44f4
leaq 0x5aa(%rip), %rsi       # 0x4482
leaq 0x5be(%rip), %rcx       # 0x449d
movl $0xf7, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f1c
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3f3b
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 0x554(%rip), %rdi       # 0x4477
leaq 0x558(%rip), %rsi       # 0x4482
leaq 0x62d(%rip), %rcx       # 0x455e
movl $0x108, %edx            # imm = 0x108
callq 0x2120
leaq 0x5b2(%rip), %rdi       # 0x44f4
leaq 0x539(%rip), %rsi       # 0x4482
leaq 0x60e(%rip), %rcx       # 0x455e
movl $0x109, %edx            # imm = 0x109
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xdc2(%rip), %rsi       # 0x2004
leaq 0xdc2(%rip), %rdx       # 0x200b
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1318
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x2d75(%rip), %rdi      # 0x3fd8
callq 0x10a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq -0x30(%rbp), %rax
movb $0x41, (%rax)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x2d30(%rip), %rdi      # 0x3fd8
callq 0x10a0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x12ec
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1090
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x130f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26f2
movq %r14, %rdi
callq 0x270e
testb %al, %al
je 0x24cb
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xdb3c(%rip), %rdi      # 0xffd8
callq 0x2170
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq -0x11(%rbp), %rdi
callq 0x2708
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2708
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdi), %r15
movq 0x10(%rdi), %r13
cmpq %r13, %r15
setne %bl
je 0x278d
movq %rsi, %r12
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
movq 0x8(%rsi), %r14
movq 0x8(%r15), %rdx
cmpq %r14, %rdx
jne 0x2773
testq %rdx, %rdx
je 0x2781
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x2150
testl %eax, %eax
je 0x2781
addq $0x20, %r15
cmpq %r13, %r15
setne %bl
jne 0x2755
jmp 0x278d
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x2fc2
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %rax
cmpb $0x1, (%rsi)
jne 0x29a8
movb $0x0, (%rsi)
movq %rax, (%rbx)
leaq 0x96cc(%rip), %rsi      # 0xc06b
leaq 0x96cc(%rip), %rdx      # 0xc072
jmp 0x29bc
movb $0x1, (%rsi)
movq %rax, (%rbx)
leaq 0x96be(%rip), %rsi      # 0xc073
leaq 0x96bd(%rip), %rdx      # 0xc079
movq %rbx, %rdi
callq 0x3288
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x2f28
movq %r14, %rdi
movq %r12, %rsi
callq 0x2728
movl %eax, %r12d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2a29
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2140
testb %r12b, %r12b
je 0x2a45
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x963e(%rip), %rsi      # 0xc07a
leaq 0x963b(%rip), %rdx      # 0xc07e
jmp 0x2a9c
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x2f28
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ece
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2a87
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x95ea(%rip), %rsi      # 0xc07f
leaq 0x95e6(%rip), %rdx      # 0xc082
movq %rbx, %rdi
callq 0x3288
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x2ac6
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2ad7
movq (%r13), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x80(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x2f28
movq %r15, %rdi
movq %r13, %rsi
callq 0x2728
movl %eax, %r13d
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b48
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2140
testb %r13b, %r13b
je 0x2b6f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x951f(%rip), %rsi      # 0xc07a
leaq 0x951c(%rip), %rdx      # 0xc07e
movq %rbx, %rdi
callq 0x3288
jmp 0x2ca4
leaq -0x60(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x2f28
addq $0x8, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ece
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2bb3
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x5e44
leaq 0x94b6(%rip), %rcx      # 0xc083
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2160
leaq -0x40(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2c03
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x2c0a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq -0x50(%rbp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x9427(%rip), %rsi      # 0xc053
callq 0x2200
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x2c53
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2c59
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2c85
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ca4
movq -0xa0(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r14, %rdi
je 0x2cd6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x2cd6
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d1c
movq -0xa0(%rbp), %rsi
jmp 0x2d14
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2d1c
movq -0x60(%rbp), %rsi
jmp 0x2d14
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d1c
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x88(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d86(%rip), %rsi      # 0xc0cf
leaq 0x8d87(%rip), %rdx      # 0xc0d7
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x3288
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b72
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x3385
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d44(%rip), %rsi      # 0xc0d8
leaq 0x8d45(%rip), %rdx      # 0xc0e0
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x3288
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4cc4
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x33c7
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d0b(%rip), %rsi      # 0xc0e1
leaq 0x8d08(%rip), %rdx      # 0xc0e5
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x3288
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4e18
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x3409
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8cce(%rip), %rsi      # 0xc0e6
leaq 0x8cd1(%rip), %rdx      # 0xc0f0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x3288
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50c0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x344b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2140
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
jmp 0x3480
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x3480
movq %rax, %rbx
movq -0x78(%rbp), %rdi
jmp 0x3480
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x3490
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4bd6
testq %rdx, %rdx
je 0x4bda
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4bdc
xorl %ebx, %ebx
jmp 0x4bdc
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x4bf1
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x4c27
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7573(%rip), %rsi      # 0xc177
leaq 0x757e(%rip), %rdx      # 0xc189
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x4c57
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7554(%rip), %rsi      # 0xc18a
leaq 0x7563(%rip), %rdx      # 0xc1a0
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c67
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4cb2
movq -0x30(%rbp), %rsi
jmp 0x4c9f
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4cb2
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4cb2
jmp 0x4caf
jmp 0x4caf
jmp 0x4caf
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4d2a
testq %rdx, %rdx
je 0x4d2e
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4d30
xorl %ebx, %ebx
jmp 0x4d30
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x4d45
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x4d7b
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7449(%rip), %rsi      # 0xc1a1
leaq 0x745a(%rip), %rdx      # 0xc1b9
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x4dab
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7430(%rip), %rsi      # 0xc1ba
leaq 0x7445(%rip), %rdx      # 0xc1d6
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4dbb
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4e06
movq -0x30(%rbp), %rsi
jmp 0x4df3
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4e06
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4e06
jmp 0x4e03
jmp 0x4e03
jmp 0x4e03
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x40(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4e7e
testq %rdx, %rdx
je 0x4e82
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4e84
xorl %ebx, %ebx
jmp 0x4e84
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x4e99
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x4ecf
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x732b(%rip), %rsi      # 0xc1d7
leaq 0x7338(%rip), %rdx      # 0xc1eb
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x4eff
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x730e(%rip), %rsi      # 0xc1ec
leaq 0x731f(%rip), %rdx      # 0xc204
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4f0f
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4f5a
movq -0x30(%rbp), %rsi
jmp 0x4f47
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4f5a
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4f5a
jmp 0x4f57
jmp 0x4f57
jmp 0x4f57
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x60(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4fd2
testq %rdx, %rdx
je 0x4fd6
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4fd8
xorl %ebx, %ebx
jmp 0x4fd8
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x4fed
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x5023
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7205(%rip), %rsi      # 0xc205
leaq 0x7216(%rip), %rdx      # 0xc21d
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x5053
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x71ec(%rip), %rsi      # 0xc21e
leaq 0x7201(%rip), %rdx      # 0xc23a
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5063
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x50ae
movq -0x30(%rbp), %rsi
jmp 0x509b
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x50ae
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x50ae
jmp 0x50ab
jmp 0x50ab
jmp 0x50ab
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x80(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x512f
testq %rdx, %rdx
je 0x5133
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5135
xorl %ebx, %ebx
jmp 0x5135
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x514a
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x5180
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x70de(%rip), %rsi      # 0xc23b
leaq 0x70ec(%rip), %rdx      # 0xc250
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x51b0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x70c2(%rip), %rsi      # 0xc251
leaq 0x70d4(%rip), %rdx      # 0xc26a
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x51c0
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x520b
movq -0x30(%rbp), %rsi
jmp 0x51f8
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x520b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x520b
jmp 0x5208
jmp 0x5208
jmp 0x5208
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0xa0(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x528b
testq %rdx, %rdx
je 0x528f
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5291
xorl %ebx, %ebx
jmp 0x5291
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x52a6
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x52dc
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6fb2(%rip), %rsi      # 0xc26b
leaq 0x6fbf(%rip), %rdx      # 0xc27f
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x530c
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6f95(%rip), %rsi      # 0xc280
leaq 0x6fa6(%rip), %rdx      # 0xc298
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x531c
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5367
movq -0x30(%rbp), %rsi
jmp 0x5354
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x5367
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x5367
jmp 0x5364
jmp 0x5364
jmp 0x5364
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0xc0(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xc0(%r14), %rsi
movq 0xc8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x53e7
testq %rdx, %rdx
je 0x53eb
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x53ed
xorl %ebx, %ebx
jmp 0x53ed
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x5402
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x5438
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6e84(%rip), %rsi      # 0xc299
leaq 0x6e9b(%rip), %rdx      # 0xc2b7
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x5468
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6e71(%rip), %rsi      # 0xc2b8
leaq 0x6e8c(%rip), %rdx      # 0xc2da
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5478
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x54c3
movq -0x30(%rbp), %rsi
jmp 0x54b0
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x54c3
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x54c3
jmp 0x54c0
jmp 0x54c0
jmp 0x54c0
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0xe0(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0xe0(%r14), %rsi
movq 0xe8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5543
testq %rdx, %rdx
je 0x5547
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5549
xorl %ebx, %ebx
jmp 0x5549
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x555e
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x5594
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6d6a(%rip), %rsi      # 0xc2db
leaq 0x6d76(%rip), %rdx      # 0xc2ee
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x55c4
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6d4c(%rip), %rsi      # 0xc2ef
leaq 0x6d5c(%rip), %rdx      # 0xc306
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x55d4
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x561f
movq -0x30(%rbp), %rsi
jmp 0x560c
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x561f
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x561f
jmp 0x561c
jmp 0x561c
jmp 0x561c
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x100(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x100(%r14), %rsi
movq 0x108(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x569f
testq %rdx, %rdx
je 0x56a3
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x56a5
xorl %ebx, %ebx
jmp 0x56a5
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x56ba
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x56f0
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6c3a(%rip), %rsi      # 0xc307
leaq 0x6c49(%rip), %rdx      # 0xc31d
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x5720
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6c1f(%rip), %rsi      # 0xc31e
leaq 0x6c32(%rip), %rdx      # 0xc338
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5730
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x577b
movq -0x30(%rbp), %rsi
jmp 0x5768
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x577b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x577b
jmp 0x5778
jmp 0x5778
jmp 0x5778
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/Neotoxic-off[P]Zest/src/tag/a.cpp
// Function: Attributes::a::type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::a::type(std::string value)
{
    Logs logs;

    this->type_t = value;

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

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

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x120(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x120(%r14), %rsi
movq 0x128(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x57fb
testq %rdx, %rdx
je 0x57ff
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5801
xorl %ebx, %ebx
jmp 0x5801
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x5816
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x584c
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6b10(%rip), %rsi      # 0xc339
leaq 0x6b1d(%rip), %rdx      # 0xc34d
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x587c
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6af3(%rip), %rsi      # 0xc34e
leaq 0x6b04(%rip), %rdx      # 0xc366
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x588c
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x58d7
movq -0x30(%rbp), %rsi
jmp 0x58c4
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x58d7
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x58d7
jmp 0x58d4
jmp 0x58d4
jmp 0x58d4
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::id(std::string value)
{
    Logs logs;

    this->id_t = value;

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

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

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7bd0
testq %rdx, %rdx
je 0x7bd4
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7bd6
xorl %ebx, %ebx
jmp 0x7bd6
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x7beb
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x7c21
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x47d2(%rip), %rsi      # 0xc3d0
leaq 0x47df(%rip), %rdx      # 0xc3e4
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x7c51
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x47b5(%rip), %rsi      # 0xc3e5
leaq 0x47c6(%rip), %rdx      # 0xc3fd
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7c61
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7cac
movq -0x30(%rbp), %rsi
jmp 0x7c99
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x7cac
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x7cac
jmp 0x7ca9
jmp 0x7ca9
jmp 0x7ca9
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::alt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::alt(std::string value)
{
    Logs logs;

    this->alt_t = value;

    if (Attributes::img::alt() == value) {
        logs.done("img attribute alt set");

        return (true);
    }
    logs.fail("img attribute alt not set");

    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x19(%rbp), %rdi
callq 0x245c
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x20c0
leaq -0x70(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x2f28
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7d24
testq %rdx, %rdx
je 0x7d28
movq (%rbx), %rsi
movq -0x80(%rbp), %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7d2a
xorl %ebx, %ebx
jmp 0x7d2a
movb $0x1, %bl
movq -0x80(%rbp), %rdi
cmpq %r15, %rdi
je 0x7d3f
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x2140
testb %bl, %bl
je 0x7d75
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x46ac(%rip), %rsi      # 0xc3fe
leaq 0x46ba(%rip), %rdx      # 0xc413
leaq -0x60(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24f2
movq -0x60(%rbp), %rdi
jmp 0x7da5
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4690(%rip), %rsi      # 0xc414
leaq 0x46a2(%rip), %rdx      # 0xc42d
leaq -0x40(%rbp), %rdi
callq 0x3288
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x255e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7db5
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2462
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e00
movq -0x30(%rbp), %rsi
jmp 0x7ded
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e00
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x7e00
jmp 0x7dfd
jmp 0x7dfd
jmp 0x7dfd
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2462
movq %rbx, %rdi
callq 0x21e0
nop