LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Davidc2525[P]Leaf/compiler/helper/graphs/graph.cpp
// Function: LEAF::HELPER::GRAPH::Graph::path_from(LEAF::HELPER::GRAPH::Node*, std::vector<LEAF::HELPER::GRAPH::Edge*, std::allocator<LEAF::HELPER::GRAPH::Edge*>>*)
void Graph::path_from(Node *a, vector<Edge *> *r)
{

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq (%rax), %rdi
callq 0x32bc0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x32c30
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32bf0
testb $0x1, %al
jne 0x32f7e
jmp 0x33009
leaq -0x20(%rbp), %rdi
callq 0x32c60
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x6120
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6120
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x6440
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x32ff3
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x32c60
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x33070
leaq -0x20(%rbp), %rdi
callq 0x32c60
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x32f30
jmp 0x32ff5
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x32c80
movq %rax, -0x30(%rbp)
jmp 0x32f58
addq $0x50, %rsp
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/make_shared.cc
// Function: main
int main(int argc, char const *argv[])
{
	auto num = cplusplus_primer::make_shared<int>(42);
	std::cout << *num << std::endl;

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2a, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x24(%rbp), %rsi
callq 0x2400
movq -0x78(%rbp), %rdi
callq 0x2470
movl (%rax), %esi
movq 0x6d15(%rip), %rdi      # 0x8fd8
callq 0x2110
movq %rax, -0x70(%rbp)
jmp 0x22ce
movq -0x70(%rbp), %rdi
movq 0x6ce7(%rip), %rsi      # 0x8fc0
callq 0x20d0
jmp 0x22e0
movl $0xa, -0x4c(%rbp)
movb $0x63, -0x4d(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x4d(%rbp), %rdx
callq 0x24a0
jmp 0x22fe
leaq -0x48(%rbp), %rdi
callq 0x2520
movq %rax, %rsi
movq 0x6cc7(%rip), %rdi      # 0x8fd8
callq 0x20a0
movq %rax, -0x80(%rbp)
jmp 0x231c
movq -0x80(%rbp), %rdi
movq 0x6c99(%rip), %rsi      # 0x8fc0
callq 0x20d0
jmp 0x232e
movl $0x63, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x2550
jmp 0x2344
leaq -0x60(%rbp), %rdi
callq 0x25c0
movl (%rax), %esi
movq 0x6c82(%rip), %rdi      # 0x8fd8
callq 0x2110
movq %rax, -0x88(%rbp)
jmp 0x2364
movq -0x88(%rbp), %rdi
movq 0x6c4e(%rip), %rsi      # 0x8fc0
callq 0x20d0
jmp 0x2379
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x25e0
leaq -0x48(%rbp), %rdi
callq 0x2600
leaq -0x20(%rbp), %rdi
callq 0x2620
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x23e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x23d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x25e0
leaq -0x48(%rbp), %rdi
callq 0x2600
leaq -0x20(%rbp), %rdi
callq 0x2620
movq -0x30(%rbp), %rdi
callq 0x2120
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/src/threads/benchmark/bench.cpp
// Function: main
int main(){
    bench(bench_lock);
    bench(bench_lock_guard);
    bench(bench_atomic);

    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
callq 0x23f0
callq 0x2680
callq 0x28f0
callq 0x2b60
callq 0x2dd0
callq 0x3040
callq 0x32b0
callq 0x3520
callq 0x3790
callq 0x3a00
callq 0x3c70
callq 0x3ee0
callq 0x4150
callq 0x43c0
callq 0x4630
callq 0x48a0
callq 0x4b20
callq 0x4e40
callq 0x5160
callq 0x5480
callq 0x57a0
callq 0x5ac0
callq 0x5de0
callq 0x6100
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_help(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int tss_help(std::string name)
{
    std::cout << "Tom's simple shell\n"
              << "These shell commands are defined internally. Type 'help' to see this list.\n"
              << "Type 'help name' to find out more about the function 'name'.\n"
              << "The following are built in: "
              << tss_get()
              << std::endl;
    /// \todo Help for individual commands
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x863d(%rip), %rdi      # 0xbfc0
leaq 0x468f(%rip), %rsi      # 0x8019
callq 0x3240
movq %rax, %rdi
leaq 0x4694(%rip), %rsi      # 0x802d
callq 0x3240
movq %rax, %rdi
leaq 0x46d1(%rip), %rsi      # 0x8079
callq 0x3240
movq %rax, %rdi
leaq 0x4700(%rip), %rsi      # 0x80b7
callq 0x3240
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3a30
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3220
movq %rax, -0x40(%rbp)
jmp 0x39e0
movq -0x40(%rbp), %rdi
movq 0x85ad(%rip), %rsi      # 0xbf98
callq 0x3290
jmp 0x39f2
leaq -0x28(%rbp), %rdi
callq 0x3468
movl $0x1, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3468
movq -0x30(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: frainfreeze[P]tss/./builtins.h
// Function: builtins::tss_get[abi:cxx11]()
std::string tss_get()
{
    std::string str;
    for(auto elem : funcMap)
        str.append("\n " + elem.first);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x3310
leaq 0x87f8(%rip), %rax      # 0xc258
movq %rax, -0x18(%rbp)
leaq 0x87ed(%rip), %rdi      # 0xc258
callq 0x47f0
movq %rax, -0x20(%rbp)
leaq 0x87dd(%rip), %rdi      # 0xc258
callq 0x4820
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4850
testb $0x1, %al
jne 0x3a9a
jmp 0x3b3e
leaq -0x20(%rbp), %rdi
callq 0x4880
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x48a0
jmp 0x3ab1
leaq 0x4624(%rip), %rsi      # 0x80dc
leaq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x4900
jmp 0x3aca
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3420
jmp 0x3adf
leaq -0x98(%rbp), %rdi
callq 0x3468
leaq -0x68(%rbp), %rdi
callq 0x4690
leaq -0x20(%rbp), %rdi
callq 0x4a10
jmp 0x3a84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x3b64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x3b33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x3468
leaq -0x68(%rbp), %rdi
callq 0x4690
jmp 0x3b64
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x3b54
movq -0xa8(%rbp), %rdi
callq 0x3468
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3468
movq -0x70(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: 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
subq $0xf0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x91(%rbp)
callq 0x3310
movq -0xc8(%rbp), %rdi
callq 0x3110
movq %rax, %rdi
leaq 0x4497(%rip), %rsi      # 0x80e4
callq 0x30b0
movq %rax, -0xc0(%rbp)
jmp 0x3c5b
movq -0xc0(%rbp), %rsi
movq 0x835f(%rip), %rdx      # 0xbfc8
leaq -0xa8(%rbp), %rdi
callq 0x4af0
jmp 0x3c77
leaq -0xa8(%rbp), %rdi
callq 0x4b20
testb $0x1, %al
jne 0x3d20
movl $0x10, %edi
callq 0x3140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
leaq 0x443d(%rip), %rsi      # 0x80e6
callq 0x30f0
jmp 0x3cb0
movq -0xe0(%rbp), %rdi
movq 0x8332(%rip), %rsi      # 0xbff0
movq 0x82eb(%rip), %rdx      # 0xbfb0
callq 0x33c0
jmp 0x3e11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x3df9
movq -0xe0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
callq 0x31d0
jmp 0x3dcf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x3dcf
jmp 0x3d22
leaq -0xa8(%rbp), %rdi
callq 0x4b40
movq %rax, %rdi
callq 0x3370
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3d44
jmp 0x3db1
leaq -0x90(%rbp), %rdi
callq 0x4b60
movq %rax, -0xf0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4b40
movq -0xf0(%rbp), %rdi
movq %rax, %rdx
movl $0x80, %esi
callq 0x3390
movq %rax, -0xe8(%rbp)
jmp 0x3d80
movq -0xe8(%rbp), %rax
cmpq $0x0, %rax
je 0x3dac
leaq -0x90(%rbp), %rdi
callq 0x4b60
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x3230
jmp 0x3daa
jmp 0x3dac
jmp 0x3d22
movb $0x1, -0x91(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x4b80
testb $0x1, -0x91(%rbp)
jne 0x3de9
jmp 0x3ddd
leaq -0xa8(%rbp), %rdi
callq 0x4b80
jmp 0x3df9
movq -0xd8(%rbp), %rdi
callq 0x3468
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x3468
movq -0xb0(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x24f0
jmp 0x2a5f
jmp 0x2ad9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2ae1
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x854b(%rip), %rdi      # 0xafe8
callq 0x21d0
movq %rax, -0x20(%rbp)
jmp 0x2aa8
movq -0x20(%rbp), %rdi
movq 0x84fd(%rip), %rsi      # 0xafb0
callq 0x21f0
jmp 0x2aba
movl $0x1, %edi
callq 0x2250
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
callq 0x22d0
jmp 0x2ad7
jmp 0x2ae1
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x2310
movq %rax, %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %r8, -0x48(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x20e0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, 0x20(%rdi)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, 0x28(%rdi)
addq $0x30, %rdi
callq 0x4060
jmp 0x2d3e
movq -0x58(%rbp), %rdi
addq $0x50, %rdi
leaq 0xa13(%rip), %rax       # 0x3760
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdx
callq 0x3770
movq -0x10(%rbp), %rdi
callq 0x22e0
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d6f
jmp 0x2d71
jmp 0x2da7
leaq 0x43b9(%rip), %rdi      # 0x7131
leaq 0x43c0(%rip), %rsi      # 0x713f
movl $0x1a6, %edx            # imm = 0x1A6
leaq 0x4478(%rip), %rcx      # 0x7203
callq 0x2160
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2130
jmp 0x2dd5
cmpq $0x0, -0x18(%rbp)
jb 0x2db0
jmp 0x2dcf
leaq 0x44fe(%rip), %rdi      # 0x72b5
leaq 0x4381(%rip), %rsi      # 0x713f
movl $0x1a7, %edx            # imm = 0x1A7
leaq 0x4439(%rip), %rcx      # 0x7203
callq 0x2160
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2310
nop
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::can_get() const
bool can_get() const
		{
			if (_q || _name.empty())
			{
				return true;
			}

			int fd = ::shm_open(_name.c_str(), O_RDWR, S_IRWXU);
			if (fd == -1)
			{
				return false;
			}

			::close(fd);
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x50, %rdi
callq 0x43c0
testb $0x1, %al
jne 0x2e60
movq -0x20(%rbp), %rdi
callq 0x22e0
testb $0x1, %al
jne 0x2e60
jmp 0x2e66
movb $0x1, -0x1(%rbp)
jmp 0x2e9c
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, %rdi
movl $0x2, %esi
movl $0x1c0, %edx            # imm = 0x1C0
callq 0x22f0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2e90
movb $0x0, -0x1(%rbp)
jmp 0x2e9c
movl -0x14(%rbp), %edi
callq 0x2390
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x20(%rbp), %rsi
callq 0x6200
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x2fb6
movb $0x0, -0x1(%rbp)
jmp 0x2fd8
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x22c0
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6360
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<unsigned long>::peek() const
const_pointer peek() const noexcept
		{
			auto rp = _q.rpos.load(std::memory_order_relaxed);
			auto wp = _q.wpos.load(std::memory_order_relaxed);
			
			if (rp == wp)
			{
				// Queue is empty.
				return nullptr;
			}
			
			if (_q.properties.sync)
			{
				// Memory fence after relaxed read.
				std::atomic_thread_fence(std::memory_order_acquire);
			}

			auto d = data();
			auto p = &d[rp];
			return reinterpret_cast<const_pointer>(p);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x3050
jmp 0x3039
movl -0x6c(%rbp), %eax
subl $0x5, %eax
je 0x305d
jmp 0x3043
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3068
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3068
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x80(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x50(%rbp)
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movl -0x2c(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x84(%rbp)
decl %eax
subl $0x2, %eax
jb 0x30cd
jmp 0x30b0
movl -0x84(%rbp), %eax
subl $0x5, %eax
je 0x30dd
jmp 0x30bd
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x30eb
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x30eb
movq -0x90(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x58(%rbp), %rax
jne 0x3107
movq $0x0, -0x40(%rbp)
jmp 0x3171
movq -0x80(%rbp), %rax
cmpl $0x0, 0x88(%rax)
je 0x3150
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x98(%rbp)
subl $0x4, %eax
ja 0x314e
movq -0x98(%rbp), %rax
leaq 0x3ec8(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x314e
jmp 0x314e
jmp 0x314e
mfence
jmp 0x3150
movq -0x80(%rbp), %rdi
callq 0x66b0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
addq -0x50(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::delete_shared(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static void delete_shared(const std::string& name)
		{
			int status = ::shm_unlink(name.c_str());
			if (status == -1 && errno != ENOENT)
			{
				std::string what("shm_unlink: ");
				what.append(::strerror(errno));
				throw circular_queue_error(what);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2360
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x3a1b
callq 0x2030
cmpl $0x2, (%rax)
je 0x3a1b
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2320
movq -0x50(%rbp), %rdx
leaq 0x3886(%rip), %rsi      # 0x71f6
leaq -0x30(%rbp), %rdi
callq 0x2b00
jmp 0x397b
leaq -0x31(%rbp), %rdi
callq 0x2210
callq 0x2030
movl (%rax), %edi
callq 0x2090
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2380
jmp 0x399e
movl $0x18, %edi
callq 0x2100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3aa0
jmp 0x39bd
movq -0x58(%rbp), %rdi
leaq 0x7328(%rip), %rsi      # 0xacf0
leaq 0x121(%rip), %rdx       # 0x3af0
callq 0x2300
jmp 0x3a2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2210
jmp 0x3a21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3a10
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2190
leaq -0x30(%rbp), %rdi
callq 0x2130
jmp 0x3a21
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2310
nopw (%rax,%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue_factory.hpp
// Function: gdc::circular_queue_factory<unsigned long, gdc::circular_queue<unsigned long>>::create()
void create()
		{
			static_assert(
				std::is_trivially_copyable<Q>::value,
				"Q in circular_queue_factory<T,Q> must be trivially copyable");

			if (_q)
			{
				// Already created.
				return;
			}
			
			if (!_name.empty())
			{
				// We're dealing with a shared memory queue.
				
				if (_capacity > 0)
				{
					// We set the capacity, hence we create the queue.
					create_shared(_name, _capacity, _sync, _metadata_initializer);
				}
				
				_q = unique_ptr(map_shared(_name), unmap_shared);
			}
			else if (_capacity > 0)
			{
				_q = unique_ptr(
					create_private(
						_capacity,
						_sync,
						_metadata_initializer),
					delete_private);
			}
			
			assert(_q);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x50, %rdi
callq 0x43c0
testb $0x1, %al
jne 0x4189
jmp 0x418e
jmp 0x437d
movq -0x90(%rbp), %rdi
callq 0x22e0
testb $0x1, %al
jne 0x4276
movq -0x90(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x422d
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, %rsi
addq $0x30, %rsi
movzbl 0x28(%rax), %eax
movl %eax, -0xa4(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4060
movl -0xa4(%rbp), %edx
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rcx
andl $0x1, %edx
callq 0x43f0
jmp 0x4208
leaq -0x28(%rbp), %rdi
callq 0x2de0
jmp 0x422d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2de0
jmp 0x4386
movq -0x90(%rbp), %rdi
callq 0x4b60
movq %rax, %rsi
leaq 0x127d(%rip), %rax      # 0x54c0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x3770
movq -0x90(%rbp), %rdi
addq $0x50, %rdi
leaq -0x48(%rbp), %rsi
callq 0x55e0
leaq -0x48(%rbp), %rdi
callq 0x3a30
jmp 0x4346
movq -0x90(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jbe 0x4344
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0xc0(%rbp)
movq %rax, %rsi
addq $0x30, %rsi
movzbl 0x28(%rax), %eax
movl %eax, -0xc4(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4060
movl -0xc4(%rbp), %esi
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rdx
andl $0x1, %esi
callq 0x5610
movq %rax, -0xb0(%rbp)
jmp 0x42e0
movq -0xb0(%rbp), %rsi
leaq 0x1862(%rip), %rax      # 0x5b50
movq %rax, -0x88(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x3770
movq -0x90(%rbp), %rdi
addq $0x50, %rdi
leaq -0x60(%rbp), %rsi
callq 0x55e0
leaq -0x60(%rbp), %rdi
callq 0x3a30
leaq -0x80(%rbp), %rdi
callq 0x2de0
jmp 0x4344
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x2de0
jmp 0x4386
jmp 0x4346
movq -0x90(%rbp), %rdi
addq $0x50, %rdi
callq 0x43c0
testb $0x1, %al
jne 0x435c
jmp 0x435e
jmp 0x437d
leaq 0x2f5e(%rip), %rdi      # 0x72c3
leaq 0x2dd3(%rip), %rsi      # 0x713f
movl $0x194, %edx            # imm = 0x194
leaq 0x2f4e(%rip), %rcx      # 0x72c6
callq 0x2160
addq $0xd0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2310
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x54d8
jmp 0x55cf
movq -0x8(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5b70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq -0x10(%rbp), %rsi
callq 0x2120
cmpl $-0x1, %eax
jne 0x55cf
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2320
movq -0x58(%rbp), %rdx
leaq 0x1f83(%rip), %rsi      # 0x74a7
leaq -0x38(%rbp), %rdi
callq 0x2b00
jmp 0x552f
leaq -0x39(%rbp), %rdi
callq 0x2210
callq 0x2030
movl (%rax), %edi
callq 0x2090
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x2380
jmp 0x5552
movl $0x18, %edi
callq 0x2100
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x3aa0
jmp 0x5571
movq -0x60(%rbp), %rdi
leaq 0x5774(%rip), %rsi      # 0xacf0
leaq -0x1a93(%rip), %rdx     # 0x3af0
callq 0x2300
jmp 0x55de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x2210
jmp 0x55d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x55c4
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x2130
jmp 0x55d5
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2310
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpb $0x0, 0x568d(%rip)      # 0xb210
jne 0x5bb3
leaq 0x5684(%rip), %rdi      # 0xb210
callq 0x2350
cmpl $0x0, %eax
je 0x5bb3
movl $0x1e, %edi
callq 0x2150
movq %rax, 0x5661(%rip)      # 0xb208
leaq 0x5662(%rip), %rdi      # 0xb210
callq 0x2140
cmpq $-0x1, 0x564d(%rip)     # 0xb208
jne 0x5bc7
movq $0x0, -0x8(%rbp)
jmp 0x5c46
cmpq $0x0, 0x5639(%rip)      # 0xb208
jle 0x5bd3
jmp 0x5bf2
leaq 0x1462(%rip), %rdi      # 0x703c
leaq 0x155e(%rip), %rsi      # 0x713f
movl $0x5a, %edx
leaq 0x1775(%rip), %rcx      # 0x7362
callq 0x2160
cmpq $0x0, -0x10(%rbp)
jne 0x5c06
movq 0x5608(%rip), %rax      # 0xb208
movq %rax, -0x8(%rbp)
jmp 0x5c46
movq 0x55fb(%rip), %rax      # 0xb208
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
subq $0x1, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x55e4(%rip)            # 0xb208
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq $0x1, %rcx
imulq 0x55d1(%rip), %rcx      # 0xb208
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x30(%rbp)
jbe 0x6224
jmp 0x6243
leaq 0x1292(%rip), %rdi      # 0x74bd
leaq 0x1296(%rip), %rsi      # 0x74c8
movl $0xf6, %edx
leaq 0x12a5(%rip), %rcx      # 0x74e3
callq 0x2160
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x5cc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x6262
jmp 0x6281
leaq 0x12d1(%rip), %rdi      # 0x753a
leaq 0x1258(%rip), %rsi      # 0x74c8
movl $0xf7, %edx
leaq 0x1267(%rip), %rcx      # 0x74e3
callq 0x2160
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x6540
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jbe 0x62ab
movq $0x0, -0x20(%rbp)
jmp 0x6345
movq -0x58(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x62fc
jmp 0x62e5
movl -0x6c(%rbp), %eax
subl $0x5, %eax
je 0x6309
jmp 0x62ef
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6314
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6314
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x66b0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x48(%rbp)
jbe 0x6384
jmp 0x63a3
leaq 0x1132(%rip), %rdi      # 0x74bd
leaq 0x1136(%rip), %rsi      # 0x74c8
movl $0x108, %edx            # imm = 0x108
leaq 0x1206(%rip), %rcx      # 0x75a4
callq 0x2160
movq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x5cc0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x63c2
jmp 0x63e1
leaq 0x1171(%rip), %rdi      # 0x753a
leaq 0x10f8(%rip), %rsi      # 0x74c8
movl $0x109, %edx            # imm = 0x109
leaq 0x11c8(%rip), %rcx      # 0x75a4
callq 0x2160
movq -0x60(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x6c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x6432
jmp 0x641b
movl -0x6c(%rbp), %eax
subl $0x5, %eax
je 0x643f
jmp 0x6425
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x644a
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x644a
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x90(%rbp)
callq 0x5cc0
movq %rax, %rcx
movq -0x90(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movq -0x60(%rbp), %rdx
movq %rax, -0x50(%rbp)
movl 0x88(%rdx), %eax
testl %eax, %eax
setne %al
movzbl %al, %ecx
movl %ecx, %eax
leal (%rax,%rax,2), %eax
movl %eax, -0x54(%rbp)
addq $0x40, %rdx
movq -0x50(%rbp), %rcx
movl -0x54(%rbp), %eax
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x2c(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x7c(%rbp)
jmp 0x64d0
movl -0x7c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, -0x38(%rbp)
subl $0x3, %eax
je 0x650b
jmp 0x64ee
movl -0x94(%rbp), %eax
subl $0x5, %eax
je 0x651b
jmp 0x64fb
movq -0x88(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x6533
movq -0x88(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x6533
movq -0x88(%rbp), %rcx
movq -0x38(%rbp), %rax
xchgq %rax, (%rcx)
jmp 0x6533
movq %rax, %rdi
callq 0x3440
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<unsigned long>::space() const
size_type space() const noexcept
		{
			auto rp = _q.rpos.load(std::memory_order_relaxed);
			auto wp = _q.wpos.load(std::memory_order_relaxed);
			auto c = capacity();
			size_t n;
			
			if (wp >= rp)
			{
				// _____xxxxx_____
				//      ^    ^
				//     rp    wp
				//
				// Scenario 2 (empty):
				// _______________
				//      ^
				//    wp==rp
				n = c + rp - wp - 1;
			}
			else
			{
				// xxxxx_____xxxxx
				//      ^    ^
				//     wp    rp
				n = rp - wp;
			}
			
			assert(n < c);
			
			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x5c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x65a0
jmp 0x6589
movl -0x5c(%rbp), %eax
subl $0x5, %eax
je 0x65ad
jmp 0x6593
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x65b8
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x65b8
movq -0x68(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x70(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x5ca0
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
decl %eax
subl $0x2, %eax
jb 0x6611
jmp 0x65fa
movl -0x74(%rbp), %eax
subl $0x5, %eax
je 0x661e
jmp 0x6604
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6629
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x6629
movq -0x80(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x5cc0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jb 0x665e
movq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x666a
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x6676
jmp 0x6695
leaq 0xed1(%rip), %rdi       # 0x754e
leaq 0xe44(%rip), %rsi       # 0x74c8
movl $0xcf, %edx
leaq 0xec4(%rip), %rcx       # 0x7554
callq 0x2160
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10b0
movq -0x48(%rbp), %rdx
leaq 0xd9d(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x1080
jmp 0x1272
leaq -0x29(%rbp), %rdi
callq 0x1070
movq 0x2d56(%rip), %rdi      # 0x3fd8
leaq -0x28(%rbp), %rsi
callq 0x1050
movq %rax, -0x50(%rbp)
jmp 0x1291
movq -0x50(%rbp), %rdi
movq 0x2d2c(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x12a3
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x1210
movq %rax, -0x58(%rbp)
jmp 0x12b6
movq -0x58(%rbp), %rax
movb $0x41, (%rax)
movq 0x2d14(%rip), %rdi      # 0x3fd8
leaq -0x28(%rbp), %rsi
callq 0x1050
movq %rax, -0x60(%rbp)
jmp 0x12d3
movq -0x60(%rbp), %rdi
movq 0x2cea(%rip), %rsi      # 0x3fc8
callq 0x1060
jmp 0x12e5
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x1070
jmp 0x132a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rdi
callq 0x10a0
// File: 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
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x2ab0
movq -0x30(%rbp), %rdi
callq 0x2b30
movb %al, -0x25(%rbp)
jmp 0x261f
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x266d
movq -0x38(%rbp), %rsi
movq 0x109a1(%rip), %rdi     # 0x12fd8
callq 0x21a0
movq %rax, -0x40(%rbp)
jmp 0x2642
movq -0x40(%rbp), %rdi
movq 0x1097b(%rip), %rsi     # 0x12fc8
callq 0x21d0
jmp 0x2654
jmp 0x266d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x2b20
jmp 0x267c
leaq -0x11(%rbp), %rdi
callq 0x2b20
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: Neotoxic-off[P]Zest/src/Zest.cpp
// Function: Zest::Settings::verbose(bool)
bool Zest::Settings::verbose(bool value)
{
    this->verbose_t = value;

    if (this->verbose_t == value)
        return (true);
    return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, (%rax)
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x2b06
movb $0x1, -0x1(%rbp)
jmp 0x2b0a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x8, %rdi
callq 0x3490
movq %rax, -0x28(%rbp)
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0x3500
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34c0
testb $0x1, %al
jne 0x2bf7
jmp 0x2c80
leaq -0x28(%rbp), %rdi
callq 0x35c0
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x3530
testb $0x1, %al
jne 0x2c12
jmp 0x2c63
movq -0x60(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
addq $0x8, %rdi
callq 0x3490
movq %rax, -0x48(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3650
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3690
movq -0x70(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x35e0
movq %rax, -0x50(%rbp)
movb $0x1, -0x1(%rbp)
jmp 0x2c84
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x36d0
movq %rax, -0x58(%rbp)
jmp 0x2bd0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb (%rdi), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2b50
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2f29
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x2b70
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22f0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xb16b(%rip), %rsi      # 0xe06b
callq 0x3780
jmp 0x2f07
leaq -0x11(%rbp), %rdi
callq 0x21f0
jmp 0x2f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x21f0
jmp 0x2f86
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x2b70
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22f0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xb120(%rip), %rsi      # 0xe073
callq 0x3780
jmp 0x2f5a
leaq -0x25(%rbp), %rdi
callq 0x21f0
jmp 0x2f7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x21f0
jmp 0x2f86
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22e0
nop
// File: 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
subq $0xc0, %rsp
movq %rdx, -0x98(%rbp)
movq %rsi, %rax
movq -0x98(%rbp), %rsi
movq %rdi, -0x90(%rbp)
movq %rdi, %rcx
movq %rcx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x20c0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x2ba0
movb %al, -0x6a(%rbp)
jmp 0x2ff0
movb -0x6a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x9c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2120
movl -0x9c(%rbp), %eax
cmpl $0x1, %eax
jne 0x3080
leaq -0x45(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x22f0
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rdx
leaq 0xb043(%rip), %rsi      # 0xe07a
callq 0x3780
jmp 0x303e
leaq -0x45(%rbp), %rdi
callq 0x21f0
jmp 0x3117
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2120
jmp 0x3127
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x21f0
jmp 0x3127
movq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x20c0
movq -0x80(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x2c90
jmp 0x30a9
leaq -0x68(%rbp), %rdi
callq 0x2120
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x22f0
movq -0x90(%rbp), %rdi
movq -0xb8(%rbp), %rdx
leaq 0xafa8(%rip), %rsi      # 0xe07f
callq 0x3780
jmp 0x30de
leaq -0x69(%rbp), %rdi
callq 0x21f0
jmp 0x3117
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2120
jmp 0x3127
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x69(%rbp), %rdi
callq 0x21f0
jmp 0x3127
movq -0x88(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22e0
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, %rax
movq -0xe0(%rbp), %rsi
movq %rdi, -0xd8(%rbp)
movq %rdi, %rdx
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x20c0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x2ba0
movb %al, -0xb1(%rbp)
jmp 0x31aa
movb -0xb1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xec(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2120
movl -0xec(%rbp), %eax
cmpl $0x1, %eax
jne 0x323d
leaq -0x4d(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x22f0
movq -0xd8(%rbp), %rdi
movq -0xf8(%rbp), %rdx
leaq 0xae86(%rip), %rsi      # 0xe07a
callq 0x3780
jmp 0x31fb
leaq -0x4d(%rbp), %rdi
callq 0x21f0
jmp 0x3329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x3339
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x21f0
jmp 0x3339
movq -0xe0(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x20c0
movq -0xc8(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0x2c90
jmp 0x3269
leaq -0x70(%rbp), %rdi
callq 0x2120
movq -0xe8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x7ae0
movq -0x108(%rbp), %rdx
leaq 0xade9(%rip), %rsi      # 0xe083
leaq -0x90(%rbp), %rdi
callq 0x3880
jmp 0x32a8
movq -0xd8(%rbp), %rdi
leaq 0xad9d(%rip), %rdx      # 0xe053
leaq -0x90(%rbp), %rsi
callq 0x3830
jmp 0x32c4
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0xb0(%rbp), %rdi
callq 0x2120
jmp 0x3329
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2120
jmp 0x3339
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x331b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2120
leaq -0xb0(%rbp), %rdi
callq 0x2120
jmp 0x3339
movq -0xd0(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc0(%rbp), %rdx
leaq 0x9667(%rip), %rsi      # 0xe0cf
leaq -0x28(%rbp), %rdi
callq 0x3780
jmp 0x4a73
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6260
jmp 0x4a85
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x22f0
movq -0xd0(%rbp), %rdx
leaq 0x9618(%rip), %rsi      # 0xe0d8
leaq -0x60(%rbp), %rdi
callq 0x3780
jmp 0x4acb
movq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x6450
jmp 0x4add
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x61(%rbp), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x22f0
movq -0xe0(%rbp), %rdx
leaq 0x95c6(%rip), %rsi      # 0xe0e1
leaq -0x88(%rbp), %rdi
callq 0x3780
jmp 0x4b29
movq -0xe8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x6640
jmp 0x4b3e
leaq -0x88(%rbp), %rdi
callq 0x2120
leaq -0x89(%rbp), %rdi
callq 0x21f0
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x22f0
movq -0xf0(%rbp), %rdx
leaq 0x9564(%rip), %rsi      # 0xe0e6
leaq -0xb0(%rbp), %rdi
callq 0x3780
jmp 0x4b90
movq -0xf8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x6a20
jmp 0x4ba5
leaq -0xb0(%rbp), %rdi
callq 0x2120
leaq -0xb1(%rbp), %rdi
callq 0x21f0
xorl %eax, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4beb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2120
leaq -0x29(%rbp), %rdi
callq 0x21f0
jmp 0x4c8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4c1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
leaq -0x61(%rbp), %rdi
callq 0x21f0
jmp 0x4c8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4c4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2120
leaq -0x89(%rbp), %rdi
callq 0x21f0
jmp 0x4c8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x4c81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2120
leaq -0xb1(%rbp), %rdi
callq 0x21f0
movq -0x38(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)