LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2c62
movq %r12, 0x20(%rbx)
movb %bpl, 0x28(%rbx)
leaq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x2e48
leaq 0x1f0(%rip), %rax       # 0x2c60
movq %rax, 0x50(%rbx)
movq $0x0, 0x58(%rbx)
cmpq $0x0, 0x8(%r14)
je 0x2a92
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1660(%rip), %rdi      # 0x40f9
leaq 0x1667(%rip), %rsi      # 0x4107
leaq 0x1724(%rip), %rcx      # 0x41cb
movl $0x1a6, %edx            # imm = 0x1A6
callq 0x2120
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x2ac8
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e6e
movq %rax, %r15
testq %rax, %rax
je 0x2b42
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2240
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ef0
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3a21
movq %rdi, %rbx
movq 0x80(%rdi), %r14
movq %r14, %rdi
callq 0x3de2
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20f0
cmpl $-0x1, %eax
je 0x3a2b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa26(%rip), %rsi       # 0x4461
leaq 0xa27(%rip), %rdx       # 0x4469
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2bca
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 0x32c4(%rip), %rax      # 0x6d48
movq %rax, (%r14)
leaq 0x32ea(%rip), %rax      # 0x6d78
movq %rax, 0x8(%r14)
leaq 0x326f(%rip), %rsi      # 0x6d08
leaq -0xcd4(%rip), %rdx      # 0x2dcc
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
movq %r14, %rdi
callq 0x2160
jmp 0x3ab8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3ace
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33cc(%rip), %al       # 0x71b8
testb %al, %al
je 0x3e23
movq 0x33b9(%rip), %rcx      # 0x71b0
cmpq $-0x1, %rcx
je 0x3e1c
testq %rcx, %rcx
jle 0x3e2a
testq %rbx, %rbx
je 0x3e1e
decq %rbx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x2, %rax
imulq %rax, %rcx
jmp 0x3e1e
xorl %ecx, %ecx
movq %rcx, %rax
popq %rbx
retq
callq 0x233f
jmp 0x3df0
leaq 0x1d3(%rip), %rdi       # 0x4004
leaq 0x2cf(%rip), %rsi       # 0x4107
leaq 0x4dd(%rip), %rcx       # 0x431c
movl $0x5a, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3eb1
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3ed0
movq %rbx, %rdi
callq 0x3f60
cmpq %r14, %rax
jae 0x3e9a
xorl %eax, %eax
jmp 0x3ea9
movq 0x40(%rbx), %r14
movq %rbx, %rdi
callq 0x3fa8
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5bf(%rip), %rdi       # 0x4477
leaq 0x5c3(%rip), %rsi       # 0x4482
leaq 0x5d7(%rip), %rcx       # 0x449d
movl $0xf6, %edx
callq 0x2120
leaq 0x61d(%rip), %rdi       # 0x44f4
leaq 0x5a4(%rip), %rsi       # 0x4482
leaq 0x5b8(%rip), %rcx       # 0x449d
movl $0xf7, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3f22
movq 0x80(%rdi), %rax
cmpq %rsi, %rax
jbe 0x3f41
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 0x54e(%rip), %rdi       # 0x4477
leaq 0x552(%rip), %rsi       # 0x4482
leaq 0x627(%rip), %rcx       # 0x455e
movl $0x108, %edx            # imm = 0x108
callq 0x2120
leaq 0x5ac(%rip), %rdi       # 0x44f4
leaq 0x533(%rip), %rsi       # 0x4482
leaq 0x608(%rip), %rcx       # 0x455e
movl $0x109, %edx            # imm = 0x109
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26e2
movq %r14, %rdi
callq 0x26fe
testb %al, %al
je 0x24bb
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xdb4c(%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 0x26f8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x26f8
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r14
movq 0x10(%rdi), %r13
cmpq %r13, %r14
je 0x2767
movq %rsi, %r15
movq %rdi, %rbx
addq $0x8, %rbx
movq 0x8(%rsi), %r12
cmpq %r12, 0x8(%r14)
jne 0x275e
testq %r12, %r12
je 0x276b
movq (%r15), %rsi
movq (%r14), %rdi
movq %r12, %rdx
callq 0x2150
testl %eax, %eax
je 0x276b
addq $0x20, %r14
cmpq %r13, %r14
jne 0x2741
xorl %eax, %eax
jmp 0x2778
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fb0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x298e
movb $0x0, (%rsi)
movq %rax, (%rbx)
leaq 0x96e6(%rip), %rsi      # 0xc06b
leaq 0x96e6(%rip), %rdx      # 0xc072
jmp 0x29a2
movb $0x1, (%rsi)
movq %rax, (%rbx)
leaq 0x96d8(%rip), %rsi      # 0xc073
leaq 0x96d7(%rip), %rdx      # 0xc079
movq %rbx, %rdi
callq 0x3252
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2718
movl %eax, %r12d
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2a0f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2140
testb %r12b, %r12b
je 0x2a2b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9658(%rip), %rsi      # 0xc07a
leaq 0x9655(%rip), %rdx      # 0xc07e
jmp 0x2a82
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 0x2f12
addq $0x8, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x2eb8
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2a6d
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9604(%rip), %rsi      # 0xc07f
leaq 0x9600(%rip), %rdx      # 0xc082
movq %rbx, %rdi
callq 0x3252
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 0x2aac
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x2abd
movq (%r13), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f12
movq %r15, %rdi
movq %r13, %rsi
callq 0x2718
movl %eax, %r13d
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b2e
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2140
testb %r13b, %r13b
je 0x2b55
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x9539(%rip), %rsi      # 0xc07a
leaq 0x9536(%rip), %rdx      # 0xc07e
movq %rbx, %rdi
callq 0x3252
jmp 0x2c8a
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 0x2f12
addq $0x8, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2eb8
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2b99
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0xb0(%rbp), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x5e4c
leaq 0x94d0(%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 0x2be9
movq %rdx, -0x50(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x40(%rbp)
jmp 0x2bf0
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 0x9441(%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 0x2c39
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x2c3f
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 0x2c6b
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2c8a
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 0x2cbc
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x2cbc
movq %rax, %rbx
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d02
movq -0xa0(%rbp), %rsi
jmp 0x2cfa
movq %rax, %rbx
movq -0x70(%rbp), %rdi
cmpq %r13, %rdi
je 0x2d02
movq -0x60(%rbp), %rsi
jmp 0x2cfa
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x2d02
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8dba(%rip), %rsi      # 0xc0cf
leaq 0x8dbb(%rip), %rdx      # 0xc0d7
leaq -0x98(%rbp), %r14
movq %r14, %rdi
callq 0x3252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b3e
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x3351
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d78(%rip), %rsi      # 0xc0d8
leaq 0x8d79(%rip), %rdx      # 0xc0e0
leaq -0x78(%rbp), %r14
movq %r14, %rdi
callq 0x3252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4c96
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0x3393
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d3f(%rip), %rsi      # 0xc0e1
leaq 0x8d3c(%rip), %rdx      # 0xc0e5
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x3252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4df0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x33d5
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2140
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x8d02(%rip), %rsi      # 0xc0e6
leaq 0x8d05(%rip), %rdx      # 0xc0f0
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x3252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50a4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3417
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 0x344c
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0x344c
movq %rax, %rbx
movq -0x78(%rbp), %rdi
jmp 0x344c
movq %rax, %rbx
movq -0x98(%rbp), %rdi
cmpq %r15, %rdi
je 0x345c
movq (%r15), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4ba5
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x4bad
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4baf
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x4baf
movb $0x1, %bl
cmpq %r15, %r14
je 0x4bc3
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x4bf9
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x75a1(%rip), %rsi      # 0xc177
leaq 0x75ac(%rip), %rdx      # 0xc189
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x4c29
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7582(%rip), %rsi      # 0xc18a
leaq 0x7591(%rip), %rdx      # 0xc1a0
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c39
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x4c84
movq -0x30(%rbp), %rsi
jmp 0x4c71
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4c84
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4c84
jmp 0x4c81
jmp 0x4c81
jmp 0x4c81
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4cff
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x4d07
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4d09
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x4d09
movb $0x1, %bl
cmpq %r15, %r14
je 0x4d1d
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x4d53
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7471(%rip), %rsi      # 0xc1a1
leaq 0x7482(%rip), %rdx      # 0xc1b9
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x4d83
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7458(%rip), %rsi      # 0xc1ba
leaq 0x746d(%rip), %rdx      # 0xc1d6
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4d93
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x4dde
movq -0x30(%rbp), %rsi
jmp 0x4dcb
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4dde
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4dde
jmp 0x4ddb
jmp 0x4ddb
jmp 0x4ddb
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4e59
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x4e61
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4e63
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x4e63
movb $0x1, %bl
cmpq %r15, %r14
je 0x4e77
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x4ead
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x734d(%rip), %rsi      # 0xc1d7
leaq 0x735a(%rip), %rdx      # 0xc1eb
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x4edd
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7330(%rip), %rsi      # 0xc1ec
leaq 0x7341(%rip), %rdx      # 0xc204
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x4eed
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x4f38
movq -0x30(%rbp), %rsi
jmp 0x4f25
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4f38
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x4f38
jmp 0x4f35
jmp 0x4f35
jmp 0x4f35
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x4fb3
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x4fbb
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x4fbd
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x4fbd
movb $0x1, %bl
cmpq %r15, %r14
je 0x4fd1
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x5007
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7221(%rip), %rsi      # 0xc205
leaq 0x7232(%rip), %rdx      # 0xc21d
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x5037
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x7208(%rip), %rsi      # 0xc21e
leaq 0x721d(%rip), %rdx      # 0xc23a
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5047
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x5092
movq -0x30(%rbp), %rsi
jmp 0x507f
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x5092
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x5092
jmp 0x508f
jmp 0x508f
jmp 0x508f
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5116
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x511e
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5120
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x5120
movb $0x1, %bl
cmpq %r15, %r14
je 0x5134
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x516a
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x70f4(%rip), %rsi      # 0xc23b
leaq 0x7102(%rip), %rdx      # 0xc250
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x519a
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x70d8(%rip), %rsi      # 0xc251
leaq 0x70ea(%rip), %rdx      # 0xc26a
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x51aa
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x51f5
movq -0x30(%rbp), %rsi
jmp 0x51e2
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x51f5
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x51f5
jmp 0x51f2
jmp 0x51f2
jmp 0x51f2
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5278
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x5280
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5282
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x5282
movb $0x1, %bl
cmpq %r15, %r14
je 0x5296
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x52cc
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6fc2(%rip), %rsi      # 0xc26b
leaq 0x6fcf(%rip), %rdx      # 0xc27f
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x52fc
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6fa5(%rip), %rsi      # 0xc280
leaq 0x6fb6(%rip), %rdx      # 0xc298
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x530c
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x5357
movq -0x30(%rbp), %rsi
jmp 0x5344
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x5357
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x5357
jmp 0x5354
jmp 0x5354
jmp 0x5354
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x53da
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x53e2
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x53e4
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x53e4
movb $0x1, %bl
cmpq %r15, %r14
je 0x53f8
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x542e
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6e8e(%rip), %rsi      # 0xc299
leaq 0x6ea5(%rip), %rdx      # 0xc2b7
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x545e
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6e7b(%rip), %rsi      # 0xc2b8
leaq 0x6e96(%rip), %rdx      # 0xc2da
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x546e
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x54b9
movq -0x30(%rbp), %rsi
jmp 0x54a6
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x54b9
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x54b9
jmp 0x54b6
jmp 0x54b6
jmp 0x54b6
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x553c
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x5544
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x5546
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x5546
movb $0x1, %bl
cmpq %r15, %r14
je 0x555a
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x5590
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6d6e(%rip), %rsi      # 0xc2db
leaq 0x6d7a(%rip), %rdx      # 0xc2ee
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x55c0
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6d50(%rip), %rsi      # 0xc2ef
leaq 0x6d60(%rip), %rdx      # 0xc306
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x55d0
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x561b
movq -0x30(%rbp), %rsi
jmp 0x5608
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x561b
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x561b
jmp 0x5618
jmp 0x5618
jmp 0x5618
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x569e
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x56a6
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x56a8
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x56a8
movb $0x1, %bl
cmpq %r15, %r14
je 0x56bc
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x56f2
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6c38(%rip), %rsi      # 0xc307
leaq 0x6c47(%rip), %rdx      # 0xc31d
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x5722
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6c1d(%rip), %rsi      # 0xc31e
leaq 0x6c30(%rip), %rdx      # 0xc338
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5732
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x577d
movq -0x30(%rbp), %rsi
jmp 0x576a
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x577d
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x577d
jmp 0x577a
jmp 0x577a
jmp 0x577a
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5800
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x5808
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x580a
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x580a
movb $0x1, %bl
cmpq %r15, %r14
je 0x581e
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x5854
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6b08(%rip), %rsi      # 0xc339
leaq 0x6b15(%rip), %rdx      # 0xc34d
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x5884
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x6aeb(%rip), %rsi      # 0xc34e
leaq 0x6afc(%rip), %rdx      # 0xc366
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x5894
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x58df
movq -0x30(%rbp), %rsi
jmp 0x58cc
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x58df
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x58df
jmp 0x58dc
jmp 0x58dc
jmp 0x58dc
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7bdb
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x7be3
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7be5
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x7be5
movb $0x1, %bl
cmpq %r15, %r14
je 0x7bf9
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x7c2f
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x47c4(%rip), %rsi      # 0xc3d0
leaq 0x47d1(%rip), %rdx      # 0xc3e4
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x7c5f
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x47a7(%rip), %rsi      # 0xc3e5
leaq 0x47b8(%rip), %rdx      # 0xc3fd
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7c6f
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x7cba
movq -0x30(%rbp), %rsi
jmp 0x7ca7
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x7cba
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x7cba
jmp 0x7cb7
jmp 0x7cb7
jmp 0x7cb7
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7d35
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x7d3d
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7d3f
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x7d3f
movb $0x1, %bl
cmpq %r15, %r14
je 0x7d53
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x7d89
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4698(%rip), %rsi      # 0xc3fe
leaq 0x46a6(%rip), %rdx      # 0xc413
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x7db9
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x467c(%rip), %rsi      # 0xc414
leaq 0x468e(%rip), %rdx      # 0xc42d
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7dc9
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x7e14
movq -0x30(%rbp), %rsi
jmp 0x7e01
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x7e14
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x7e14
jmp 0x7e11
jmp 0x7e11
jmp 0x7e11
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::src(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::src(std::string value)
{
    Logs logs;

    this->src_t = value;

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

        return (true);
    }
    logs.fail("img attribute src 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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7e8f
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x7e97
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7e99
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x7e99
movb $0x1, %bl
cmpq %r15, %r14
je 0x7ead
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x7ee3
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x456e(%rip), %rsi      # 0xc42e
leaq 0x457c(%rip), %rdx      # 0xc443
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x7f13
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4552(%rip), %rsi      # 0xc444
leaq 0x4564(%rip), %rdx      # 0xc45d
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x7f23
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x7f6e
movq -0x30(%rbp), %rsi
jmp 0x7f5b
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x7f6e
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x7f6e
jmp 0x7f6b
jmp 0x7f6b
jmp 0x7f6b
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Neotoxic-off[P]Zest/src/tag/img.cpp
// Function: Attributes::img::crossorigin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Attributes::img::crossorigin(std::string value)
{
    Logs logs;

    this->crossorigin_t = value;

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

        return (true);
    }
    logs.fail("img attribute crossorigin 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 0x244c
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 0x2f12
movq -0x78(%rbp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7fe9
movq -0x80(%rbp), %r14
testq %rdx, %rdx
je 0x7ff1
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
sete %bl
jmp 0x7ff3
movq -0x80(%rbp), %r14
xorl %ebx, %ebx
jmp 0x7ff3
movb $0x1, %bl
cmpq %r15, %r14
je 0x8007
movq -0x70(%rbp), %rsi
incq %rsi
movq %r14, %rdi
callq 0x2140
testb %bl, %bl
je 0x803d
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4444(%rip), %rsi      # 0xc45e
leaq 0x445a(%rip), %rdx      # 0xc47b
leaq -0x60(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x24e2
movq -0x60(%rbp), %rdi
jmp 0x806d
leaq -0x30(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x4430(%rip), %rsi      # 0xc47c
leaq 0x444a(%rip), %rdx      # 0xc49d
leaq -0x40(%rbp), %rdi
callq 0x3252
leaq -0x19(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x254e
movq -0x40(%rbp), %rdi
cmpq %r14, %rdi
je 0x807d
movq (%r14), %rsi
incq %rsi
callq 0x2140
leaq -0x19(%rbp), %rdi
callq 0x2452
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 0x80c8
movq -0x30(%rbp), %rsi
jmp 0x80b5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x80c8
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x2140
jmp 0x80c8
jmp 0x80c5
jmp 0x80c5
jmp 0x80c5
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2452
movq %rbx, %rdi
callq 0x21e0
nop