LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3330
testq %r14, %r14
je 0x6fdd
movq %r14, %rdi
callq 0x3100
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x32b0
jmp 0x6ff9
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl 0x20(%rdi), %esi
orl $0x1, %esi
callq 0x3440
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x33d0
leaq 0xc0(%rbx), %rdi
movq %rsp, %rsi
callq 0x3140
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7028
callq 0x3220
leaq 0x20(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x705d
callq 0x3220
jmp 0x705d
jmp 0x705a
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6bfc
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdc07(%rip), %al       # 0x155c8
testb %al, %al
je 0x7a0b
leaq 0x30(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xe220
addq $0x38, %r15
cmpq %r15, %rax
je 0x79ed
movq %r12, %rdi
movq %r14, %rsi
callq 0xe1ae
movq %rax, %rsi
jmp 0x79f4
leaq 0xdbbc(%rip), %rsi      # 0x155b0
movq %rbx, %rdi
callq 0x7696
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3500
jmp 0x79c5
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7a9c
movb $0x0, 0x8(%rdi)
jmp 0x7ab2
movq (%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq 0xd51b(%rip), %rdi      # 0x14fc8
callq 0x32b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xd508(%rip), %rdi      # 0x14fc8
popq %rbx
jmp 0x32b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8230
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x8323
movq 0x8(%rsp), %r13
xorl %ebp, %ebp
movsbl (%r13,%rbp), %edi
callq 0x3350
movb %al, (%r13,%rbp)
incq %rbp
cmpq %rbp, %r15
jne 0x830b
leaq 0x7677(%rip), %rcx      # 0xf9a1
leaq 0x8(%rsp), %rdi
movl $0x7, %edx
xorl %esi, %esi
callq 0x3320
testl %eax, %eax
je 0x8350
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3140
jmp 0x838d
leaq 0x28(%rsp), %rdi
movl $0x7, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x3280
addq $0x8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3140
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x838d
callq 0x3220
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x839c
callq 0x3220
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83c8
callq 0x3220
jmp 0x83c8
jmp 0x83c5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x83d7
callq 0x3220
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x1b8, %rsp            # imm = 0x1B8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31b0
movq 0x148(%r14), %r13
addq $0x148, %r14            # imm = 0x148
cmpq %r14, %r13
je 0xced7
leaq 0x40(%rsp), %r15
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r12
cmpb $0x0, 0x150(%r13)
jne 0xcece
leaq 0x10(%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xcf3c
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r15, %rdi
callq 0x32b0
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcece
callq 0x3220
movq (%r13), %r13
cmpq %r14, %r13
jne 0xce95
leaq 0x48(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x33d0
leaq 0x30(%rsp), %rdi
callq 0x31d0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcf0a
movq %rax, %r14
jmp 0xcf21
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xcf21
callq 0x3220
leaq 0x30(%rsp), %rdi
callq 0x31d0
movq %r14, %rdi
callq 0x3480
movq %rax, %rdi
callq 0x6bfc
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x160, %rdi            # imm = 0x160
callq 0xbf26
leaq 0x168(%rbx), %rcx
cmpq %rcx, %rax
je 0xd8d4
movq 0x40(%rax), %rbx
jmp 0xd96c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x22e9(%rip), %rsi      # 0xfbcd
leaq 0x22e5(%rip), %rdx      # 0xfbd0
movq %rsp, %rdi
callq 0x83e0
leaq 0x223d(%rip), %rsi      # 0xfb37
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xb99a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0xbde4
movq (%rbx), %rax
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd93a
callq 0x3220
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd94d
callq 0x3220
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xd95b
callq 0x3220
movb 0x7c1f(%rip), %al       # 0x15580
leaq 0x7aa8(%rip), %rbx      # 0x15410
testb %al, %al
je 0xd979
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x7c00(%rip), %rdi      # 0x15580
callq 0x34a0
testl %eax, %eax
je 0xd96c
leaq 0x7a80(%rip), %rbx      # 0x15410
movq %rbx, %rdi
callq 0x9666
leaq -0x5af9(%rip), %rdi     # 0x7ea6
leaq 0x78da(%rip), %rdx      # 0x15280
movq %rbx, %rsi
callq 0x3210
leaq 0x7bcb(%rip), %rdi      # 0x15580
callq 0x3170
jmp 0xd96c
movq %rax, %rbx
leaq 0x7bba(%rip), %rdi      # 0x15580
callq 0x3160
jmp 0xda13
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd9e8
callq 0x3220
jmp 0xd9e8
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda00
callq 0x3220
jmp 0xda00
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xda13
callq 0x3220
jmp 0xda13
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %ebx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
leaq 0x8(%rdi), %rax
movq %rax, -0x48(%rbp)
leaq 0x18(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
addq $0x48, %rdi
movq %rdi, -0x40(%rbp)
movq %r12, -0x50(%rbp)
callq 0x24fc
movb $0x0, 0x74(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x20e0
movl %ebx, (%r14)
movq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x20e0
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2050
movl %eax, 0x98(%r14)
movl %eax, 0x70(%r14)
cmpl $-0x1, %eax
jne 0x27a7
movq -0x40(%rbp), %rdi
callq 0x2526
leaq -0x60(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x28d2(%rip), %rsi      # 0x5047
leaq 0x28e7(%rip), %rdx      # 0x5063
leaq -0x70(%rbp), %rdi
callq 0x261e
leaq -0x70(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2544
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x27a7
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
movq $0x0, 0x78(%r14)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq -0x70(%rbp), %rdi
cmpq %rbx, %rdi
je 0x27e2
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21c0
jmp 0x27e2
jmp 0x27df
movq %rax, %r12
jmp 0x27fa
movq %rax, %r12
movq 0x50(%r14), %rdi
addq $0x60, %r14
cmpq %r14, %rdi
je 0x27fa
movq (%r14), %rsi
incq %rsi
callq 0x21c0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0x2816
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x2832
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %r12, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x98(%rdi), %edi
callq 0x22e0
cmpl $-0x1, %eax
jne 0x2914
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2526
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x27ed(%rip), %rsi      # 0x50ce
leaq 0x2801(%rip), %rdx      # 0x50e9
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x261e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2544
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2914
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2937
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %rsi
movw $0x2, 0x78(%rdi)
movl $0x0, 0x7c(%rdi)
movzwl (%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x7a(%rdi)
movl 0x98(%rdi), %edi
movl $0x10, %edx
callq 0x2040
cmpl $-0x1, %eax
jne 0x29cf
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2526
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x26c8(%rip), %rsi      # 0x5064
leaq 0x26e4(%rip), %rdx      # 0x5087
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x261e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2544
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29cf
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x29f2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x78(%rdi), %r14
movw $0x2, 0x78(%rdi)
movq 0x8(%rdi), %rdi
callq 0x21b0
movl %eax, 0x7c(%rbx)
movzwl (%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x7a(%rbx)
movl 0x98(%rbx), %edi
movq %r14, %rsi
movl $0x10, %edx
callq 0x2150
cmpl $-0x1, %eax
je 0x2a5f
movb $0x1, 0x74(%rbx)
jmp 0x2aad
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2526
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x260e(%rip), %rsi      # 0x5088
leaq 0x262c(%rip), %rdx      # 0x50ad
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x261e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2544
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2aad
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x2ad0
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x28(%rbp), %rdx
movl $0x10, (%rdx)
movl 0x98(%rsi), %edi
leaq -0x58(%rbp), %rsi
callq 0x2080
cmpl $-0x1, %eax
je 0x2b42
movl %eax, %r15d
movl %eax, 0x70(%r14)
leaq -0x58(%rbp), %r14
leaq -0x28(%rbp), %rdx
movl %eax, %edi
movq %r14, %rsi
callq 0x2120
movl 0x4(%r14), %edi
callq 0x20c0
movl %r15d, (%rbx)
leaq 0x8(%rbx), %rdi
leaq -0x21(%rbp), %rdx
movq %rax, %rsi
callq 0x2e94
jmp 0x2bb2
addq $0x48, %r14
movq %r14, %rdi
callq 0x2526
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x2550(%rip), %rsi      # 0x50ae
leaq 0x2568(%rip), %rdx      # 0x50cd
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x261e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2544
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2b91
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movl $0xffffffff, (%rbx)     # imm = 0xFFFFFFFF
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
leaq 0x26da(%rip), %rdx      # 0x5284
movq %rdx, %rsi
callq 0x261e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2bda
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2250
cmpl $-0x1, %eax
jne 0x2c77
addq $0x48, %r14
movq %r14, %rdi
callq 0x2526
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x24a6(%rip), %rsi      # 0x50ea
leaq 0x24b4(%rip), %rdx      # 0x50ff
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x261e
movq %r14, %rdi
movq %r15, %rsi
callq 0x2544
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2c77
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x1050(%rbp), %r14
movq %r14, %rdi
callq 0x20b0
leaq (%rax,%rbp), %rdx
addq $-0x1050, %rdx          # imm = 0xEFB0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x261e
movq %rbx, %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2cce
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cfa
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 0x2180
movl $0x1001, %edx           # imm = 0x1001
movl %r14d, %edi
movq %r12, %rsi
callq 0x2090
movq %rax, %r14
testl %r14d, %r14d
jg 0x2d82
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x2526
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x23b1(%rip), %rsi      # 0x5100
leaq 0x23c0(%rip), %rdx      # 0x5116
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x261e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2544
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2d82
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movl %r14d, %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2dad
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x253a
testl %eax, %eax
jne 0x2df9
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2552
movq 0x51c1(%rip), %rdi      # 0x7fd0
movq %r15, %rsi
callq 0x2170
leaq -0x38(%rbp), %rdi
callq 0x22f8
movq %rbx, %rdi
callq 0x283a
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x21c0
movl $0x1, %edi
callq 0x2220
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e5b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f93
movq %rdi, %rbx
movq (%rdi), %rax
movzbl (%rax), %eax
cmpl $0x26, %eax
je 0x2f4a
cmpl $0x23, %eax
jne 0x2f93
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2240
cmpq $-0x1, %rax
jne 0x2f96
xorl %r14d, %r14d
movq %rbx, %rdi
movl $0x2c, %esi
xorl %edx, %edx
callq 0x2240
cmpq $-0x1, %rax
jne 0x2f96
movq %rbx, %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2240
cmpq $-0x1, %rax
sete %r14b
jmp 0x2f96
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3009
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2325(%rip), %rsi      # 0x533e
callq 0x2070
testl %eax, %eax
je 0x3068
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x3064
movq (%rbx), %rdx
xorl %esi, %esi
movabsq $0x4000000000003, %rdi  # imm = 0x4000000000003
movzbl (%rdx,%rsi), %r8d
movl %r8d, %eax
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x1a, %al
jb 0x305c
xorl %eax, %eax
addl $-0x2d, %r8d
cmpl $0x32, %r8d
ja 0x306a
btq %r8, %rdi
jae 0x306a
incq %rsi
cmpq %rsi, %rcx
jne 0x303a
movb $0x1, %al
jmp 0x306a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x21ed(%rip), %rdx      # 0x5284
movq %rdx, %rsi
callq 0x261e
movq 0x4f2a(%rip), %rdi      # 0x7fd0
leaq 0x21d8(%rip), %rsi      # 0x5285
movl $0x32, %edx
callq 0x21f0
movq 0x4f22(%rip), %rdi      # 0x7fe0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq 0x4f07(%rip), %r14      # 0x7fe0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x31c2
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq %r13, -0x50(%rbp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x2580
movq %r15, %rdi
callq 0x2fff
movl %eax, %r12d
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x3134
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21c0
testb %r12b, %r12b
jne 0x31b0
movl $0x35, %edx
movq 0x4e8b(%rip), %rdi      # 0x7fd0
leaq 0x2175(%rip), %rsi      # 0x52c1
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x30fe
movq 0x4e44(%rip), %rdi      # 0x7fd0
leaq 0x2125(%rip), %rsi      # 0x52b8
movl $0x8, %edx
callq 0x21f0
movq 0x4e2c(%rip), %rdi      # 0x7fd0
callq 0x20d0
xorl %edi, %edi
callq 0x2220
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4e07(%rip), %rdi      # 0x7fd0
leaq 0x20e8(%rip), %rsi      # 0x52b8
movl $0x8, %edx
callq 0x21f0
movq 0x4def(%rip), %rdi      # 0x7fd0
callq 0x20d0
jmp 0x31a9
jmp 0x31ea
movq %rax, %r14
movq (%rbx), %rdi
movq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x3204
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x2034(%rip), %rdx      # 0x5284
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x261e
cmpb $0x0, 0x4f7d(%rip)      # 0x81e0
je 0x326c
xorl %edi, %edi
callq 0x2290
xorl %r13d, %r13d
leaq -0x68(%rbp), %rbx
leaq -0x48(%rbp), %r14
movq 0x4d52(%rip), %r15      # 0x7fd0
movq 0x4f63(%rip), %r12      # 0x81e8
movq %r12, %rdi
callq 0x2dc4
movq %rbx, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x2be2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2230
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x32be
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21c0
movq 0x4f23(%rip), %rdi      # 0x81e8
callq 0x2dce
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x21f0
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1f9a(%rip), %rsi      # 0x5283
callq 0x21f0
movq %r14, %rdi
leaq 0x1fff(%rip), %rsi      # 0x52f7
callq 0x2070
testl %eax, %eax
je 0x33ad
movq -0x40(%rbp), %rdx
testq %rdx, %rdx
je 0x3327
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x1f67(%rip), %rcx      # 0x5284
xorl %r8d, %r8d
callq 0x2270
jmp 0x337e
movl $0x1, %edi
callq 0x2130
leal 0x1(%r13), %r12d
cmpl $0x4, %r13d
jl 0x337e
movl $0xe, %edx
movq %r15, %rdi
leaq 0x1fd8(%rip), %rsi      # 0x5322
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movb 0x4e64(%rip), %al       # 0x81e0
jmp 0x339d
cmpq $0x1000, -0x40(%rbp)    # imm = 0x1000
setne %cl
movb 0x4e51(%rip), %al       # 0x81e0
orb %al, %cl
movl %r12d, %r13d
testb $0x1, %cl
je 0x327e
movl %r12d, %r13d
testb $0x1, %al
je 0x327e
jmp 0x3265
movb $0x1, 0x4e2c(%rip)      # 0x81e0
jmp 0x3265
jmp 0x33bf
jmp 0x33bf
jmp 0x33bf
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x33db
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movl $0x0, 0x40(%rdi)
movl $0x208, %edi            # imm = 0x208
callq 0x21c0
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x22e0
movq %r15, 0x48(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %r14
addq $0x8, %rax
movl $0x0, 0x8(%r14)
xorl %ecx, %ecx
movq %rcx, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rcx, 0x28(%r14)
movl $0x18, %edi
callq 0x21c0
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2050
incq 0x10(%rbx)
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0x30be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %r15, %rdi
callq 0x21d0
jmp 0x383d
jmp 0x383a
movq %rax, %r14
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3852
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21d0
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x386f
movq (%rdi), %r15
movl $0x18, %esi
callq 0x21d0
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x385a
movq %r14, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x38(%rdi), %r15
movq (%rsi), %rbx
movq 0x8(%rsi), %rax
movq %rax, -0x58(%rbp)
cmpq %rax, %rbx
je 0x3975
movq %rdi, -0x50(%rbp)
xorl %r12d, %r12d
leaq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rbx,%r12,4), %rsi
movq 0x8(%rbx,%r12,4), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x2f1c
movq -0x40(%rbp), %rdx
testq %rdx, %rdx
je 0x398a
movq %r15, %r14
movq (%r15,%r12), %r13
movq -0x48(%rbp), %r15
cmpb $0x5f, (%r15)
jne 0x390c
movl $0x1, %edx
leaq -0x48(%rbp), %rdi
xorl %esi, %esi
callq 0x2080
movq 0x8(%r13), %rdx
cmpq -0x40(%rbp), %rdx
jne 0x3926
movq -0x48(%rbp), %r15
testq %rdx, %rdx
je 0x3965
movq (%r13), %rdi
jmp 0x3916
cmpq %rdx, 0x28(%r13)
jne 0x392a
movq 0x20(%r13), %rdi
movq %r15, %rsi
callq 0x21e0
testl %eax, %eax
sete %r13b
jmp 0x392d
movq -0x48(%rbp), %r15
xorl %r13d, %r13d
leaq -0x38(%rbp), %rax
cmpq %rax, %r15
je 0x3945
movq -0x38(%rbp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x21d0
testb %r13b, %r13b
je 0x396a
leaq (%rbx,%r12,4), %rax
addq $0x8, %r12
addq $0x20, %rax
cmpq -0x58(%rbp), %rax
movq %r14, %r15
jne 0x38a8
jmp 0x396e
movb $0x1, %r13b
jmp 0x392d
xorl %eax, %eax
jmp 0x397b
addq %r12, %r15
movq -0x50(%rbp), %rdi
movq %r15, 0x38(%rdi)
movb $0x1, %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x592a(%rip), %rdi      # 0x92bb
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2290
jmp 0x399e
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x39ba
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::search_scopes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Analizer_ACL::search_scopes( string key ){
    string return_value = "__ERRCODE: Couldn't find variable name";

    //First chek if it is on global scope.
    if( (**(scopes.begin())).count(key) ){
        return_value = (**(scopes.begin()))[key];
    }else{
        for( auto search_iterator = scope_iterator; search_iterator != scopes.begin(); --search_iterator ){
            if( (**search_iterator).count(key) ){//If there is at least one occurence of the key on the current map.
                return_value = (**search_iterator)[key];
                break;//find the value, so break the loop.
            }
        }
    }
    if( return_value == "__ERRCODE: Couldn't find variable name\n"){
        cout << "Couldn't find the variable name.\n";
        return "__ERR";
    }

    return return_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x5664(%rip), %rsi      # 0x904f
leaq 0x5683(%rip), %rdx      # 0x9075
leaq -0x48(%rbp), %rdi
callq 0x2baa
movq (%r15), %rax
movq 0x10(%rax), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7884
addq $0x8, %r12
cmpq %r12, %rax
je 0x3a6d
movq (%r15), %rax
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x75ca
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2120
leaq 0x563e(%rip), %rsi      # 0x9076
leaq -0x48(%rbp), %rdi
callq 0x20b0
testl %eax, %eax
je 0x3a99
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x48(%rbp), %rcx
leaq -0x38(%rbp), %rdx
cmpq %rdx, %rcx
je 0x3ae9
movq %rcx, (%rbx)
movq -0x38(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0x3aef
movq 0x18(%r15), %r13
cmpq %r13, (%r15)
je 0x3a31
movq 0x10(%r13), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x7884
addq $0x8, %r12
cmpq %r12, %rax
jne 0x3b09
movq 0x8(%r13), %r13
cmpq (%r15), %r13
jne 0x3a76
jmp 0x3a31
movq 0x8538(%rip), %rdi      # 0xbfd8
leaq 0x55f7(%rip), %rsi      # 0x909e
movl $0x21, %edx
leaq -0x38(%rbp), %r14
callq 0x2210
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x55fd(%rip), %rsi      # 0x90c0
leaq 0x55fb(%rip), %rdx      # 0x90c5
movq %rbx, %rdi
callq 0x2baa
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x3af7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
jmp 0x3af7
movups (%rdx), %xmm0
movups %xmm0, (%rax)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r13), %rdi
movq %r14, %rsi
callq 0x75ca
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x2120
jmp 0x3a31
jmp 0x3b30
jmp 0x3b30
jmp 0x3b30
jmp 0x3b30
jmp 0x3b30
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3b4c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/cimtools[P]yaaclc/src/Analizer_ACL.cpp
// Function: Analizer_ACL::skip_block()
void Analizer_ACL::skip_block(){
    int scope_level = 0;
    do{

        ++token_iterator; //start analizing the next token.
        #ifdef DEBUGGING2
        cout << "skip_block: Token being analized is   " << (*token_iterator)->content << "      From type        " << (*token_iterator)->type << "       scope_level has value     "<< scope_level  <<endl;
        #endif
        if((*token_iterator)->type == "END"){
            cout << "SKIPING IF BLOCK ERROR: coudn`t find the end of if block\n";
            break;
        }else if( (*token_iterator)->content == "if" ){
            ++scope_level;
        }else if( (*token_iterator)->content == "endif" ){
            --scope_level;
        }

    }while( !(  ( (*token_iterator)->content == "else" && scope_level == 0 )   ||  ( (*token_iterator)->content != "endif" && scope_level == -1 ) ) );
    ++token_iterator;//The token skiped was a else to run instead of an if, or it was the endif in case the if didn`t had an else.

    #ifdef DEBUGGING2
    cout << "skip_block: When exiting the function the current token is   " << (*token_iterator)->content << "      From type        " << (*token_iterator)->type << endl;
    #endif
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
leaq 0x549b(%rip), %r14      # 0x90c6
leaq 0x560d(%rip), %r12      # 0x923f
leaq 0x5643(%rip), %r13      # 0x927c
movq 0x38(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x38(%rbx)
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x20b0
testl %eax, %eax
je 0x3cca
movq 0x38(%rbx), %rax
movq (%rax), %rdi
leaq 0x554c(%rip), %rsi      # 0x91b3
callq 0x20b0
testl %eax, %eax
je 0x3c8b
movq 0x38(%rbx), %rax
movq (%rax), %rdi
movq %r13, %rsi
callq 0x20b0
cmpl $0x1, %eax
movl $0x0, %eax
sbbl %eax, %eax
jmp 0x3c90
movl $0x1, %eax
addl %eax, %r15d
movq 0x38(%rbx), %rax
movq (%rax), %rdi
movq %r12, %rsi
callq 0x20b0
orl %r15d, %eax
je 0x3ce2
movq 0x38(%rbx), %rax
movq (%rax), %rdi
movq %r13, %rsi
callq 0x20b0
testl %eax, %eax
je 0x3c39
cmpl $-0x1, %r15d
jne 0x3c39
jmp 0x3ce2
movq 0x8307(%rip), %rdi      # 0xbfd8
leaq 0x53f2(%rip), %rsi      # 0x90ca
movl $0x39, %edx
callq 0x2210
addq $0x8, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/7bao[P]TarEverything/tareverything.cpp
// Function: main
int main(int argc ,char **argv){
    string arg_1;
    string arg_2;
    Tareverything tar;
    switch(argc){
        case tar.sing_suff:
            arg_1 = argv[1];
            tar.write_para(arg_1); 
            cout << tar.command << endl;
            tar.tar_command(tar.command);
            break;
        case tar.doub_suff:
            arg_1 = argv[1];
            arg_2 = argv[2];
            tar.write_para(arg_1,arg_2); 
            cout << tar.command << endl;
            tar.tar_command(tar.command);
            break;
        default:
            cout << "No such file or dirctory" << endl;     
            exit(1);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
cmpl $0x3, %edi
je 0x3737
cmpl $0x2, %edi
jne 0x3833
movq 0x8(%rbx), %rbx
movq %rbx, %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
callq 0x22b0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2484
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x58c2(%rip), %rdi      # 0x8fd8
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
jmp 0x37c0
movq 0x8(%rbx), %r14
movq %r14, %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x22b0
movq 0x10(%rbx), %rbx
leaq 0x48(%rsp), %r14
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x22b0
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x2b06
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5834(%rip), %rdi      # 0x8fd8
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2130
movq 0x8(%rsp), %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x37f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x380b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3822
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x579e(%rip), %rdi      # 0x8fd8
leaq 0x2875(%rip), %rsi      # 0x60b6
movl $0x18, %edx
callq 0x2220
movq 0x5786(%rip), %rdi      # 0x8fd8
callq 0x2100
movl $0x1, %edi
callq 0x2240
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x387b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x3892
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21e0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x38a9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Train_PTransE-pos.cpp
// Function: main
int main(int argc,char**argv)
{
    //随机数种子
    srand((unsigned) time(NULL));
    if (argc!=2)
        return 0;
    else
    {
        version = argv[1];
        positive_margin = atof(version.c_str());
        prepare();
        train.run();
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
xorl %edi, %edi
callq 0x2190
movl %eax, %edi
callq 0x21b0
cmpl $0x2, %ebp
jne 0x474a
movq 0x8(%rbx), %rbx
movq 0xac0d(%rip), %r14      # 0xf310
leaq 0xabfe(%rip), %r15      # 0xf308
movq %rbx, %rdi
callq 0x20d0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x22b0
movq 0xabdc(%rip), %rdi      # 0xf308
callq 0x2250
movsd %xmm0, 0xabef(%rip)     # 0xf328
callq 0x29fa
leaq 0x540ab(%rip), %rdi     # 0x587f0
callq 0x4cd8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Train_PTransE-pos.cpp
// Function: Train::add(int, int, int, std::vector<std::pair<std::vector<int, std::allocator<int>>, double>, std::allocator<std::pair<std::vector<int, std::allocator<int>>, double>>>)
void add(int x,int y,int z, vector<pair<vector<int>,double> > path_list)
    {
        fb_h.push_back(x);
        fb_r.push_back(z);
        fb_l.push_back(y);
        // 保存该三元组对应的所有路径
		fb_path.push_back(path_list);
        ok[make_pair(x,z)][y]=1;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movl %ecx, %r15d
movl %edx, %ebp
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl %ecx, 0x4(%rsp)
movq 0x70(%rdi), %rsi
cmpq 0x78(%rdi), %rsi
je 0x4ab7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x70(%rbx)
jmp 0x4ac5
leaq 0x68(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x939e
movq 0xa0(%rbx), %rsi
cmpq 0xa8(%rbx), %rsi
je 0x4ae5
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xa0(%rbx)
jmp 0x4af6
leaq 0x98(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x939e
movq 0x88(%rbx), %rsi
cmpq 0x90(%rbx), %rsi
je 0x4b15
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x88(%rbx)
jmp 0x4b26
leaq 0x80(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x939e
leaq 0xb0(%rbx), %rdi
movq %r14, %rsi
callq 0x5654
movl 0xc(%rsp), %eax
movl 0x4(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %rbx, %rdi
callq 0x5680
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x570a
movl $0x1, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Train_PTransE-pos.cpp
// Function: Train::norm(std::vector<double, std::allocator<double>>&)
double norm(vector<double> &a)
    {
        double x = vec_len(a);
        if (x>1)
        for (int ii=0; ii<a.size(); ii++)
                a[ii]/=x;
        return 0;
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x5ef3
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x5ede
ucomisd %xmm1, %xmm0
jb 0x5eff
sqrtsd %xmm0, %xmm0
jmp 0x5f04
callq 0x2160
ucomisd 0x510c(%rip), %xmm0     # 0xb018
jbe 0x5f3e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
je 0x5f3e
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x5f28
xorpd %xmm0, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/IdelCoder[P]PTransE-ag/Train_PTransE-pos.cpp
// Function: Train::train_kb(int, int, int, int, int, int, double)
void train_kb(int e1_a,int e2_a,int rel_a,int e1_b,int e2_b,int rel_b,double margin)
    {
        double sum1 = calc_kb(e1_a,e2_a,rel_a);
        double sum2 = calc_kb(e1_b,e2_b,rel_b);
        if (sum1+margin>sum2)
        {
            // 两者的差距在marign之内，才计算损失函数，调整参数
        	res+=margin+sum1-sum2;
        	gradient_kb(e1_a, e2_a, rel_a, -1);
			gradient_kb(e1_b, e2_b, rel_b, 1);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movl %r9d, %ebp
movl %r8d, %r14d
movl %edx, %r13d
movl %esi, %ebx
movq %rdi, %r15
movl 0x60(%rsp), %r12d
movl %ecx, 0xc(%rsp)
callq 0x8804
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
movl %r14d, 0x10(%rsp)
movl %r14d, %esi
movl %ebp, 0x14(%rsp)
movl %ebp, %edx
movl %r12d, %ecx
callq 0x8804
movsd 0x18(%rsp), %xmm1
addsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x81dd
subsd %xmm0, %xmm1
addsd 0x38(%r15), %xmm1
movsd %xmm1, 0x38(%r15)
movsd 0x2ead(%rip), %xmm0     # 0xb050
movq %r15, %rdi
movl %ebx, %esi
movl %r13d, %edx
movl 0xc(%rsp), %ecx
callq 0x8884
movsd 0x2e5c(%rip), %xmm0     # 0xb018
movq %r15, %rdi
movl 0x10(%rsp), %esi
movl 0x14(%rsp), %edx
movl %r12d, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8884
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq