LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4430
movq 0x8(%rsp), %rdi
movq 0x1b8(%rsp), %rsi
callq 0x4330
jmp 0xd486
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4350
jmp 0xd497
movq (%rsp), %rdi
addq $0xc0, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4040
jmp 0xd4ae
leaq 0x10(%rsp), %rdi
callq 0x4618
jmp 0xd4ba
leaq 0x40(%rsp), %rdi
callq 0x40b0
movq (%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xd4fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x4618
jmp 0xd4fa
jmp 0xd4fc
leaq 0x40(%rsp), %rdi
callq 0x40b0
jmp 0xd508
jmp 0xd50a
movq 0x38(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0x1f227(%rip)     # 0x2d658
jne 0xe478
leaq 0x1f21e(%rip), %rdi     # 0x2d658
callq 0x45a0
cmpl $0x0, %eax
je 0xe478
leaq 0x1f1f5(%rip), %rdi     # 0x2d640
callq 0xe930
jmp 0xe452
leaq 0x1f7(%rip), %rdi       # 0xe650
leaq 0x1f1e0(%rip), %rsi     # 0x2d640
leaq 0x1eea9(%rip), %rdx     # 0x2d310
callq 0x42e0
leaq 0x1f1e5(%rip), %rdi     # 0x2d658
callq 0x4220
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x40(%rsp), %rsi
callq 0x20620
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
callq 0x20650
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x20600
testb $0x1, %al
jne 0xe4b8
jmp 0xe4c5
leaq 0x1f181(%rip), %rax     # 0x2d640
movq %rax, (%rsp)
jmp 0xe4dc
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq 0x40(%rsp), %rsi
callq 0x20680
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xddb0
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x1f14f(%rip), %rdi     # 0x2d658
callq 0x4210
movq 0x38(%rsp), %rdi
callq 0x4570
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x8(%rax)
je 0xe737
movq (%rsp), %rax
movb $0x0, 0x8(%rax)
jmp 0xe74a
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x1e863(%rip), %rdi     # 0x2cfa8
callq 0x42f0
movq 0x8(%rsp), %rsi
movq 0x1e852(%rip), %rdi     # 0x2cfa8
callq 0x42f0
addq $0x18, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4130
movq 0x28(%rsp), %rdi
callq 0x42c0
movq %rax, 0x30(%rsp)
jmp 0x10abf
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x41d0
movq %rax, 0x18(%rsp)
jmp 0x10ae0
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x42c0
movq %rax, 0x10(%rsp)
jmp 0x10afe
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x80(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x1c48f(%rip), %rcx     # 0x2cfb0
callq 0x10c30
movq %rax, 0x8(%rsp)
jmp 0x10b2d
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x10df2(%rip), %rcx     # 0x21930
xorl %eax, %eax
movl %eax, %esi
leaq 0x88(%rsp), %rdi
movl $0x7, %edx
callq 0x4420
movl %eax, 0x4(%rsp)
jmp 0x10b5a
movl 0x4(%rsp), %eax
cmpl $0x0, %eax
jne 0x10bd2
movq 0xa8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x7, %edx
movq $-0x1, %rcx
callq 0x4360
jmp 0x10b83
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
leaq 0x38(%rsp), %rsi
callq 0x4040
jmp 0x10b98
leaq 0x38(%rsp), %rdi
callq 0x4618
jmp 0x10ba4
jmp 0x10bec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x10c01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4618
jmp 0x10bd0
jmp 0x10c01
movq 0x20(%rsp), %rdi
movq 0xa8(%rsp), %rsi
addq $0x8, %rdi
callq 0x4040
jmp 0x10bea
jmp 0x10bec
leaq 0x88(%rsp), %rdi
callq 0x4618
addq $0xb8, %rsp
retq
leaq 0x88(%rsp), %rdi
callq 0x4618
jmp 0x10c10
jmp 0x10c12
movq 0x78(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopw %cs:(%rax,%rax)
nop
// File: myint[P]optparse/./optparse.h
// Function: optparse::Option::nargs(unsigned long)
Option &nargs(size_t n)
        {
            // This doesn't seem to be currently supported.
            if (n > 1)
            {
                throw std::invalid_argument(
                    "nargs greater than 1 not supported");
            }

            _nargs = n;
            return *this;
        }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x1, 0x58(%rsp)
jbe 0x1727a
movb $0x1, 0x23(%rsp)
movl $0x10, %edi
callq 0x4180
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4580
movq 0x10(%rsp), %rdx
leaq 0xa778(%rip), %rsi      # 0x2196b
leaq 0x38(%rsp), %rdi
callq 0x4450
jmp 0x171ff
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4560
jmp 0x17210
movq 0x8(%rsp), %rdi
movb $0x0, 0x23(%rsp)
movq 0x15da7(%rip), %rsi     # 0x2cfc8
movq 0x15d90(%rip), %rdx     # 0x2cfb8
callq 0x4530
jmp 0x172a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1725b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4618
jmp 0x17259
jmp 0x1725b
leaq 0x37(%rsp), %rdi
callq 0x4390
testb $0x1, 0x23(%rsp)
jne 0x1726e
jmp 0x17278
movq 0x8(%rsp), %rdi
callq 0x4270
jmp 0x17290
movq 0x18(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0xe0(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq 0x15ca1(%rip), %rdi     # 0x2cfa8
leaq 0xa680(%rip), %rsi      # 0x2198e
callq 0x4330
movq %rax, %rdi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x4550
movq %rax, %rdi
leaq 0xa675(%rip), %rsi      # 0x219a2
callq 0x4330
movq %rax, %rdi
movq 0x15c54(%rip), %rsi     # 0x2cf90
callq 0x4380
movq 0x15c60(%rip), %rdi     # 0x2cfa8
leaq 0xa661(%rip), %rsi      # 0x219b0
callq 0x4330
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x174b0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x42f0
movq %rax, %rdi
movq 0x15c16(%rip), %rsi     # 0x2cf90
callq 0x4380
movq 0x15c22(%rip), %rdi     # 0x2cfa8
leaq 0xa648(%rip), %rsi      # 0x219d5
callq 0x4330
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x42f0
movq %rax, %rdi
movq 0x15be7(%rip), %rsi     # 0x2cf90
callq 0x4380
movq 0x15bf3(%rip), %rdi     # 0x2cfa8
leaq 0xa632(%rip), %rsi      # 0x219ee
callq 0x4330
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x42f0
movq %rax, %rdi
movq 0x15bb8(%rip), %rsi     # 0x2cf90
callq 0x4380
movq 0x15bc4(%rip), %rdi     # 0x2cfa8
leaq 0xa61c(%rip), %rsi      # 0x21a07
callq 0x4330
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x10a60
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x42f0
movq %rax, %rdi
movq 0x15b7a(%rip), %rsi     # 0x2cf90
callq 0x4380
movq 0x15b86(%rip), %rdi     # 0x2cfa8
movq 0x15b67(%rip), %rsi     # 0x2cf90
callq 0x4380
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movl %edx, 0x214(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4260
movq 0x40(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x15700
testb $0x1, %al
jne 0x1d59c
jmp 0x1d5d3
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x4320
jmp 0x1d5b0
movl $0x1, 0x78(%rsp)
jmp 0x1d6ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x1d709
movq 0x40(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x12200
movq %rax, 0x28(%rsp)
jmp 0x1d5eb
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x40(%rsp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x12230
movq %rax, 0x20(%rsp)
jmp 0x1d60d
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x12300
testb $0x1, %al
jne 0x1d62f
jmp 0x1d6d3
leaq 0x70(%rsp), %rdi
callq 0x18f20
movq %rax, 0x18(%rsp)
jmp 0x1d640
movq 0x18(%rsp), %rax
testb $0x1, 0x140(%rax)
jne 0x1d6c2
leaq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x18f20
movq %rax, 0x10(%rsp)
jmp 0x1d66c
movq 0x10(%rsp), %rsi
movl 0x214(%rsp), %edx
leaq 0x48(%rsp), %rdi
callq 0x1d800
jmp 0x1d684
movq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x42f0
jmp 0x1d695
leaq 0x48(%rsp), %rdi
callq 0x4618
jmp 0x1d6a1
jmp 0x1d6c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x4618
jmp 0x1d6c0
jmp 0x1d709
jmp 0x1d6c4
leaq 0x70(%rsp), %rdi
callq 0x12380
jmp 0x1d5f5
movq 0x30(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x4320
jmp 0x1d6e7
movl $0x1, 0x78(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4290
movq 0x38(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
leaq 0x88(%rsp), %rdi
callq 0x4290
jmp 0x1d718
jmp 0x1d71a
movq 0x80(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nop
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x160, %rdi            # imm = 0x160
movq 0xa0(%rsp), %rsi
callq 0x1aca0
movq 0x10(%rsp), %rdi
movq %rax, 0x98(%rsp)
addq $0x160, %rdi            # imm = 0x160
callq 0x1ab10
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1b150
testb $0x1, %al
jne 0x1eab7
jmp 0x1ec44
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4580
movq 0x8(%rsp), %rdx
leaq 0x309e(%rip), %rsi      # 0x21b70
leaq 0x30(%rsp), %rdi
callq 0x4450
jmp 0x1eade
leaq 0x2ff5(%rip), %rsi      # 0x21ada
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1a090
jmp 0x1eaf6
movq 0xa0(%rsp), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1aa30
jmp 0x1eb0f
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
leaq 0x70(%rsp), %rsi
callq *%rax
jmp 0x1eb24
leaq 0x70(%rsp), %rdi
callq 0x4618
jmp 0x1eb30
leaq 0x50(%rsp), %rdi
callq 0x4618
jmp 0x1eb3c
leaq 0x30(%rsp), %rdi
callq 0x4618
jmp 0x1eb48
leaq 0x2f(%rsp), %rdi
callq 0x4390
cmpb $0x0, 0xeab7(%rip)      # 0x2d610
jne 0x1eba0
leaq 0xeaae(%rip), %rdi      # 0x2d610
callq 0x45a0
cmpl $0x0, %eax
je 0x1eba0
leaq 0xe92d(%rip), %rdi      # 0x2d4a0
callq 0x14ba0
jmp 0x1eb7a
leaq -0xe991(%rip), %rdi     # 0x101f0
leaq 0xe918(%rip), %rsi      # 0x2d4a0
leaq 0xe781(%rip), %rdx      # 0x2d310
callq 0x42e0
leaq 0xea75(%rip), %rdi      # 0x2d610
callq 0x4220
leaq 0xe8f9(%rip), %rax      # 0x2d4a0
movq %rax, 0xb0(%rsp)
jmp 0x1ec5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1ec1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1ec0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x1ec00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x4618
jmp 0x1ebfe
jmp 0x1ec00
leaq 0x50(%rsp), %rdi
callq 0x4618
jmp 0x1ec0c
jmp 0x1ec0e
leaq 0x30(%rsp), %rdi
callq 0x4618
jmp 0x1ec1a
jmp 0x1ec1c
leaq 0x2f(%rsp), %rdi
callq 0x4390
jmp 0x1ec6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0xe9d3(%rip), %rdi      # 0x2d610
callq 0x4210
jmp 0x1ec6d
leaq 0x98(%rsp), %rdi
callq 0x1abd0
movq 0x20(%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4570
movq %rax, %rdi
callq 0xcc60
nop
// File: 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
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x8, %rdi
movq %rdi, -0x80(%rbp)
callq 0x2340
movq -0x70(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x78(%rbp)
callq 0x2340
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x68(%rbp)
callq 0x2710
jmp 0x2bf1
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
movb $0x0, 0x74(%rdi)
addq $0x28, %rdi
callq 0x2030
jmp 0x2c0b
movq -0x90(%rbp), %rsi
movq -0x70(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
callq 0x2030
jmp 0x2c26
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, %ecx
movq -0x70(%rbp), %rax
movl %ecx, 0x98(%rax)
movl 0x98(%rax), %ecx
movl %ecx, 0x70(%rax)
cmpl $-0x1, 0x98(%rax)
jne 0x2d10
movq -0x70(%rbp), %rdi
addq $0x48, %rdi
callq 0x2780
jmp 0x2c68
movq -0x70(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xa0(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x23c0
movq -0x98(%rbp), %rdx
leaq 0x33b2(%rip), %rsi      # 0x6047
leaq -0x50(%rbp), %rdi
callq 0x2840
jmp 0x2ca0
movq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x27e0
jmp 0x2cb2
leaq -0x50(%rbp), %rdi
callq 0x2448
leaq -0x51(%rbp), %rdi
callq 0x2290
jmp 0x2d10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2d3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2d05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2448
leaq -0x51(%rbp), %rdi
callq 0x2290
jmp 0x2d34
movq -0x70(%rbp), %rdi
movq $0x8, -0x60(%rbp)
addq $0x78, %rdi
movq -0x60(%rbp), %rdx
xorl %esi, %esi
callq 0x2130
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3690
movq -0x78(%rbp), %rdi
callq 0x2448
movq -0x80(%rbp), %rdi
callq 0x2448
movq -0x28(%rbp), %rdi
callq 0x23a0
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x98(%rax), %edi
callq 0x2410
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x2e61
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2780
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23c0
movq -0x58(%rbp), %rdx
leaq 0x32c9(%rip), %rsi      # 0x60ce
leaq -0x30(%rbp), %rdi
callq 0x2840
jmp 0x2e10
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27e0
jmp 0x2e1f
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x2e61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2e56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x2e67
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23a0
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movw $0x2, 0x78(%rax)
xorl %edi, %edi
callq 0x21a0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl (%rax), %eax
movzwl %ax, %edi
callq 0x2040
movq -0x50(%rbp), %rsi
movw %ax, 0x7a(%rsi)
movl 0x98(%rsi), %edi
addq $0x78, %rsi
movl $0x10, %edx
callq 0x2050
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x2f52
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2780
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23c0
movq -0x58(%rbp), %rdx
leaq 0x316e(%rip), %rsi      # 0x6064
leaq -0x30(%rbp), %rdi
callq 0x2840
jmp 0x2f01
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27e0
jmp 0x2f10
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x2f52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2f47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x2f58
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movw $0x2, 0x78(%rdi)
addq $0x8, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x2240
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x7c(%rax)
movl (%rax), %eax
movzwl %ax, %edi
callq 0x2040
movq -0x50(%rbp), %rsi
movw %ax, 0x7a(%rsi)
movl 0x98(%rsi), %edi
addq $0x78, %rsi
movl $0x10, %edx
callq 0x21c0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x308c
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x2780
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23c0
movq -0x58(%rbp), %rdx
leaq 0x3058(%rip), %rsi      # 0x6088
leaq -0x30(%rbp), %rdi
callq 0x2840
jmp 0x303b
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27e0
jmp 0x304a
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x3094
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3081
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2448
leaq -0x31(%rbp), %rdi
callq 0x2290
jmp 0x309a
movq -0x50(%rbp), %rax
movb $0x1, 0x74(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x10, -0x24(%rbp)
movl 0x98(%rax), %edi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x20b0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x31af
movq -0x78(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x98(%rbp)
callq 0x2780
leaq -0x49(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x23c0
movq -0x90(%rbp), %rdx
leaq 0x2f7c(%rip), %rsi      # 0x60ae
leaq -0x48(%rbp), %rdi
callq 0x2840
jmp 0x313d
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x27e0
jmp 0x314f
leaq -0x48(%rbp), %rdi
callq 0x2448
leaq -0x49(%rbp), %rdi
callq 0x2290
movq -0x88(%rbp), %rdi
movl $0xffffffff, -0x60(%rbp) # imm = 0xFFFFFFFF
leaq -0x60(%rbp), %rsi
leaq 0x310a(%rip), %rdx      # 0x6284
callq 0x36b0
jmp 0x31ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x31a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2448
leaq -0x49(%rbp), %rdi
callq 0x2290
jmp 0x31fc
movq -0x78(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, 0x70(%rax)
movl -0x28(%rbp), %edi
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x2180
movl -0x1c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %edi
callq 0x2110
movq -0x88(%rbp), %rdi
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x3730
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x23a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x1090, %rsp           # imm = 0x1090
movq %rdi, -0x1078(%rbp)
movq %rdi, %rax
movq %rax, -0x1070(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1068(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0x2130
movl -0x14(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1001, %edx           # imm = 0x1001
callq 0x2350
movl %eax, -0x1024(%rbp)
cmpl $-0x1, -0x1024(%rbp)
jne 0x3334
movq -0x1068(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x1088(%rbp)
callq 0x2780
leaq -0x1049(%rbp), %rdi
movq %rdi, -0x1080(%rbp)
callq 0x23c0
movq -0x1080(%rbp), %rdx
leaq 0x2e36(%rip), %rsi      # 0x60ea
leaq -0x1048(%rbp), %rdi
callq 0x2840
jmp 0x32c2
movq -0x1088(%rbp), %rdi
leaq -0x1048(%rbp), %rsi
callq 0x27e0
jmp 0x32d7
leaq -0x1048(%rbp), %rdi
callq 0x2448
leaq -0x1049(%rbp), %rdi
callq 0x2290
jmp 0x3334
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
jmp 0x3323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
leaq -0x1048(%rbp), %rdi
callq 0x2448
leaq -0x1049(%rbp), %rdi
callq 0x2290
jmp 0x33c4
movb $0x0, -0x105d(%rbp)
leaq -0x105e(%rbp), %rdi
movq %rdi, -0x1090(%rbp)
callq 0x23c0
movq -0x1078(%rbp), %rdi
movq -0x1090(%rbp), %rdx
leaq -0x1020(%rbp), %rsi
callq 0x2840
jmp 0x336a
leaq -0x105e(%rbp), %rdi
callq 0x2290
movb $0x1, -0x105d(%rbp)
testb $0x1, -0x105d(%rbp)
jne 0x33b4
jmp 0x33a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
leaq -0x105e(%rbp), %rdi
callq 0x2290
jmp 0x33c4
movq -0x1078(%rbp), %rdi
callq 0x2448
movq -0x1070(%rbp), %rax
addq $0x1090, %rsp           # imm = 0x1090
popq %rbp
retq
movq -0x1058(%rbp), %rdi
callq 0x23a0
// File: 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
subq $0x1090, %rsp           # imm = 0x1090
movq %rsi, -0x1070(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1068(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x340b
movq -0x1068(%rbp), %rax
movl 0x70(%rax), %eax
movl %eax, -0x14(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1001, %edx           # imm = 0x1001
callq 0x2130
movq -0x1070(%rbp), %rdi
leaq -0x1020(%rbp), %rax
movq %rax, -0x1078(%rbp)
callq 0x20e0
movq -0x1078(%rbp), %rdi
movq %rax, %rsi
callq 0x2210
movl -0x14(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1001, %edx           # imm = 0x1001
callq 0x20c0
movl %eax, -0x1024(%rbp)
cmpl $0x1, -0x1024(%rbp)
jge 0x3523
movq -0x1068(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x1088(%rbp)
callq 0x2780
leaq -0x1049(%rbp), %rdi
movq %rdi, -0x1080(%rbp)
callq 0x23c0
movq -0x1080(%rbp), %rdx
leaq 0x2c5a(%rip), %rsi      # 0x6100
leaq -0x1048(%rbp), %rdi
callq 0x2840
jmp 0x34b4
movq -0x1088(%rbp), %rdi
leaq -0x1048(%rbp), %rsi
callq 0x27e0
jmp 0x34c9
leaq -0x1048(%rbp), %rdi
callq 0x2448
leaq -0x1049(%rbp), %rdi
callq 0x2290
jmp 0x3523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
jmp 0x3515
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1058(%rbp)
movl %eax, -0x105c(%rbp)
leaq -0x1048(%rbp), %rdi
callq 0x2448
leaq -0x1049(%rbp), %rdi
callq 0x2290
jmp 0x3532
movl -0x1024(%rbp), %eax
addq $0x1090, %rsp           # imm = 0x1090
popq %rbp
retq
movq -0x1058(%rbp), %rdi
callq 0x23a0
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3630
testb $0x1, %al
jne 0x35b3
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3660
movq -0x48(%rbp), %rsi
movq 0x5a01(%rip), %rdi      # 0x8fd0
callq 0x2200
jmp 0x35d6
leaq -0x28(%rbp), %rdi
callq 0x2448
movq -0x40(%rbp), %rax
cmpq $0x0, %rax
je 0x3600
movq -0x40(%rbp), %rdi
callq 0x2d60
movq -0x40(%rbp), %rdi
movl $0xa0, %esi
callq 0x2250
movl $0x1, %edi
callq 0x22f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2448
movq -0x30(%rbp), %rdi
callq 0x23a0
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2160
cmpq $0x0, %rax
je 0x382c
movq -0x18(%rbp), %rdi
callq 0x2160
cmpq $0xc8, %rax
jbe 0x3835
movb $0x0, -0x1(%rbp)
jmp 0x38c3
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x3865
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movsbl (%rax), %eax
cmpl $0x26, %eax
je 0x3865
movb $0x0, -0x1(%rbp)
jmp 0x38c3
movq -0x18(%rbp), %rdi
movl $0x20, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2320
cmpq $-0x1, %rax
je 0x3883
movb $0x0, -0x1(%rbp)
jmp 0x38c3
movq -0x18(%rbp), %rdi
movl $0x2c, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2320
cmpq $-0x1, %rax
je 0x38a1
movb $0x0, -0x1(%rbp)
jmp 0x38c3
movq -0x18(%rbp), %rdi
movl $0x7, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2320
cmpq $-0x1, %rax
je 0x38bf
movb $0x0, -0x1(%rbp)
jmp 0x38c3
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2160
cmpq $0x2, %rax
ja 0x39d4
movb $0x0, -0x1(%rbp)
jmp 0x3a57
movq -0x38(%rbp), %rdi
leaq 0x295f(%rip), %rsi      # 0x633e
callq 0x5250
testb $0x1, %al
jne 0x39ea
jmp 0x39f0
movb $0x0, -0x1(%rbp)
jmp 0x3a57
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x21e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5280
testb $0x1, %al
jne 0x3a25
jmp 0x3a53
leaq -0x20(%rbp), %rdi
callq 0x52c0
movb (%rax), %al
movb %al, -0x29(%rbp)
movsbl -0x29(%rbp), %edi
callq 0x3940
testb $0x1, %al
jne 0x3a46
movb $0x0, -0x1(%rbp)
jmp 0x3a57
jmp 0x3a48
leaq -0x20(%rbp), %rdi
callq 0x52e0
jmp 0x3a12
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xa(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x23c0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x27da(%rip), %rsi      # 0x6284
callq 0x2840
jmp 0x3ab1
leaq -0xa(%rbp), %rdi
callq 0x2290
movq 0x550f(%rip), %rdi      # 0x8fd0
leaq 0x27bd(%rip), %rsi      # 0x6285
callq 0x2220
jmp 0x3acf
movq -0x50(%rbp), %rsi
movq 0x5506(%rip), %rdi      # 0x8fe0
callq 0x2070
movq %rax, -0x60(%rbp)
jmp 0x3ae5
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2120
movb %al, -0x61(%rbp)
jmp 0x3afd
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3b06
jmp 0x3b63
movq 0x54c3(%rip), %rdi      # 0x8fd0
leaq 0x27a4(%rip), %rsi      # 0x62b8
callq 0x2220
movq %rax, -0x70(%rbp)
jmp 0x3b1f
movq -0x70(%rbp), %rdi
movq 0x548e(%rip), %rsi      # 0x8fb8
callq 0x2270
jmp 0x3b31
xorl %edi, %edi
callq 0x22f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xa(%rbp), %rdi
callq 0x2290
jmp 0x3c6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x3c65
jmp 0x3b65
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x20f0
jmp 0x3b74
leaq -0x40(%rbp), %rdi
callq 0x39b0
movb %al, -0x71(%rbp)
jmp 0x3b82
movb -0x71(%rbp), %al
xorb $-0x1, %al
movb %al, -0x72(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2448
movb -0x72(%rbp), %al
testb $0x1, %al
jne 0x3b9f
jmp 0x3c45
movq 0x542a(%rip), %rdi      # 0x8fd0
leaq 0x2714(%rip), %rsi      # 0x62c1
callq 0x2220
jmp 0x3bb4
movq -0x50(%rbp), %rsi
movq 0x5421(%rip), %rdi      # 0x8fe0
callq 0x2070
movq %rax, -0x80(%rbp)
jmp 0x3bca
movq -0x80(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2120
movb %al, -0x81(%rbp)
jmp 0x3be5
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x3bf1
jmp 0x3c40
movq 0x53d8(%rip), %rdi      # 0x8fd0
leaq 0x26b9(%rip), %rsi      # 0x62b8
callq 0x2220
movq %rax, -0x90(%rbp)
jmp 0x3c0d
movq -0x90(%rbp), %rdi
movq 0x539d(%rip), %rsi      # 0x8fb8
callq 0x2270
jmp 0x3c22
xorl %edi, %edi
callq 0x22f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2448
jmp 0x3c65
jmp 0x3b65
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x3c58
movq -0x50(%rbp), %rdi
callq 0x2448
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x2448
movq -0x18(%rbp), %rdi
callq 0x23a0
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x13098(%rip), %rdi     # 0x16fd8
movq %rdi, -0xb8(%rbp)
leaq 0xd0b6(%rip), %rsi      # 0x11004
callq 0x3250
movq %rax, %rdi
movq 0x1306b(%rip), %rsi     # 0x16fc8
movq %rsi, -0xb0(%rbp)
callq 0x3290
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3250
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
callq 0x3290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3460
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x40e0
jmp 0x3fc7
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x69b0
jmp 0x3fd6
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32b0
movq 0x12fe6(%rip), %rdi     # 0x16fd8
leaq 0xd014(%rip), %rsi      # 0x1100d
callq 0x3250
movq %rax, -0xc0(%rbp)
jmp 0x4007
movq -0xc0(%rbp), %rdi
movq 0x12fb3(%rip), %rsi     # 0x16fc8
callq 0x3290
jmp 0x401c
leaq -0x40(%rbp), %rdi
callq 0x42c0
movq %rax, %rsi
movq 0x12fa9(%rip), %rdi     # 0x16fd8
callq 0x30b0
movq %rax, -0xc8(%rbp)
jmp 0x403d
movq -0xc8(%rbp), %rdi
movq 0x12f7d(%rip), %rsi     # 0x16fc8
callq 0x3290
jmp 0x4052
leaq -0x60(%rbp), %rdi
callq 0x7170
jmp 0x405d
movl $0x0, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x42e0
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x40a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32b0
jmp 0x40d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x42e0
movq -0x90(%rbp), %rdi
callq 0x3450
nopl (%rax)
// File: cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::Analizer_ACL()
Analizer_ACL::Analizer_ACL(){
    myfile = new ifstream( "base.dnl" );
    map<string,string> * global_scope = new map<string,string>;
    scopes.push_back(global_scope);
    scope_iterator = scopes.begin();
    #ifdef DEBUGGING
    cout << "Constructor: start getting tokens" << endl;
    #endif
    get_tokens();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0xc7d0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0xc7f0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0xc810
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xc830
movq -0x38(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x208, %edi            # imm = 0x208
callq 0x3260
movq %rax, -0x30(%rbp)
jmp 0x5cf6
movq -0x30(%rbp), %rdi
leaq 0xb345(%rip), %rsi      # 0x11046
movl $0x8, %edx
callq 0x3480
jmp 0x5d0d
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl $0x30, %edi
callq 0x3260
movq %rax, -0x50(%rbp)
jmp 0x5d29
movq -0x50(%rbp), %rdi
callq 0xc850
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0xc870
jmp 0x5d49
movq -0x48(%rbp), %rdi
callq 0xc8b0
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x5dc0
jmp 0x5d69
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x5d97
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x3270
movq -0x40(%rbp), %rdi
callq 0x4650
movq -0x38(%rbp), %rdi
callq 0x46b0
movq -0x10(%rbp), %rdi
callq 0x3450
nopw %cs:(%rax,%rax)
// File: cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::Analizer_ACL(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Analizer_ACL::Analizer_ACL( string file_path ){
    myfile = new ifstream( file_path );
    map<string,string> * global_scope = new map<string,string>;
    scopes.push_back(global_scope);
    scope_iterator = scopes.begin();
    #ifdef DEBUGGING
    cout << "Constructor: start getting tokens" << endl;
    #endif
    get_tokens();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xc7d0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
callq 0xc7f0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0xc810
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0xc830
movq -0x40(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x208, %edi            # imm = 0x208
callq 0x3260
movq %rax, -0x38(%rbp)
jmp 0x6a1e
movq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rdi
movl $0x8, %edx
callq 0x33e0
jmp 0x6a32
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x48(%rax)
movl $0x30, %edi
callq 0x3260
movq %rax, -0x60(%rbp)
jmp 0x6a4e
movq -0x60(%rbp), %rdi
callq 0xc850
movq -0x60(%rbp), %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xc870
jmp 0x6a6e
movq -0x50(%rbp), %rdi
callq 0xc8b0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, 0x18(%rdi)
callq 0x5dc0
jmp 0x6a8e
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x6abc
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x208, %esi            # imm = 0x208
callq 0x3270
movq -0x48(%rbp), %rdi
callq 0x4650
movq -0x40(%rbp), %rdi
callq 0x46b0
movq -0x18(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::eat_tokens_if_match(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
bool Analizer_ACL::eat_tokens_if_match( vector<string> type_sequence ){
    vector<Token *>::iterator after_state = token_iterator;
    if(equal( type_sequence.begin(), type_sequence.end(), token_iterator, [&](string first, Token * second){
        ++after_state;
        if( first.at(0) == '_'){
            first.erase(0,1);
            return second->content == first;
        }else{
            return second->type == first;
        }
    })){
        token_iterator = after_state;//Eat the tokens.
        return true;
    }else{
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
callq 0xc8e0
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xc910
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x6b80
testb $0x1, %al
jne 0x6b57
jmp 0x6b69
movq -0x48(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x38(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x6b6d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::get_relative_token_content[abi:cxx11](int)
string Analizer_ACL::get_relative_token_content( int relative_position ){
    string content;

    content = (*(token_iterator+relative_position))->content;
    #ifdef DEBUGGING
    cout << "get_relative_token_content:The readed token is " << content << endl;
    #endif
    return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0xcb20
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcb60
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
callq 0x3050
jmp 0x6f3b
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x6f67
jmp 0x6f5e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31a0
jmp 0x6f71
movq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3450
nopw (%rax,%rax)
// File: cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::get_relative_token_type[abi:cxx11](int)
string Analizer_ACL::get_relative_token_type( int relative_position ){
    string type;

    type = (*(token_iterator+relative_position))->type;
    #ifdef DEBUGGING
    cout << "get_relative_token_content:The readed token is " << type << endl;
    #endif
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0xcb20
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcb60
movq -0x38(%rbp), %rdi
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x3050
jmp 0x6fdf
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x700b
jmp 0x7002
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31a0
jmp 0x7015
movq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3450
nop