LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
const Value operator[](const std::string key) const {
            auto mt = object.find(key);
            if (mt != object.end())
                return mt->second;
            return Value();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsi), %rdi
movq %rdx, %rsi
callq 0x451a
addq $0x70, %r14
cmpq %r14, %rax
je 0x4277
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a08
jmp 0x427f
movq %rbx, %rdi
callq 0x2948
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_hex4(__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, unsigned int&)
int parse_hex4(std::string::const_iterator& tmp_it, unsigned& u) {
            u = 0;
            char ch = 0;
            for (int i = 0; i < 4; i++) {
                u <<= 4;
                CHECK_ITERATOR(tmp_it);
                ch = *tmp_it++;
                if (ch >= '0' && ch <= '9')
                    u |= ch - '0';
                else if (ch >= 'a' && ch <= 'f')
                    u |= ch - 'a' + 10;
                else if (ch >= 'A' && ch <= 'F')
                    u |= ch - 'A' + 10;
                else return PARSE_INVALID_UNICODE_HEX;
            }
            return PARSE_OK;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andl $0x0, (%rdx)
movq (%rdi), %rcx
addq 0x8(%rdi), %rcx
movq (%rsi), %rdi
xorl %eax, %eax
movl $0x5, %r8d
movl $0xffffffd0, %r9d       # imm = 0xFFFFFFD0
movl $0xffffffa9, %r11d      # imm = 0xFFFFFFA9
movl $0xffffffc9, %ebx       # imm = 0xFFFFFFC9
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x4, %r14d
je 0x4dc1
leaq (%rdi,%r14), %r12
shll $0x4, %r15d
movl %r15d, (%rdx)
cmpq %rcx, %r12
je 0x4dbe
leaq 0x1(%r12), %r13
movq %r13, (%rsi)
movsbl (%r12), %r12d
leal -0x30(%r12), %r10d
movl %r9d, %r13d
cmpb $0xa, %r10b
jb 0x4db0
leal -0x61(%r12), %r10d
movl %r11d, %r13d
cmpb $0x6, %r10b
jb 0x4db0
leal -0x41(%r12), %r10d
movl %ebx, %r13d
cmpb $0x5, %r10b
ja 0x4dcc
addl %r12d, %r13d
orl %r13d, %r15d
movl %r15d, (%rdx)
incq %r14
jmp 0x4d63
movl %r8d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8, %eax
jmp 0x4dc1
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::encode_utf8(unsigned int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void encode_utf8(unsigned& u, std::string& tmp_str) {
            if (u <= 0x7F)
                tmp_str += (u & 0xFF);
            else if (u <= 0x7FF) {
                tmp_str += (0xC0 | (0xFF & (u >> 6)));
                tmp_str += (0x80 | (0x3F & u));
            }
            else if (u <= 0xffff) {
                tmp_str += (0xE0 | (0xFF & (u >> 12)));
                tmp_str += (0x80 | (0x3F & (u >> 6)));
                tmp_str += (0x80 | (0x3F & u));
            }
            else {
                tmp_str += (0xF0 | (0xFF & (u >> 18)));
                tmp_str += (0x80 | (0x3F & (u >> 12)));
                tmp_str += (0x80 | (0x3F & (u >> 6)));
                tmp_str += (0x80 | (0x3F & u));
            }    
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl (%rsi), %eax
cmpl $0x7f, %eax
jbe 0x4e45
movq %rsi, %r14
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x4df6
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x4e33
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x4e04
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x4e1e
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2170
movl (%r14), %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2170
movl (%r14), %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2170
movb (%r14), %al
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::FastWriter::convert_object[abi:cxx11](JSON::Value const&)
std::string convert_object(const Value& root) {
            std::string tmp_str("{ ");
            std::vector<std::string> names = root.getMemberNames();
            for (auto it : names) {
                tmp_str += it;
                tmp_str += " : ";
                tmp_str += convert_value(root[it]);
                tmp_str += " , ";
            }
            tmp_str.pop_back();
            tmp_str.pop_back();
            tmp_str += "}";
            return tmp_str;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movq %rdi, %rbx
leaq 0x24a6(%rip), %rsi      # 0x7399
leaq -0x160(%rbp), %rdx
callq 0x2090
leaq -0x58(%rbp), %rdi
movq %r14, -0x38(%rbp)
movq %r14, %rsi
callq 0x2c76
movq -0x58(%rbp), %r12
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0xb8(%rbp), %r13
cmpq -0x40(%rbp), %r12
je 0x4fd4
movq %r13, %rdi
movq %r12, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2290
movq %rbx, %rdi
leaq 0x2450(%rip), %rsi      # 0x739c
callq 0x2280
leaq -0x78(%rbp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
leaq -0x160(%rbp), %r15
movq %r15, %rdi
movq -0x38(%rbp), %rsi
movq %r14, %rdx
callq 0x4244
leaq -0x98(%rbp), %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0x514c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2290
movq %r14, %rdi
callq 0x20c0
leaq -0x160(%rbp), %rdi
callq 0x2a36
leaq -0x78(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
leaq 0x22ca(%rip), %rsi      # 0x7288
callq 0x2280
movq %r13, %rdi
callq 0x20c0
addq $0x20, %r12
jmp 0x4f22
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x21f0
leaq 0x2281(%rip), %rsi      # 0x726c
movq %rbx, %rdi
callq 0x2280
leaq -0x58(%rbp), %rdi
callq 0x2e10
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5029
movq %rax, %r14
jmp 0x5067
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x20c0
jmp 0x5038
movq %rax, %r14
jmp 0x505e
jmp 0x504f
movq %rax, %r14
jmp 0x5044
movq %rax, %r14
leaq -0x160(%rbp), %rdi
callq 0x2a36
leaq -0x78(%rbp), %rdi
callq 0x20c0
jmp 0x5052
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0x20c0
leaq -0x58(%rbp), %rdi
callq 0x2e10
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::FastWriter::convert_array[abi:cxx11](JSON::Value const&)
std::string convert_array(const Value& root) {
            std::string tmp_str("[ ");
            for (size_t i = 0; i < root.size(); i++) {
                tmp_str += convert_value(root[i]);
                tmp_str +=" , ";
            }
            tmp_str.pop_back();
            tmp_str.pop_back();
            tmp_str += "]";
            return tmp_str;
        }

// 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 0x2329(%rip), %rsi      # 0x73c2
leaq -0x48(%rbp), %r12
movq %r12, %rdx
callq 0x2090
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x41ac
cmpq %rax, %r13
jae 0x50f5
movq %r14, %rdi
movq %r13, %rsi
callq 0x41f6
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x514c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2290
movq %r12, %rdi
callq 0x20c0
movq %rbx, %rdi
leaq 0x219d(%rip), %rsi      # 0x7288
callq 0x2280
incq %r13
jmp 0x50a8
movq %rbx, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x21f0
leaq 0x22b9(%rip), %rsi      # 0x73c5
movq %rbx, %rdi
callq 0x2280
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5138
jmp 0x5138
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x20c0
jmp 0x513b
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Writer::convert_value[abi:cxx11](JSON::Value const&)
std::string convert_value(const Value& root) {
            switch (root.get_type()) {
                case JSON_NULL: return convert_literal(root.get_type()); break;
                case JSON_TRUE: return convert_literal(root.get_type()); break;
                case JSON_FALSE: return convert_literal(root.get_type()); break;
                case JSON_NUMBER: return convert_number(root.asDouble()); break;
                case JSON_STRING: return convert_string(root.asString()); break;
                case JSON_ARRAY: return convert_array(root); break;
                case JSON_OBJECT: return convert_object(root); break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
leaq 0x1f14(%rip), %rcx      # 0x707c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
jmp 0x51cd
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x23dc
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x529c
leaq -0x38(%rbp), %rdi
callq 0x20c0
jmp 0x51ee
pushq $0x2
jmp 0x51c6
movq %rdx, %rdi
callq 0x4180
leaq -0x38(%rbp), %rdx
movsd %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x525a
jmp 0x51ee
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5210
jmp 0x51ee
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x51ee
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Writer::convert_literal[abi:cxx11](JSON::json_type)
std::string convert_literal(json_type type) {
            switch (type) {
                case JSON_NULL: return std::string("null");
                case JSON_TRUE: return std::string("true");
                case JSON_FALSE: return std::string("false");
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x2, %edx
je 0x5230
cmpl $0x1, %edx
jne 0x523d
leaq 0x1e8b(%rip), %rsi      # 0x70b5
leaq -0xa(%rbp), %rdx
jmp 0x5248
leaq 0x1e83(%rip), %rsi      # 0x70ba
leaq -0x9(%rbp), %rdx
jmp 0x5248
leaq 0x1e6c(%rip), %rsi      # 0x70b0
leaq -0xb(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Writer::convert_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string convert_string(const std::string& str) {
            std::string tmp_str = "\"";
            for (auto e : str) {
                switch (e) {
                    case '\\': tmp_str += "\\\\"; break;
                    case '\"': tmp_str += "\\\""; break;
                    case '\b': tmp_str += "\\b"; break;
                    case '\f': tmp_str += "\\f"; break;
                    case '\n': tmp_str += "\\n"; break;
                    case '\r': tmp_str += "\\r"; break;
                    case '\t': tmp_str += "\\t"; break;
                    default:
                    if (e < 0x20) {
                        char buf[7];
                        sprintf(buf, "\\u%04x", e);
                        tmp_str += buf;
                    }
                    else
                    tmp_str += e;
                    break;
                }
            }
            tmp_str += '\"';
            return tmp_str;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20f3(%rip), %rsi      # 0x73aa
leaq -0x29(%rbp), %rdx
callq 0x2090
movq (%r14), %r12
movq 0x8(%r14), %r13
leaq 0x1dca(%rip), %r15      # 0x7098
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x5379
movzbl (%r12,%r14), %eax
leal -0x8(%rax), %ecx
cmpl $0x5, %ecx
ja 0x52f9
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
leaq 0x20b5(%rip), %rsi      # 0x73ac
jmp 0x535d
leaq 0x20a9(%rip), %rsi      # 0x73a9
cmpl $0x22, %eax
je 0x535d
cmpl $0x5c, %eax
jne 0x5313
leaq 0x2095(%rip), %rsi      # 0x73a6
jmp 0x535d
movsbl %al, %edx
cmpb $0x1f, %dl
jg 0x536d
leaq -0x30(%rbp), %rdi
leaq 0x2095(%rip), %rsi      # 0x73bb
xorl %eax, %eax
callq 0x2060
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x2280
jmp 0x5365
leaq 0x2076(%rip), %rsi      # 0x73b8
jmp 0x535d
leaq 0x2067(%rip), %rsi      # 0x73b2
jmp 0x535d
leaq 0x205b(%rip), %rsi      # 0x73af
jmp 0x535d
leaq 0x2058(%rip), %rsi      # 0x73b5
movq %rbx, %rdi
callq 0x2280
incq %r14
jmp 0x52d1
movq %rbx, %rdi
movl %edx, %esi
callq 0x2170
jmp 0x5365
pushq $0x22
popq %rsi
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x539a
jmp 0x539a
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::StyleWriter::convert_array[abi:cxx11](JSON::Value const&)
std::string convert_array(const Value& root) {
            std::string tmp_str;
            tmp_str += "[\n";
            tab_count++;
            for (size_t i = 0; i < root.size(); i++) {
                PUSH_TAB(tmp_str);
                tmp_str += convert_value(root[i]);
                if (i + 1 != root.size())
                    tmp_str += ",\n";
                else {
                    tmp_str += '\n';
                    tab_count--;
                }
            }
            PUSH_TAB(tmp_str);
            tmp_str += ']';
            return tmp_str;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1df4(%rip), %rsi      # 0x73d2
callq 0x2280
pushq $0x1
popq %rax
xorl %r12d, %r12d
leaq 0x1dda(%rip), %r13      # 0x73ca
addq %rax, 0x8(%r14)
movq -0x30(%rbp), %rdi
callq 0x41ac
cmpq %rax, %r12
jae 0x5681
xorl %r15d, %r15d
cmpq 0x8(%r14), %r15
jae 0x561b
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2280
incq %r15
jmp 0x5605
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x41f6
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x514c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2290
movq %r15, %rdi
callq 0x20c0
incq %r12
movq -0x30(%rbp), %rdi
callq 0x41ac
cmpq %rax, %r12
je 0x566e
movq %rbx, %rdi
leaq 0x1d68(%rip), %rsi      # 0x73cf
callq 0x2280
jmp 0x55f4
movq %rbx, %rdi
pushq $0xa
popq %rsi
callq 0x2170
pushq $-0x1
popq %rax
jmp 0x55f0
xorl %r12d, %r12d
leaq 0x1d3f(%rip), %r15      # 0x73ca
cmpq 0x8(%r14), %r12
jae 0x56a1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2280
incq %r12
jmp 0x568b
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x2170
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56d6
jmp 0x56d6
jmp 0x56d6
jmp 0x56d6
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x20c0
jmp 0x56d9
jmp 0x56d6
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/ekg[P]split/jointest.cpp
// Function: main
int main(void) {
    vector<string> s;
    s.push_back("this");
    s.push_back("will");
    s.push_back("be");
    s.push_back("joined");
    cout << join(s, "|") << endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
leaq 0xd1c(%rip), %rsi       # 0x2004
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1402
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x158e
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq 0xcf7(%rip), %rsi       # 0x2009
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1402
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x158e
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq 0xcd2(%rip), %rsi       # 0x200e
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1402
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x158e
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq 0xcab(%rip), %rsi       # 0x2011
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x1402
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x158e
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq 0xc88(%rip), %rdx       # 0x2018
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x143d
movq 0x2c34(%rip), %rdi      # 0x3fd8
leaq -0x30(%rbp), %rsi
callq 0x1100
movq %rax, %rdi
callq 0x1080
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq -0x50(%rbp), %rdi
callq 0x14f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x13e0
jmp 0x13e5
jmp 0x13e0
jmp 0x13e5
jmp 0x13e0
jmp 0x13e5
jmp 0x13e0
jmp 0x13e5
movq %rax, %rbx
jmp 0x13f1
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x1070
leaq -0x50(%rbp), %rdi
callq 0x14f0
movq %rbx, %rdi
callq 0x1170
// File: /workspace/github_cpp_makefile_star2_O2/shengzh-oOoO[P]CodeSim/src/test.cpp
// Function: PrintFinalResult()
void PrintFinalResult(){
    float f_result = 0;
    for (int i = 0; i < len; i++){
        f_result = f_result + result[i];
        //printf("%0.1f\n",result[i]);
    }
    f_result = f_result / float(len);
    printf("%0.1f\n",f_result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x36b2(%rip), %eax      # 0x48c8
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
shlq $0x2, %rdx
xorps %xmm0, %xmm0
leaq 0x3670(%rip), %rsi      # 0x48a0
cmpq %rcx, %rdx
je 0x1240
addss (%rcx,%rsi), %xmm0
addq $0x4, %rcx
jmp 0x1230
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xdb1(%rip), %rdi       # 0x2004
movb $0x1, %al
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/shengzh-oOoO[P]CodeSim/src/test.cpp
// Function: Shell(char*)
void Shell(char* str){
    FILE *fp;
    fp=popen(str,"r");
    memset(buffer,0,sizeof(buffer));
    fread(buffer,1,sizeof(buffer),fp);
    pclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0xda2(%rip), %rsi       # 0x200b
callq 0x1050
movq %rax, %rbx
leaq 0x2e28(%rip), %r14      # 0x40a0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x1060
pushq $0x1
popq %rsi
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10b0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x10a0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::NameToDexIDMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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>>>>>&)
void MapGenerator::NameToDexIDMapHelper(map<string,string> &m) {
	m.clear();
	ifstream fin(NAMESFILE);
	string name;
	string DexID,discard;
	//int i = 0;
	while(getline(fin,DexID) ) {
		getline(fin,name);
		m[name] = DexID;
		//cout << name << ' ' << DexID << '\n';
		//i++;
		getline(fin,discard);
	}
	//cout << i << endl;
	fin.close();
	//cout << "Finished NDIDM\n";
	

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x78fc
leaq 0xf3de(%rip), %rsi      # 0x12004
leaq -0x290(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
leaq -0x68(%rbp), %r15
leaq -0x88(%rbp), %r12
leaq -0x48(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2cbd
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4800
movq %rax, %rdi
movq %r15, %rsi
callq 0x2110
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
jmp 0x2c76
leaq -0x290(%rbp), %rdi
callq 0x2060
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x290(%rbp), %rdi
callq 0x2070
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d07
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x290(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::TypeToDexIDVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::TypeToDexIDVectorMapHelper(map<string,vector<string> > &m) {
	m.clear();
	ifstream fin(TYPESFILE);
	string type;
	string DexID;
	int numTypes;
	while(fin >> DexID) {
		fin >> numTypes;
		for(int i = 0; i < numTypes; i++) {
			fin >> type;
			m[type].push_back(DexID);
		}		
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x7cf2
leaq 0xf2a2(%rip), %rsi      # 0x12018
leaq -0x278(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x50(%rbp), %r15
leaq -0x70(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2e04
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2120
xorl %r12d, %r12d
cmpl -0x2c(%rbp), %r12d
jge 0x2db0
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r13, %rsi
callq 0x486a
movq %rax, %rdi
movq %r15, %rsi
callq 0x48d4
incl %r12d
jmp 0x2dd8
leaq -0x278(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e44
jmp 0x2e44
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToNameMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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>>>>>&)
void MapGenerator::DexIDToNameMapHelper(map<string,string> &m) {
	m.clear();
	ifstream fin(NAMESFILE);
	string name;
	string DexID,discard;
	while(getline(fin,DexID) ) {
		getline(fin,name);
		m[DexID] = name;
		getline(fin,discard);
	}
	fin.close();
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x78fc
leaq 0xf15c(%rip), %rsi      # 0x12004
leaq -0x290(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %dl, (%rax)
leaq -0x68(%rbp), %r15
leaq -0x88(%rbp), %r12
leaq -0x48(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2f3f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4800
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
jmp 0x2ef8
leaq -0x290(%rbp), %rdi
callq 0x2060
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x290(%rbp), %rdi
callq 0x2070
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f89
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x290(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToTypeVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::DexIDToTypeVectorMapHelper(map<string,vector<string> > &m) {
	m.clear();
	ifstream fin(TYPESFILE);
	string type;
	string DexID;
	int numTypes;
	while(fin >> DexID) {
		fin >> numTypes;
		for(int i = 0; i < numTypes; i++) {
			fin >> type;
			m[DexID].push_back(type);
		}		
	}
	fin.close();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x7cf2
leaq 0xf020(%rip), %rsi      # 0x12018
leaq -0x278(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x50(%rbp), %r15
leaq -0x70(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3086
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2120
xorl %r12d, %r12d
cmpl -0x2c(%rbp), %r12d
jge 0x3032
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r15, %rsi
callq 0x486a
movq %rax, %rdi
movq %r13, %rsi
callq 0x48d4
incl %r12d
jmp 0x305a
leaq -0x278(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30c6
jmp 0x30c6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToEntryIDVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::DexIDToEntryIDVectorMapHelper(map<string,vector<string> > &m) {
	m.clear();
	ifstream fin(ENTRYFILE);
	string DexID;
	string EntryID;
	string discard;
	//int i = 0;
	while(getline(fin,EntryID) ) {
		getline(fin,DexID);
		getline(fin,discard);
		//cout << i++ << endl;
		while(discard != "")
			getline(fin,discard);
		m[DexID].push_back(EntryID);
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rdi
movq %rsi, -0x30(%rbp)
callq 0x7cf2
leaq 0xef01(%rip), %rsi      # 0x1202c
leaq -0x298(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq -0x60(%rbp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x70(%rbp), %r15
leaq -0x90(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq 0xf3ee(%rip), %rbx      # 0x12570
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x31e6
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
movq %r13, %rdi
movq %rbx, %rsi
callq 0x490f
testb %al, %al
je 0x31cd
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
jmp 0x31b1
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x486a
movq %rax, %rdi
movq %r15, %rsi
callq 0x48d4
jmp 0x3182
leaq -0x298(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x20e0
leaq -0x298(%rbp), %rdi
callq 0x2070
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3232
jmp 0x3232
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x20e0
leaq -0x298(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::MoveIDtoEntryIDVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::MoveIDtoEntryIDVectorMapHelper(map<string, vector<string> > &m) {
	m.clear();
	ifstream fin(ENTRYFILE);
	string DexID;
	string EntryID;
	string discard;	
	string move;
	while(getline(fin,EntryID) ) {
		getline(fin,DexID);
		for(unsigned int i = 0; i < 4; i++) {
			getline(fin,move);
			m[move].push_back(EntryID);
		}
		getline(fin,discard);
		while(discard != "") {
			getline(fin,discard);
		}
	}	
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x7cf2
leaq 0xeb68(%rip), %rsi      # 0x1202c
leaq -0x2b0(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x98(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq -0x38(%rbp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq -0x58(%rbp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq -0x88(%rbp), %r13
leaq -0x68(%rbp), %r15
movq %r14, %rdi
leaq -0x48(%rbp), %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x35a4
movq %r14, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2050
pushq $0x4
popq %r12
subl $0x1, %r12d
jb 0x3579
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq %rbx, %rdi
movq %r15, %rsi
callq 0x486a
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x48d4
jmp 0x354f
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
movq %r13, %rdi
leaq 0xefe2(%rip), %rsi      # 0x12570
callq 0x490f
testb %al, %al
je 0x3522
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
jmp 0x3584
leaq -0x2b0(%rbp), %rdi
callq 0x2060
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0xa8(%rbp), %rdi
callq 0x20e0
leaq -0x2b0(%rbp), %rdi
callq 0x2070
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x35fe
jmp 0x35fe
jmp 0x35fe
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0xa8(%rbp), %rdi
callq 0x20e0
leaq -0x2b0(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::NameToEntryIDVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::NameToEntryIDVectorMapHelper(map<string, vector<string> > &m) {
	m.clear();
	//ifstream fin(ENTRYFILE);
	map<string, string> dtn;
	DexIDToNameMap(dtn);
	map<string, vector<string> > dte;
	DexIDToEntryIDVectorMap(dte);
	for( 	map<string, vector<string> >::iterator it = dte.begin(); it != dte.end(); it++) {
		m[dtn[it->first]] = it->second;
	}
	//fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x7cf2
leaq -0x78(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x19b92(%rip), %rsi     # 0x1d220
leaq -0x80(%rbp), %rdi
callq 0x5542
leaq -0x48(%rbp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x19bc3(%rip), %rsi     # 0x1d280
leaq -0x50(%rbp), %rdi
callq 0x5928
movq -0x38(%rbp), %r15
leaq -0x80(%rbp), %r14
cmpq %r12, %r15
je 0x3703
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x4800
movq %rbx, %rdi
movq %rax, %rsi
callq 0x486a
leaq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0x491c
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
jmp 0x36ce
leaq -0x50(%rbp), %rdi
callq 0x513a
leaq -0x80(%rbp), %rdi
callq 0x509e
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3729
movq %rax, %rbx
jmp 0x3735
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x513a
leaq -0x80(%rbp), %rdi
callq 0x509e
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::MoveNameToEntryIDVectorMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, 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>>>>>>>&)
void MapGenerator::MoveNameToEntryIDVectorMapHelper(map<string, vector<string> > &m) {
	m.clear();
	map<string, MoveData> midtmd; 
	MoveIDToMoveDataMap(midtmd);
	map<string, vector<string> > midteid;
	MoveIDtoEntryIDVectorMap(midteid);
	for( 	map<string, vector<string> >::iterator it = midteid.begin(); it != midteid.end(); it++) {
		m[midtmd[it->first].name] = it->second;
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x7cf2
leaq -0x78(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x19c3c(%rip), %rsi     # 0x1d3d0
leaq -0x80(%rbp), %rdi
callq 0x634c
leaq -0x48(%rbp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x19b1d(%rip), %rsi     # 0x1d2e0
leaq -0x50(%rbp), %rdi
callq 0x5928
movq -0x38(%rbp), %r15
leaq -0x80(%rbp), %r14
cmpq %r12, %r15
je 0x380d
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x49f0
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x486a
leaq 0x40(%r15), %rsi
movq %rax, %rdi
callq 0x491c
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
jmp 0x37d4
leaq -0x50(%rbp), %rdi
callq 0x513a
leaq -0x80(%rbp), %rdi
callq 0x5272
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3833
movq %rax, %rbx
jmp 0x383f
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x513a
leaq -0x80(%rbp), %rdi
callq 0x5272
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::MoveNameToMoveIDMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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>>>>>&)
void MapGenerator::MoveNameToMoveIDMapHelper(map <string, string> &m) {
	m.clear();
	ifstream fin(MOVESFILE);
	string MoveID;
	string moveName;
	string discard;
	while(getline(fin,MoveID) ) {
		getline(fin,moveName);
		getline(fin,discard);
		while(discard != "") {
			getline(fin,discard);
		}
		m[moveName] = MoveID;
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rdi
movq %rsi, -0x30(%rbp)
callq 0x78fc
leaq 0xe7a6(%rip), %rsi      # 0x12045
leaq -0x298(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x80(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq -0x60(%rbp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x90(%rbp), %r15
leaq -0x70(%rbp), %r12
leaq -0x50(%rbp), %r13
leaq 0xec7a(%rip), %rbx      # 0x12570
movq %r14, %rdi
movq %r15, %rsi
callq 0x2050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x395a
movq %r14, %rdi
movq %r12, %rsi
callq 0x2050
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
movq %r13, %rdi
movq %rbx, %rsi
callq 0x490f
testb %al, %al
je 0x3941
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
jmp 0x3925
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x4800
movq %rax, %rdi
movq %r15, %rsi
callq 0x2110
jmp 0x38f6
leaq -0x298(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x20e0
leaq -0x298(%rbp), %rdi
callq 0x2070
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39a6
jmp 0x39a6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x90(%rbp), %rdi
callq 0x20e0
leaq -0x298(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToBaseStatsMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<int, std::allocator<int>>>>>&)
void MapGenerator::DexIDToBaseStatsMapHelper(map <string, vector<int> > &m) {
	m.clear();
	ifstream fin(STATSFILE);
	string DexID;
	
	vector<int> s(6);
	while(fin >> DexID) {
		for(int i = 0; i < 6; i++)
			fin >> s[i];
		
		m[DexID] = s;
	}
	fin.close();
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x87de
leaq 0xe646(%rip), %rsi      # 0x1205c
leaq -0x270(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2300
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %rdi
pushq $0x6
popq %rsi
leaq -0x29(%rbp), %rdx
callq 0x4a5a
leaq -0x270(%rbp), %r14
leaq -0x68(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3aa3
xorl %r13d, %r13d
cmpq $0x18, %r13
je 0x3a8b
movq -0x48(%rbp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x2120
addq $0x4, %r13
jmp 0x3a70
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4aac
movq %rax, %rdi
movq %r12, %rsi
callq 0x4b16
jmp 0x3a54
leaq -0x270(%rbp), %rdi
callq 0x2060
leaq -0x48(%rbp), %rdi
callq 0x6248
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x270(%rbp), %rdi
callq 0x2070
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ae8
movq %rax, %rbx
jmp 0x3af4
jmp 0x3ae8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x6248
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x270(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::NatureToStatMultiplierMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>>>>&)
void MapGenerator::NatureToStatMultiplierMapHelper(map <string, map<int, int> > &m) {
	m.clear();
	ifstream fin(NATUREFILE);
	string nature;
	int incStat,decStat;
	while(fin >> nature) {
		fin >> incStat >> decStat;
	//	cout << nature << " " << incStat << " " << decStat << '\n';
		m[nature][incStat] = 1;
		m[nature][decStat] = -1;
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x9548
leaq 0xdc91(%rip), %rsi      # 0x1209d
leaq -0x258(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x50(%rbp), %r15
leaq -0x30(%rbp), %r12
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x44a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2120
movq %rax, %rdi
movq %r13, %rsi
callq 0x2120
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f00
movq %rax, %rdi
movq %r12, %rsi
callq 0x4f6a
movl $0x1, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4f00
movq %rax, %rdi
movq %r13, %rsi
callq 0x4f6a
orl $-0x1, (%rax)
jmp 0x443a
leaq -0x258(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x258(%rbp), %rdi
callq 0x2070
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44d5
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x258(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::SaveChangesToFile()
void MapGenerator::SaveChangesToFile() {
	ofstream fout(OUTPUTENTRYFILE);
	for(map<string, EntryData>::iterator it = EntryIDToEntryData.begin(); it != EntryIDToEntryData.end(); it++) {
		PrintEntryData(fout,it->second);
	}

	fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq 0xdb42(%rip), %rsi      # 0x12075
leaq -0x218(%rbp), %rbx
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x21e0
movq 0x18ecc(%rip), %r14     # 0x1d418
leaq 0x18eb5(%rip), %r15     # 0x1d408
cmpq %r15, %r14
je 0x4571
leaq 0x40(%r14), %rdx
movq %rbx, %rsi
callq 0x45b0
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
jmp 0x4553
leaq -0x218(%rbp), %rdi
callq 0x2250
leaq -0x218(%rbp), %rdi
callq 0x2270
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4599
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::PrintEntryData(std::basic_ofstream<char, std::char_traits<char>>&, EntryData const&)
void MapGenerator::PrintEntryData(ofstream &fout, const EntryData &ed) {
	fout << ed.ID << '\n';
	fout << ed.DexID << '\n';
	for(unsigned i = 0; i < 4; i++) {
		fout << ed.moveID[i] << '\n';
	}
	fout << ed.item << '\n';
	fout << ed.nature << '\n';
	for(unsigned i = 0; i < 6; i++) {
		fout << ed.EV[i] << '\n';
	}
	fout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2180
pushq $0xa
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
xorl %r12d, %r12d
cmpq $0x80, %r12
je 0x461e
movq 0x40(%r14), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
addq $0x20, %r12
jmp 0x45f5
leaq 0x58(%r14), %rsi
movq %rbx, %rdi
callq 0x2180
pushq $0xa
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
leaq 0x78(%r14), %rsi
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
xorl %r12d, %r12d
cmpq $0x6, %r12
je 0x467c
movq 0x98(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x22d0
movq %rax, %rdi
movl %r15d, %esi
callq 0x21f0
incq %r12
jmp 0x4653
pushq $0xa
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21f0
nop