LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::epoll()
epoll::epoll()
{
    handle = epoll_create1(0);
    if (handle == -1)
	throw std::runtime_error{"An error occured while creating epoll: " +
		                 get_errno_as_string()};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
andq $0x0, 0x18(%rdi)
xorl %edi, %edi
callq 0xb8f0
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0xf776
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb2a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb460
leaq 0x1247(%rip), %rsi      # 0x109d9
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xbc20
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xbb90
xorl %ebp, %ebp
movq 0x5836(%rip), %rsi      # 0x14ff0
movq 0x5777(%rip), %rdx      # 0x14f38
movq %r14, %rdi
callq 0xbc50
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0xb250
jmp 0xf7de
movq %rax, %r15
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0xb250
testb %bpl, %bpl
jne 0xf7f2
jmp 0xf7fa
movq %rax, %r15
movq %r14, %rdi
callq 0xb430
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xbce0
movq %r15, %rdi
callq 0xbcf0
// File: /workspace/github_cpp_makefile_star2_O2/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::add(socket_io::socket_view const&, unsigned int)
auto epoll::add(socket_view const& to_monitor, uint32_t const events) -> void
{
    int const sockfd = to_monitor.get_native_handle();
    epoll_event config { events, { .fd = sockfd } };
    if (epoll_ctl(handle, EPOLL_CTL_ADD, sockfd, &config) == -1)
	throw std::runtime_error{"An error occured while adding a fd: " +
		                 get_errno_as_string()};
    monitored_sockets.push_back(to_monitor);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xb5e0
leaq 0x44(%rsp), %rcx
movl %ebp, (%rcx)
movl %eax, 0x4(%rcx)
movl (%r14), %edi
pushq $0x1
popq %rsi
movl %eax, %edx
callq 0xb960
cmpl $-0x1, %eax
je 0xf8ac
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd20
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xb2a0
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb460
leaq 0x113b(%rip), %rsi      # 0x10a01
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xbc20
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb90
xorl %ebp, %ebp
movq 0x5704(%rip), %rsi      # 0x14ff0
movq 0x5645(%rip), %rdx      # 0x14f38
movq %rbx, %rdi
callq 0xbc50
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0xb250
jmp 0xf910
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0xb250
testb %bpl, %bpl
jne 0xf922
jmp 0xf92a
movq %rax, %r14
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0xbcf0
// File: /workspace/github_cpp_makefile_star2_O2/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::remove(socket_io::socket_view const&)
auto epoll::remove(socket_view const& to_stop_monitor) -> void
{
    int const sockfd = to_stop_monitor.get_native_handle();
    epoll_event config { 0, { .fd = sockfd } };
    if (epoll_ctl(handle, EPOLL_CTL_DEL, sockfd, &config) == -1)
    {
	if (errno == ENOENT)
	    return;
	throw std::runtime_error{"An error occured while removing a fd: " +
		                 get_errno_as_string()};
    }
    
    auto new_end = std::remove_if(std::begin(monitored_sockets),
				  std::end(monitored_sockets),
				  [=](socket_view const& view)
				  { return view.get_native_handle() ==
				           sockfd; });
    monitored_sockets.erase(new_end, std::end(monitored_sockets));		   
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb5e0
leaq 0x5c(%rsp), %rcx
andl $0x0, (%rcx)
movl %eax, %ebp
movl %eax, 0x4(%rcx)
movl (%rbx), %edi
pushq $0x2
popq %rsi
movl %eax, %edx
callq 0xb960
cmpl $-0x1, %eax
je 0xf9f5
leaq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %r12
movq %rbx, 0x8(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, %r14
subq %r12, %r14
movq %r14, %r15
sarq $0x5, %r15
testq %r15, %r15
jle 0xfa56
movq %r12, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfaa4
leaq 0x8(%r12), %r13
movq %r13, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfaa7
leaq 0x10(%r12), %r13
movq %r13, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfaa7
leaq 0x18(%r12), %r13
movq %r13, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfaa7
addq $0x20, %r12
decq %r15
addq $-0x20, %r14
jmp 0xf990
callq 0xb050
cmpl $0x2, (%rax)
je 0xfaef
pushq $0x10
popq %rdi
callq 0xb2a0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb460
leaq 0x1007(%rip), %rsi      # 0x10a26
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xbc20
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb90
xorl %ebp, %ebp
movq 0x55a9(%rip), %rsi      # 0x14ff0
movq 0x54ea(%rip), %rdx      # 0x14f38
movq %rbx, %rdi
callq 0xbc50
sarq $0x3, %r14
cmpq $0x1, %r14
movq 0x8(%rsp), %r15
je 0xfa91
cmpq $0x2, %r14
je 0xfa81
cmpq $0x3, %r14
jne 0xfade
movq %r12, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfa9f
addq $0x8, %r12
movq %r12, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfa9f
addq $0x8, %r12
movq %r12, %rdi
callq 0xb5e0
cmpl %ebp, %eax
cmovneq %rbx, %r12
movq %r12, %r13
jmp 0xfaac
movq %r12, %r13
movq 0x8(%rsp), %r15
cmpq %rbx, %r13
je 0xfadb
movq %r13, %r14
addq $0x8, %r13
cmpq %rbx, %r13
je 0xfad6
movq %r13, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfab4
movq (%r13), %rax
movq %rax, (%r14)
addq $0x8, %r14
jmp 0xfab4
movq %r14, %rbx
jmp 0xfade
movq %r13, %rbx
movq 0x10(%r15), %rdx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xbc10
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xb250
jmp 0xfb13
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0xb250
testb %bpl, %bpl
jne 0xfb27
jmp 0xfb2f
movq %rax, %r14
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0xbcf0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dak98[P]SocketIO/src/epoll.cpp
// Function: socket_io::epoll::get_event() const
auto epoll::get_event() const -> event
{
    epoll_event events[1];
    int error_code = epoll_wait(handle, events, 1, -1);
    if (error_code == -1 && errno == EINTR)
	throw std::system_error{std::make_error_code(std::errc::interrupted)};
    if (error_code == -1)
	throw std::runtime_error{"An error occured while acquiring an event: " +
		                 get_errno_as_string()};

    auto it = std::find_if(std::begin(monitored_sockets),
			   std::end(monitored_sockets),
			   [=](socket_view const& view)
			   { return view.get_native_handle() ==
			            events[0].data.fd; });
    return {events[0].events, *it};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movl (%rdi), %edi
leaq 0xc(%rsp), %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0xb290
cmpl $-0x1, %eax
je 0xfc38
movq 0x8(%r14), %rbx
movq 0x10(%r14), %r15
movl 0x10(%rsp), %ebp
movq %r15, %r12
subq %rbx, %r12
movq %r12, %r13
sarq $0x5, %r13
testq %r13, %r13
jle 0xfbcb
movq %rbx, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfbfd
leaq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfc17
leaq 0x10(%rbx), %r14
movq %r14, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfc17
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfc17
addq $0x20, %rbx
decq %r13
addq $-0x20, %r12
jmp 0xfb7d
sarq $0x3, %r12
cmpq $0x1, %r12
je 0xfc06
cmpq $0x2, %r12
je 0xfbf1
cmpq $0x3, %r12
jne 0xfc14
movq %rbx, %rdi
callq 0xb5e0
cmpl %ebp, %eax
je 0xfbfd
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xb5e0
cmpl %ebp, %eax
jne 0xfc02
movq %rbx, %r14
jmp 0xfc17
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xb5e0
cmpl %ebp, %eax
cmoveq %rbx, %r15
movq %r15, %r14
movl 0xc(%rsp), %ecx
movl (%r14), %eax
movl 0x4(%r14), %edx
shlq $0x20, %rax
orq %rcx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb050
cmpl $0x4, (%rax)
jne 0xfc76
pushq $0x20
popq %rdi
callq 0xb2a0
movq %rax, %rbx
callq 0xb2c0
pushq $0x4
popq %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb400
movq 0x52b9(%rip), %rsi      # 0x14f20
movq 0x52d2(%rip), %rdx      # 0x14f40
movq %rbx, %rdi
callq 0xbc50
pushq $0x10
popq %rdi
callq 0xb2a0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb460
leaq 0xdbb(%rip), %rsi       # 0x10a4d
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xbc20
movb $0x1, %bpl
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0xbb90
xorl %ebp, %ebp
movq 0x5336(%rip), %rsi      # 0x14ff0
movq 0x5277(%rip), %rdx      # 0x14f38
movq %rbx, %rdi
callq 0xbc50
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0xb250
jmp 0xfcde
movq %rax, %r14
movb $0x1, %bpl
leaq 0x18(%rsp), %rdi
callq 0xb250
testb %bpl, %bpl
jne 0xfcf4
jmp 0xfcfc
jmp 0xfcf1
movq %rax, %r14
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0xbcf0
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::detail::cols()
static unsigned int cols()
        {
            unsigned int n = 80;
#ifndef _WIN32
            const char *s = getenv("COLUMNS");
            if (s)
            {
                std::istringstream(s) >> n;
            }
#endif
            return n;
        }

// Assembly:
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl $0x50, 0xc(%rsp)
leaq 0x7f56(%rip), %rdi      # 0xdb41
callq 0x32f0
testq %rax, %rax
je 0x5c43
leaq 0x10(%rsp), %rbx
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x30d0
leaq 0x30(%rsp), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x3400
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3420
leaq 0x30(%rsp), %rdi
callq 0x3110
leaq 0x10(%rsp), %rdi
callq 0x3300
movl 0xc(%rsp), %eax
jmp 0x5c46
pushq $0x50
popq %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x5c61
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> optparse::detail::str_join_trans<std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, optparse::detail::str_wrap>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::_Rb_tree_const_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, optparse::detail::str_wrap)
static std::string str_join_trans(const std::string &sep, InputIterator begin, InputIterator end, UnaryOperator op)
        {
            std::string buf;
            for (InputIterator it = begin; it != end; ++it)
            {
                if (it != begin)
                {
                    buf += sep;
                }
                buf += op(*it);
            }

            return buf;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, (%rsp)
movb $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rbp
movq %rdx, %r12
cmpq %r15, %r12
je 0x5cf7
cmpq %r13, %r12
je 0x5cc7
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x3490
leaq 0x20(%r12), %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0xace8
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3490
movq %rbp, %rdi
callq 0x3300
movq %r12, %rdi
callq 0x32b0
movq %rax, %r12
jmp 0x5cb1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d1a
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3300
jmp 0x5d1d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3300
movq %r14, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
nop
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser& optparse::OptionParser::set_defaults<char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
OptionParser &set_defaults(const std::string &dest, T t)
        {
            std::ostringstream ss;
            ss << t;
            _defaults[dest] = ss.str();
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x3330
movq %r12, %rdi
movq %r15, %rsi
callq 0x3260
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x33b0
leaq 0x1c0(%rbx), %rdi
movq %r14, %rsi
callq 0xc62e
movq %rsp, %rsi
movq %rax, %rdi
callq 0x3160
movq %rsp, %rdi
callq 0x3300
leaq 0x20(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x632c
movq %rax, %rbx
jmp 0x633c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3300
leaq 0x20(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::Option::action(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Option &action(const std::string &a)
        {
            _action = a;
            if (a == "store_const" or
                a == "store_true" or
                a == "store_false" or
                a == "append_const" or
                a == "count" or
                a == "help" or
                a == "version")
            {
                nargs(0);
            }
            return *this;
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x60, %rdi
callq 0x3160
leaq 0x72c9(%rip), %rsi      # 0xd6c5
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x7159(%rip), %rsi      # 0xd568
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x711f(%rip), %rsi      # 0xd541
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x7393(%rip), %rsi      # 0xd7c8
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x725a(%rip), %rsi      # 0xd6a2
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x72e2(%rip), %rsi      # 0xd73d
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
jne 0x647a
leaq 0x72e3(%rip), %rsi      # 0xd751
movq %r14, %rdi
callq 0x8a6f
testb %al, %al
je 0x6482
andq $0x0, 0xe0(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::Option& optparse::Option::set_default<char const*>(char const*)
Option &set_default(T t)
        {
            std::ostringstream ss;
            ss << t;
            _default = ss.str();
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3330
movq %r15, %rdi
movq %r14, %rsi
callq 0x3260
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x33b0
leaq 0xc0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3160
leaq 0x8(%rsp), %rdi
callq 0x3300
leaq 0x28(%rsp), %rdi
callq 0x3080
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3300
jmp 0x663a
jmp 0x6637
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3080
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::Values::all(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::vector<std::string> all(const std::string &d) const
        {
            static const std::vector<std::string> empty;
            return (_append_map.find(d) == _append_map.end()) ?
                empty :
                _append_map.at(d);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb 0xe75f(%rip), %al       # 0x155b0
testb %al, %al
je 0x6e9b
leaq 0x30(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xcb46
addq $0x38, %r15
cmpq %r15, %rax
je 0x6e7d
movq %r12, %rdi
movq %r14, %rsi
callq 0xcb00
movq %rax, %rsi
jmp 0x6e84
leaq 0xe714(%rip), %rsi      # 0x15598
movq %rbx, %rdi
callq 0x6b64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xe70e(%rip), %rdi      # 0x155b0
callq 0x3450
testl %eax, %eax
je 0x6e55
xorps %xmm0, %xmm0
movups %xmm0, 0xe6e3(%rip)     # 0x15598
andq $0x0, 0xe6eb(%rip)      # 0x155a8
leaq 0xe6d4(%rip), %rsi      # 0x15598
leaq 0x5d(%rip), %rdi        # 0x6f28
leaq 0xe396(%rip), %rdx      # 0x15268
callq 0x3210
leaq 0xe6d2(%rip), %rdi      # 0x155b0
callq 0x3190
jmp 0x6e55
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/test.cpp
// Function: Output::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void operator()(const std::string &s)
    {
        if (first)
        {
            first = false;
        }
        else
        {
            std::cout << delim;
        }
        std::cout << s;
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x6f76
movb $0x0, 0x8(%rdi)
jmp 0x6f85
movq (%rdi), %rsi
movq 0xe048(%rip), %rdi      # 0x14fc8
callq 0x3220
movq 0xe03c(%rip), %rdi      # 0x14fc8
movq %rbx, %rsi
popq %rbx
jmp 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::set_usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void set_usage(const std::string &u)
        {
            std::string lower = u;
            std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
            if (lower.compare(0, 7, "usage: ") == 0)
            {
                _usage = u.substr(7);
            }
            else
            {
                _usage = u;
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3340
movq (%r15), %r12
movq 0x8(%r15), %r15
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x767e
movsbl (%r12,%r13), %edi
callq 0x3360
movb %al, (%r12,%r13)
incq %r13
jmp 0x7666
leaq 0x62ab(%rip), %rcx      # 0xd930
leaq 0x20(%rsp), %rdi
pushq $0x7
popq %rdx
xorl %esi, %esi
callq 0x3320
testl %eax, %eax
je 0x76a9
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3160
jmp 0x76d1
movq %rsp, %rdi
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x3290
addq $0x8, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3160
movq %rsp, %rdi
callq 0x3300
leaq 0x20(%rsp), %rdi
callq 0x3300
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3300
jmp 0x76fb
jmp 0x76f8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
nop
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/test.cpp
// Function: MyCallback::operator()(optparse::Option const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, optparse::OptionParser const&)
void operator()(const optparse::Option &option, const std::string &opt, const std::string &val, const optparse::OptionParser &parser)
    {
        counter++;
        std::cout << "--- MyCallback --- " << counter << ". time called" << std::endl;
        std::cout << "--- MyCallback --- option.action(): " << option.action() << std::endl;
        std::cout << "--- MyCallback --- opt: " << opt << std::endl;
        std::cout << "--- MyCallback --- val: " << val << std::endl;
        std::cout << "--- MyCallback --- parser.usage(): " << parser.usage() << std::endl;
        std::cout << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
incl 0x8(%rdi)
movq 0xbd9e(%rip), %rbx      # 0x14fc8
leaq 0x473a(%rip), %rsi      # 0xd96b
movq %rbx, %rdi
callq 0x3260
movl 0x8(%rbp), %esi
movq %rax, %rdi
callq 0x3410
leaq 0x4734(%rip), %rsi      # 0xd97f
movq %rax, %rdi
callq 0x3260
movq %rax, %rdi
callq 0x3120
leaq 0x472b(%rip), %rsi      # 0xd98d
movq %rbx, %rdi
callq 0x3260
addq $0x60, %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3120
leaq 0x472a(%rip), %rsi      # 0xd9b2
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
movq %r12, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3120
leaq 0x4721(%rip), %rsi      # 0xd9cb
movq %rbx, %rdi
callq 0x3260
movq %rax, %rdi
movq %r15, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3120
leaq 0x4718(%rip), %rsi      # 0xd9e4
movq %rbx, %rdi
callq 0x3260
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3120
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3120
nop
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::format_option_help[abi:cxx11](unsigned int) const
std::string format_option_help(unsigned int indent=2) const
        {
            std::stringstream ss;

            if (_opts.empty())
            {
                return ss.str();
            }

            for (std::list<Option>::const_iterator it = _opts.begin(); it != _opts.end(); ++it)
            {
                if (not it->_suppress_help)
                {
                    ss << it->format_help(indent);
                }
            }

            return ss.str();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x31c0
movq 0x148(%r14), %r13
addq $0x148, %r14            # imm = 0x148
cmpq %r14, %r13
je 0xbb54
leaq 0x30(%rsp), %r15
movq %rsp, %r12
cmpq %r14, %r13
je 0xbb54
cmpb $0x0, 0x150(%r13)
jne 0xbb4e
leaq 0x10(%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xbbac
movq %r15, %rdi
movq %r12, %rsi
callq 0x3220
movq %r12, %rdi
callq 0x3300
movq (%r13), %r13
jmp 0xbb1e
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x33b0
leaq 0x20(%rsp), %rdi
callq 0x31e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbb8f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3300
jmp 0xbb92
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
// File: /workspace/github_cpp_makefile_star2_O2/myint[P]optparse/./optparse.h
// Function: optparse::OptionParser::lookup_short_opt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const Option &lookup_short_opt(const std::string &opt) const
        {
            std::map<std::string, Option const *>::const_iterator it = _optmap_s.find(opt);
            if (it == _optmap_s.end())
            {
                error("no such option" + std::string(": -") + opt);

                static const Option empty;
                return empty;
            }
            return *it->second;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x160, %rdi            # imm = 0x160
callq 0xad44
leaq 0x168(%rbx), %rcx
cmpq %rcx, %rax
je 0xc33b
movq 0x40(%rax), %rbx
jmp 0xc3b6
leaq 0x1809(%rip), %rsi      # 0xdb4b
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30d0
leaq 0x175d(%rip), %rsi      # 0xdab5
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xa757
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0xac0d
movq (%rbx), %rax
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x48(%rsp), %rdi
callq 0x3300
leaq 0x28(%rsp), %rdi
callq 0x3300
leaq 0x8(%rsp), %rdi
callq 0x3300
movb 0x91bd(%rip), %al       # 0x15568
leaq 0x9046(%rip), %rbx      # 0x153f8
testb %al, %al
je 0xc3c1
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x91a0(%rip), %rdi      # 0x15568
callq 0x3450
testl %eax, %eax
je 0xc3b6
leaq 0x9020(%rip), %rbx      # 0x153f8
movq %rbx, %rdi
callq 0x8900
leaq -0x50af(%rip), %rdi     # 0x7338
leaq 0x8e7a(%rip), %rdx      # 0x15268
movq %rbx, %rsi
callq 0x3210
leaq 0x916b(%rip), %rdi      # 0x15568
callq 0x3190
jmp 0xc3b6
movq %rax, %rbx
leaq 0x915a(%rip), %rdi      # 0x15568
callq 0x3180
jmp 0xc445
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3300
jmp 0xc431
movq %rax, %rbx
jmp 0xc445
movq %rax, %rbx
jmp 0xc43b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3300
leaq 0x8(%rsp), %rdi
callq 0x3300
movq %rbx, %rdi
callq 0x3430
movq %rax, %rdi
callq 0x62a4
nop
// File: /workspace/github_cpp_makefile_star2_O2/ankit-1517[P]dbms_rTree/sample_run.cpp
// Function: main
int main() {
	FileManager fm;

	// Create a brand new file
	FileHandler fh = fm.CreateFile("temp.txt");
	cout << "File created " << endl;

	// Create a new page
	PageHandler ph = fh.NewPage ();
	char *data = ph.GetData ();

	// Store an integer at the very first location
	int num = 5;
	memcpy (&data[0], &num, sizeof(int));

	// Store an integer at the second location
	num = 1000;
	memcpy (&data[4], &num, sizeof(int));

	// Flush the page
	fh.FlushPages ();
	cout << "Data written and flushed" << endl;

	// Close the file
	fm.CloseFile(fh);

	// Reopen the same file, but for reading this time
	fh = fm.OpenFile ("temp.txt");
	cout << "File opened" << endl;

	// Get the very first page and its data
	ph = fh.FirstPage ();
	data = ph.GetData ();

	// Output the first integer
	memcpy (&num, &data[0], sizeof(int));
	cout << "First number: " << num << endl;

	// Output the second integer
	memcpy (&num, &data[4], sizeof(int));
	cout << "Second number: " << num << endl;;

	// Close the file and destory it
	fm.CloseFile (fh);
	fm.DestroyFile ("temp.txt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
callq 0x3a2e
leaq 0x672(%rip), %rdx       # 0x43a8
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x3ad0
movq 0x3287(%rip), %rdi      # 0x6fd0
leaq 0x661(%rip), %rsi       # 0x43b1
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x385c
leaq -0x50(%rbp), %rdi
callq 0x35f6
movabsq $0x3e800000005, %rcx    # imm = 0x3E800000005
movq %rcx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x3988
movq 0x3240(%rip), %rdi      # 0x6fd0
leaq 0x628(%rip), %rsi       # 0x43bf
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c42
leaq 0x5f0(%rip), %rdx       # 0x43a8
leaq -0x70(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b88
movups -0x70(%rbp), %xmm0
movups -0x60(%rbp), %xmm1
movaps %xmm1, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq 0x31f4(%rip), %rdi      # 0x6fd0
leaq 0x5f5(%rip), %rsi       # 0x43d8
callq 0x2140
movq %rax, %rdi
callq 0x20b0
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x365a
movups -0x70(%rbp), %xmm0
leaq -0x50(%rbp), %rdi
movaps %xmm0, (%rdi)
callq 0x35f6
movq %rax, %rbx
movl (%rax), %r14d
movq 0x31b6(%rip), %rdi      # 0x6fd0
leaq 0x5c3(%rip), %rsi       # 0x43e4
callq 0x2140
movq %rax, %rdi
movl %r14d, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
movl 0x4(%rbx), %ebx
movq 0x318d(%rip), %rdi      # 0x6fd0
leaq 0x5a9(%rip), %rsi       # 0x43f3
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3c42
leaq 0x533(%rip), %rsi       # 0x43a8
leaq -0x18(%rbp), %rdi
callq 0x3c2e
leaq -0x18(%rbp), %rdi
callq 0x3aa4
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3e9c
jmp 0x3e9c
jmp 0x3e9c
jmp 0x3e9c
jmp 0x3e9c
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x3aa4
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Socket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Socket::Socket(string ip, string name, int port) {
	if (log) cout << "Creating socket\n";
	
	this->connected = false;
	this->name = name;
	this->port = port;
	this->ip = ip;

    this->sock_fd = socket(AF_INET, SOCK_STREAM, 0);
	this->conn_fd = this->sock_fd;

	if (this->sock_fd == -1) {
        this->error.set_occurred();
        this->error.set_message("Could not create socket T.T\n");
    }

	size_t size = sizeof(&serv_addr);
    bzero(&serv_addr, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %r13d
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x8(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x28(%rdi), %r12
movb %al, 0x38(%rdi)
addq $0x48, %rdi
movq %rdi, -0x38(%rbp)
movq %r12, -0x48(%rbp)
callq 0x24dc
movb $0x0, 0x74(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movl %r13d, (%rbx)
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x20e0
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x2050
movl %eax, 0x98(%rbx)
movl %eax, 0x70(%rbx)
cmpl $-0x1, %eax
jne 0x26ec
movq -0x38(%rbp), %rdi
callq 0x2502
leaq 0x197e(%rip), %rsi      # 0x4047
leaq -0x68(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x254a
leaq -0x68(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2520
leaq -0x68(%rbp), %rdi
callq 0x22e8
andq $0x0, 0x78(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0x68(%rbp), %rdi
callq 0x22e8
jmp 0x2718
jmp 0x2715
movq %rax, %r12
jmp 0x2724
movq %rax, %r12
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x22e8
movq -0x48(%rbp), %rdi
callq 0x22e8
movq -0x40(%rbp), %rdi
callq 0x22e8
movq %r12, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Disconnect()
void Socket::Disconnect() {
	if (log) cout << "Disconnecting\n";

	int status = close(this->sock_fd);

	if (status == -1) {
		this->error.set_occurred();
		this->error.set_message("Could not disconnect... =(\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x98(%rdi), %edi
callq 0x22d0
cmpl $-0x1, %eax
jne 0x27cd
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2502
leaq 0x1925(%rip), %rsi      # 0x40ce
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x254a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2520
leaq -0x38(%rbp), %rdi
callq 0x22e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Bind()
void Socket::Bind(){
	if (log) cout << "Binding socket\n";
	
	/* IPV4 */
	this->serv_addr.sin_family = AF_INET;

	/* Manda o socket ouvir em todas as interfaces disponíveis */
	this->serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);

	/* Port em network byte order */
	this->serv_addr.sin_port = htons(this->port);

	int status = bind(this->sock_fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

	if (status == -1){
		this->error.set_occurred();
		this->error.set_message("Could not bind with the server ;-;\n");
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %rsi
movw $0x2, 0x78(%rdi)
andl $0x0, 0x7c(%rdi)
movzwl (%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x7a(%rdi)
movl 0x98(%rdi), %edi
pushq $0x10
popq %rdx
callq 0x2030
cmpl $-0x1, %eax
jne 0x285b
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2502
leaq 0x182d(%rip), %rsi      # 0x4064
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x254a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2520
leaq -0x38(%rbp), %rdi
callq 0x22e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Connect()
void Socket::Connect() {
	if (log) cout << "Connecting socket\n";
	
	/* IPV4 */
	this->serv_addr.sin_family = AF_INET;
	
	/* Diz em que porta está o servidor a ser conectado */
	this->serv_addr.sin_addr.s_addr = inet_addr((this->ip).c_str());
	
	/* Port em network byte order */
	this->serv_addr.sin_port = htons(this->port);
    
	int status = connect(this->sock_fd, (struct sockaddr*)&serv_addr, sizeof(serv_addr));

	if (status == -1) {
		this->error.set_occurred();
		this->error.set_message("Could not connect with the server =(\n");
		return;
	}
    
    this->connected = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
movw $0x2, 0x78(%rdi)
movq 0x8(%rdi), %rdi
callq 0x21a0
movl %eax, 0x7c(%rbx)
movzwl (%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x7a(%rbx)
movl 0x98(%rbx), %edi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x2140
cmpl $-0x1, %eax
je 0x28d9
movb $0x1, 0x74(%rbx)
jmp 0x2910
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2502
leaq 0x179c(%rip), %rsi      # 0x4088
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x254a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2520
leaq -0x38(%rbp), %rdi
callq 0x22e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Accept[abi:cxx11]()
pair<int, string> Socket::Accept() {
	if (log) cout << "Accepting\n";
	
	sockaddr_in received_addr;
	socklen_t addr_size = sizeof(received_addr);

	int connection_fd = accept(this->sock_fd, (struct sockaddr *)&received_addr, &addr_size);

	if (connection_fd == -1) {
		this->error.set_occurred();
		this->error.set_message("Server didn't accept, sorry =(\n");
		return pair<int, string>(-1, "");
	}
	
	this->conn_fd = connection_fd;
	getpeername(connection_fd, (struct sockaddr*)&received_addr, &addr_size);
	return pair<int, string>(connection_fd, inet_ntoa(received_addr.sin_addr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rdx
movl $0x10, (%rdx)
movl 0x98(%rsi), %edi
leaq -0x38(%rbp), %rsi
callq 0x2080
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x2996
movl %eax, 0x70(%r14)
leaq -0x38(%rbp), %r14
leaq -0x20(%rbp), %rdx
movl %eax, %edi
movq %r14, %rsi
callq 0x2110
movl 0x4(%r14), %edi
callq 0x20c0
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x1c(%rbp), %rsi
movq %rbx, %rdi
callq 0x2c70
jmp 0x29e3
addq $0x48, %r14
movq %r14, %rdi
callq 0x2502
leaq 0x1705(%rip), %rsi      # 0x40ae
leaq -0x58(%rbp), %r15
leaq -0x28(%rbp), %rdx
movq %r15, %rdi
callq 0x254a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2520
leaq -0x58(%rbp), %rdi
callq 0x22e8
leaq -0x28(%rbp), %rsi
orl $-0x1, (%rsi)
leaq 0x18a9(%rip), %rdx      # 0x4284
movq %rbx, %rdi
callq 0x2c4a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Read[abi:cxx11](int)
string Socket::Read(int conn_fd) {
	if (log) cout << "Reading\n";

	char helper[buffer_size + 1];
	bzero(helper, sizeof(helper));
	
	int status = read(conn_fd, helper, sizeof(helper));

	if (status == -1) {
		this->error.set_occurred();
		this->error.set_message("Could not read... =(\n");
	}
	
	string ret(helper);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1030, %rsp           # imm = 0x1030
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1050(%rbp), %r12
movl $0x1001, %edx           # imm = 0x1001
movq %r12, %rdi
xorl %esi, %esi
callq 0x20f0
movl $0x1001, %edx           # imm = 0x1001
movl %r15d, %edi
movq %r12, %rsi
callq 0x2240
cmpl $-0x1, %eax
jne 0x2a83
addq $0x48, %r14
movq %r14, %rdi
callq 0x2502
leaq 0x168b(%rip), %rsi      # 0x40ea
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %rdx
movq %r15, %rdi
callq 0x254a
movq %r14, %rdi
movq %r15, %rsi
callq 0x2520
leaq -0x48(%rbp), %rdi
callq 0x22e8
leaq -0x1050(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x254a
movq %rbx, %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
int Socket::Write(string msg, int conn_fd) {
	if (log) cout << "Writing\n";

	// Default conn_fd
	if (conn_fd == -1) conn_fd = this->conn_fd;

	char helper[buffer_size + 1];
	bzero(helper, sizeof(helper));
	strcpy(helper, msg.c_str());

	int status = write(conn_fd, helper, sizeof(helper));

	if (status < 1) {
		this->error.set_occurred();
		this->error.set_message("Could not write... =(\n");
	}

	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1030, %rsp           # imm = 0x1030
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, %edx
jne 0x2ae2
movl 0x70(%rbx), %r14d
leaq -0x1050(%rbp), %r12
movl $0x1001, %edx           # imm = 0x1001
movq %r12, %rdi
xorl %esi, %esi
callq 0x20f0
movq (%r15), %rsi
movq %r12, %rdi
callq 0x2170
movl $0x1001, %edx           # imm = 0x1001
movl %r14d, %edi
movq %r12, %rsi
callq 0x2090
movq %rax, %r14
testl %r14d, %r14d
jg 0x2b52
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2502
leaq 0x15d2(%rip), %rsi      # 0x4100
leaq -0x48(%rbp), %r15
leaq -0x21(%rbp), %rdx
movq %r15, %rdi
callq 0x254a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2520
leaq -0x48(%rbp), %rdi
callq 0x22e8
movl %r14d, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/socket.cpp
// Function: Socket::Check()
void Socket::Check() {
    if (!this->Has_error()) return;
	
	cout << this->Get_error();
	delete this;
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x2c0c
testb %al, %al
jne 0x2bb2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x48(%rbx), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x252e
movq 0x4407(%rip), %rdi      # 0x6fd0
movq %r14, %rsi
callq 0x2160
leaq -0x30(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x273e
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x21b0
pushq $0x1
popq %rdi
callq 0x2200
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/client.cpp
// Function: check_channel_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool check_channel_name(string name){
    if(name.size() == 0 or name.size() > 200) return false;
    if(name[0] != '#' and name[0] != '&') return false;
    if(name.find(' ') != name.npos) return false;
    if(name.find(',') != name.npos) return false;
    if(name.find((char)7) != name.npos) return false;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq $-0xc9, %rax
addq 0x8(%rdi), %rax
cmpq $-0xc8, %rax
jb 0x2d3a
movq %rdi, %rbx
movq (%rdi), %rax
movzbl (%rax), %eax
cmpl $0x26, %eax
je 0x2cf7
cmpl $0x23, %eax
jne 0x2d3a
xorl %r14d, %r14d
pushq $0x20
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2220
cmpq $-0x1, %rax
jne 0x2d3d
xorl %r14d, %r14d
pushq $0x2c
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2220
cmpq $-0x1, %rax
jne 0x2d3d
pushq $0x7
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2220
cmpq $-0x1, %rax
sete %r14b
jmp 0x2d3d
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/client.cpp
// Function: check_username(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool check_username(string username) {
    if (username.size() <= 2) return false;
    if (username == "server") return false;

    for (char letter : username) {
        if (!check_letter(letter)) return false;
    }
    return true;
}

// Assembly:
cmpq $0x3, 0x8(%rdi)
jae 0x2da6
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1588(%rip), %rsi      # 0x433e
callq 0x39fd
testb %al, %al
je 0x2dc8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
movabsq $0x4000000000003, %rdi  # imm = 0x4000000000003
cmpq %rsi, %rdx
sete %al
je 0x2dc1
movzbl (%rcx,%rsi), %r8d
movl %r8d, %r9d
andb $-0x21, %r9b
addb $-0x41, %r9b
cmpb $0x1a, %r9b
jb 0x2e09
addl $-0x2d, %r8d
cmpl $0x32, %r8d
ja 0x2dc1
btq %r8, %rdi
jae 0x2dc1
incq %rsi
jmp 0x2ddb
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/client.cpp
// Function: get_nickname[abi:cxx11]()
string get_nickname() {
    string nickname = "";
    cout << "Type your nickname (a-z, A-Z, ., _, -, size > 2): ";
    
    if(!getline(cin, nickname)) {
        cout << "Quitting" << endl;
        exit(0);
    }
    
    // espera nome válido
    while (!check_username(nickname)) {
        cout << "Type a valid username (a-z, A-Z, ., _, -, size > 2): ";
        if(!getline(cin, nickname)) {
           cout << "Quitting" << endl;
           exit(0);
        }
    }

    return nickname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x145b(%rip), %rsi      # 0x4284
leaq -0x29(%rbp), %rdx
callq 0x254a
movq 0x4197(%rip), %rdi      # 0x6fd0
leaq 0x1445(%rip), %rsi      # 0x4285
callq 0x2180
movq 0x4194(%rip), %rdi      # 0x6fe0
movq %rbx, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2ef7
leaq -0x50(%rbp), %r14
leaq 0x1450(%rip), %r12      # 0x42c1
movq 0x4168(%rip), %r13      # 0x6fe0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2d9c
movl %eax, %r15d
movq %r14, %rdi
callq 0x22e8
testb %r15b, %r15b
jne 0x2ee5
movq 0x412e(%rip), %rdi      # 0x6fd0
movq %r12, %rsi
callq 0x2180
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x2e78
movq 0x4106(%rip), %rdi      # 0x6fd0
leaq 0x13e7(%rip), %rsi      # 0x42b8
callq 0x2180
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40d2(%rip), %rdi      # 0x6fd0
leaq 0x13b3(%rip), %rsi      # 0x42b8
callq 0x2180
movq %rax, %rdi
callq 0x20d0
jmp 0x2ede
jmp 0x2f16
movq %rax, %r14
movq %rbx, %rdi
callq 0x22e8
movq %r14, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/davidcairuz[P]network-internet-relay-chat/client.cpp
// Function: client_receive_thread(void*)
void* client_receive_thread(void* arg) {
    string message = "";
    int failed = 0;

    while (!quit) {
        do {
            message = client_socket->Read(client_socket->Get_conn_fd());
            client_socket->Check();
            cout << message << "\n";
            
            if (message == "Too many people here, you are not welcome\n") { // server cheio
                quit = true;
                break;
            } else if (message.empty()) { // checa se houve max_retries erros
                failed++;
                sleep(1);
                
                if (failed >= Socket::max_retries) {
                    cout << "Server is down" << endl;
                    break;
                } else 
                    continue;
            
            } else {
                failed = 0;
            }

            message = "";

        } while (message.size() == Socket::buffer_size && !quit);
    }

    pthread_exit(NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x1321(%rip), %rsi      # 0x4284
leaq -0x48(%rbp), %r14
leaq -0x68(%rbp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x254a
xorl %r12d, %r12d
leaq 0x1377(%rip), %rbx      # 0x42f7
cmpb $0x0, 0x4251(%rip)      # 0x71d8
jne 0x3076
movq 0x424c(%rip), %r13      # 0x71e0
movq %r13, %rdi
callq 0x2b88
movq %r15, %rdi
movq %r13, %rsi
movl %eax, %edx
callq 0x2a06
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x22e8
movq 0x421d(%rip), %rdi      # 0x71e0
callq 0x2b92
movq 0x4001(%rip), %rdi      # 0x6fd0
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
leaq 0x12a2(%rip), %rsi      # 0x4283
callq 0x2180
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39fd
testb %al, %al
jne 0x3047
cmpq $0x0, -0x40(%rbp)
je 0x3010
xorl %r12d, %r12d
movq %r14, %rdi
leaq 0x127b(%rip), %rsi      # 0x4284
callq 0x22c0
jmp 0x3026
pushq $0x1
popq %rdi
callq 0x2120
leal 0x1(%r12), %r13d
cmpl $0x4, %r12d
jge 0x3053
movl %r13d, %r12d
cmpq $0x1000, -0x40(%rbp)    # imm = 0x1000
movb 0x41a4(%rip), %al       # 0x71d8
jne 0x2f80
testb $0x1, %al
je 0x2f8d
jmp 0x2f80
movb $0x1, 0x418a(%rip)      # 0x71d8
jmp 0x2f80
movq 0x3f76(%rip), %rdi      # 0x6fd0
leaq 0x12c1(%rip), %rsi      # 0x4322
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movl %r13d, %r12d
jmp 0x2f80
xorl %edi, %edi
callq 0x2270
jmp 0x3083
jmp 0x3083
jmp 0x3083
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x22e8
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/cimtools[P]yaaclc/src/main.cpp
// Function: main
int main(int argc, char* argv[]){
    cout << "begining" << endl;
    cout << argv[1] << endl;
    
    Analizer_ACL analizer(argv[1]);
    cout << "Object created" << endl;

    cout << analizer.token_vector.size() << endl;
    analizer.lexer();

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq 0x8804(%rip), %r14      # 0xafd8
leaq 0x4829(%rip), %rsi      # 0x7004
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x28b4
leaq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x34bc
leaq -0x38(%rbp), %rdi
callq 0x2110
movq 0x87a8(%rip), %rdi      # 0xafd8
leaq 0x47d6(%rip), %rsi      # 0x700d
callq 0x21d0
movq %rax, %rdi
callq 0x2120
movq -0x60(%rbp), %rsi
subq -0x68(%rbp), %rsi
sarq $0x3, %rsi
movq 0x8781(%rip), %rdi      # 0xafd8
callq 0x2150
movq %rax, %rdi
callq 0x2120
leaq -0x88(%rbp), %rdi
callq 0x38f2
leaq -0x88(%rbp), %rdi
callq 0x2942
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2110
jmp 0x28ac
movq %rax, %rbx
jmp 0x28ac
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x2942
movq %rbx, %rdi
callq 0x2330