LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse()
int parse()
        {
            skip_blank();
            int ret = 0;
            if ((ret = parse_value()) == PARSE_OK) {
                skip_blank();
                if (it != json_source.end()) {
                    root->clear();
                    return PARSE_ROOT_NOT_SINGULAR;
                }
            }
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x20(%rdi), %rcx
addq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0x3329
cmpb $0x20, (%rcx)
jne 0x3329
incq %rcx
movq %rcx, 0x20(%rbx)
jmp 0x3316
movq %rbx, %rdi
xorl %esi, %esi
callq 0x338c
testl %eax, %eax
jne 0x3369
movq (%rbx), %rcx
movq 0x20(%rbx), %rdx
addq 0x8(%rbx), %rcx
cmpq %rcx, %rdx
je 0x3355
cmpb $0x20, (%rdx)
jne 0x3355
incq %rdx
movq %rdx, 0x20(%rbx)
jmp 0x3342
cmpq %rcx, 0x20(%rbx)
je 0x3369
movq 0x28(%rbx), %rdi
callq 0x31de
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_value(JSON::Value*)
int parse_value(Value* element = nullptr) {
            if (it == json_source.end())
                return PARSE_EXPECT_VALUE;
            switch (*it) {
            case 'n': return parse_literal("null", JSON_NULL, element);
            case 't': return parse_literal("true", JSON_TRUE, element);
            case 'f': return parse_literal("false", JSON_FALSE, element);
            case '[': return parse_array(element);
            case '{': return parse_object(element);
            case '\"': return parse_string(element);
            case '\0': return PARSE_EXPECT_VALUE;
            default:
                if (*it == '-' || (*it >= '0' && *it <= '9')) {
                    return parse_number(element);
                }
                return PARSE_INVALID_VALUE;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, %rcx
movq (%rdi), %rsi
movq 0x20(%rdi), %rdx
addq 0x8(%rdi), %rsi
movl $0x1, %eax
cmpq %rsi, %rdx
je 0x3447
movb (%rdx), %dl
movzbl %dl, %esi
cmpl $0x65, %esi
jg 0x33d1
cmpl $0x2c, %esi
jg 0x33eb
testl %esi, %esi
je 0x3447
cmpl $0x22, %esi
jne 0x3431
movq %rcx, %rsi
popq %rbp
jmp 0x3ade
cmpl $0x73, %esi
jg 0x33fe
cmpl $0x66, %esi
je 0x3411
cmpl $0x6e, %esi
jne 0x3431
leaq 0x3cc9(%rip), %rsi      # 0x70b0
xorl %edx, %edx
jmp 0x342b
cmpl $0x2d, %esi
je 0x343e
cmpl $0x5b, %esi
jne 0x3431
movq %rcx, %rsi
popq %rbp
jmp 0x3530
cmpl $0x74, %esi
je 0x341f
cmpl $0x7b, %esi
jne 0x3431
movq %rcx, %rsi
popq %rbp
jmp 0x374e
leaq 0x3ca2(%rip), %rsi      # 0x70ba
movl $0x2, %edx
jmp 0x342b
leaq 0x3c8f(%rip), %rsi      # 0x70b5
movl $0x1, %edx
popq %rbp
jmp 0x344a
addb $-0x30, %dl
movl $0x2, %eax
cmpb $0x9, %dl
ja 0x3447
movq %rcx, %rsi
popq %rbp
jmp 0x3b8a
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_literal(char const*, JSON::json_type, JSON::Value*)
int parse_literal(const char* dst, json_type type, Value* element = nullptr) {
            int len = strlen(dst);
            if (strncmp(&(*it), dst, len) == 0) {
                it += len;
                if (element != nullptr) {
                    switch (type) {
                    case JSON_NULL: element->clear(); break;
                    case JSON_TRUE: *element = true; break;
                    case JSON_FALSE: *element = false; break;
                    }
                }
                else {
                    switch (type) {
                    case JSON_NULL: root->clear(); break;
                    case JSON_TRUE: *root = true; break;
                    case JSON_FALSE: *root = false; break;
                    }
                }
                return PARSE_OK;
            }
            else
                return PARSE_INVALID_VALUE;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, -0x2c(%rbp)
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x20d0
movq 0x20(%r12), %r13
movslq %eax, %r14
movq %r13, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x20f0
movl $0x2, %ebx
testl %eax, %eax
je 0x349c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl -0x2c(%rbp), %eax
addq %r14, %r13
movq %r13, 0x20(%r12)
xorl %ebx, %ebx
testq %r15, %r15
je 0x34c1
cmpl $0x2, %eax
je 0x34ec
cmpl $0x1, %eax
je 0x34db
testl %eax, %eax
jne 0x348b
movq %r15, %rdi
jmp 0x34d4
cmpl $0x2, %eax
je 0x3516
cmpl $0x1, %eax
je 0x34fd
testl %eax, %eax
jne 0x348b
movq 0x28(%r12), %rdi
callq 0x31de
jmp 0x348b
movq %r15, %rdi
callq 0x31de
movl $0x1, (%r15)
jmp 0x348b
movq %r15, %rdi
callq 0x31de
movl $0x2, (%r15)
jmp 0x348b
movq 0x28(%r12), %r14
movq %r14, %rdi
callq 0x31de
movl $0x1, (%r14)
jmp 0x348b
movq 0x28(%r12), %r14
movq %r14, %rdi
callq 0x31de
movl $0x2, (%r14)
jmp 0x348b
nop
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_string(JSON::Value*)
int parse_string(Value* element = nullptr) {
            std::string tmp_str;
            std::string::const_iterator tmp_it = it;
            int ret = parse_string(tmp_str, tmp_it);
            if (ret == PARSE_OK) {
                it = tmp_it;
                if (element != nullptr)
                    *element = tmp_str;
                else
                    *root = tmp_str;
            }
            return ret;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x20(%rdi), %rax
leaq -0x28(%rbp), %rdx
movq %rax, (%rdx)
leaq -0x48(%rbp), %rsi
callq 0x4e8a
movl %eax, %ebx
testl %eax, %eax
jne 0x3b54
movq -0x28(%rbp), %rax
movq %rax, 0x20(%r15)
testq %r14, %r14
jne 0x3b35
movq 0x28(%r15), %r14
movq %r14, %rdi
callq 0x31de
movl $0x4, (%r14)
addq $0x30, %r14
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x2110
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3b62
callq 0x21d0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3b82
callq 0x21d0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::value_parse::parse_number(JSON::Value*)
int parse_number(Value* element = nullptr) {
            std::string::const_iterator tmp_it = it;
            if (*tmp_it == '-')
                tmp_it++;
            if (*tmp_it == '0')
                tmp_it++;
            else {
                if (!ISDIGIT1TO9(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            if (*tmp_it == '.') {
                tmp_it++;
                if (!ISDIGIT(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            if (*tmp_it == 'e' || *tmp_it == 'E') {
                tmp_it++;
                if (*tmp_it == '-' || *tmp_it == '+')
                    tmp_it++;
                if (!ISDIGIT(*tmp_it))
                    return PARSE_INVALID_VALUE;
                for (tmp_it++; ISDIGIT(*tmp_it); tmp_it++);
            }
            // if (*tmp_it != ' ' && *tmp_it != '\0')
            //    return PARSE_INVALID_VALUE;
            double dst_number = strtod(&(*it), NULL);
            if (errno == ERANGE && (dst_number == HUGE_VAL || dst_number == -HUGE_VAL))
                return PARSE_NUMBER_OVERFLOW;
            it = tmp_it;
            if (element != nullptr)
                *element = dst_number;
            else
                *root = dst_number;
            return PARSE_OK;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
xorl %ecx, %ecx
cmpb $0x2d, (%rax)
sete %cl
leaq (%rax,%rcx), %r15
movb (%rax,%rcx), %cl
cmpb $0x30, %cl
jne 0x3bbc
incq %r15
jmp 0x3bda
addb $-0x31, %cl
movl $0x2, %eax
cmpb $0x8, %cl
ja 0x3cab
movb 0x1(%r15), %al
incq %r15
addb $-0x30, %al
cmpb $0xa, %al
jb 0x3bcd
cmpb $0x2e, (%r15)
jne 0x3c05
movb 0x1(%r15), %cl
addb $-0x30, %cl
movl $0x2, %eax
cmpb $0x9, %cl
ja 0x3cab
incq %r15
movb 0x1(%r15), %al
incq %r15
addb $-0x30, %al
cmpb $0xa, %al
jb 0x3bf8
movzbl (%r15), %eax
orl $0x20, %eax
cmpl $0x65, %eax
jne 0x3c46
movzbl 0x1(%r15), %eax
cmpl $0x2d, %eax
je 0x3c20
cmpl $0x2b, %eax
jne 0x3c26
addq $0x2, %r15
jmp 0x3c29
incq %r15
movb (%r15), %cl
addb $-0x30, %cl
movl $0x2, %eax
cmpb $0x9, %cl
ja 0x3cab
movb 0x1(%r15), %al
incq %r15
addb $-0x30, %al
cmpb $0xa, %al
jb 0x3c39
movq 0x20(%r14), %rdi
xorl %esi, %esi
callq 0x2180
movq %xmm0, -0x28(%rbp)
movq %xmm0, %r12
callq 0x2050
cmpl $0x22, (%rax)
sete %cl
btrq $0x3f, %r12
movabsq $0x7ff0000000000000, %rax # imm = 0x7FF0000000000000
cmpq %rax, %r12
sete %dl
movl $0x4, %eax
testb %dl, %cl
jne 0x3cab
movq %r15, 0x20(%r14)
testq %rbx, %rbx
jne 0x3c91
movq 0x28(%r14), %rbx
movq %rbx, %rdi
callq 0x31de
movl $0x3, (%rbx)
movq -0x28(%rbp), %xmm0
movq %xmm0, 0x28(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::size() const
size_t size() const {
            assert(type == JSON_ARRAY || type == JSON_OBJECT);
            switch (type) {
            case JSON_ARRAY: return array.size();
            case JSON_OBJECT: return object.size();
            }
        }

// Assembly:
movl (%rdi), %eax
addl $-0x5, %eax
cmpl $0x2, %eax
jae 0x471d
testl %eax, %eax
je 0x4702
movq 0x90(%rdi), %rax
retq
movq 0x58(%rdi), %rcx
subq 0x50(%rdi), %rcx
sarq $0x3, %rcx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rcx, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2b6f(%rip), %rdi      # 0x7297
leaq 0x2b5d(%rip), %rsi      # 0x728c
leaq 0x2b8b(%rip), %rcx      # 0x72c1
movl $0x6c, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b08
addq $0x70, %r14
cmpq %r14, %rax
je 0x47c9
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ff0
jmp 0x4816
xorl %eax, %eax
movl %eax, (%rbx)
leaq 0x18(%rbx), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x40(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x38(%rbx)
movb %al, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rax, 0x60(%rbx)
leaq 0x70(%rbx), %rcx
movl %eax, 0x70(%rbx)
movq %rax, 0x78(%rbx)
movq %rcx, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
movq %rax, 0x90(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rdx)
movq (%rdi), %rax
addq 0x8(%rdi), %rax
movq (%rsi), %rcx
xorl %edi, %edi
xorl %r10d, %r10d
leaq (%rcx,%rdi), %r9
movl %r10d, %r8d
shll $0x4, %r8d
movl %r8d, (%rdx)
cmpq %rax, %r9
je 0x5408
leaq 0x1(%r9), %r10
movq %r10, (%rsi)
movsbl (%r9), %r9d
leal -0x30(%r9), %r11d
movl $0xffffffd0, %r10d      # imm = 0xFFFFFFD0
cmpb $0xa, %r11b
jb 0x53f3
leal -0x61(%r9), %r11d
movl $0xffffffa9, %r10d      # imm = 0xFFFFFFA9
cmpb $0x6, %r11b
jb 0x53f3
leal -0x41(%r9), %r11d
movl $0xffffffc9, %r10d      # imm = 0xFFFFFFC9
cmpb $0x5, %r11b
ja 0x540f
addl %r9d, %r10d
orl %r8d, %r10d
movl %r10d, (%rdx)
incq %rdi
cmpl $0x4, %edi
jne 0x53a5
xorl %eax, %eax
jmp 0x540d
movl $0x5, %eax
popq %rbp
retq
movl $0x8, %eax
jmp 0x540d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5487
movq %rsi, %r14
cmpl $0x7ff, %eax            # imm = 0x7FF
ja 0x5438
shrl $0x6, %eax
orb $-0x40, %al
jmp 0x5475
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0x5446
shrl $0xc, %eax
orb $-0x20, %al
jmp 0x5460
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
movl (%r14), %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
movl (%r14), %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21b0
movb (%r14), %al
andb $0x3f, %al
orb $-0x80, %al
movsbl %al, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x58(%rbp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x1e2a(%rip), %rsi      # 0x7360
leaq 0x1e25(%rip), %rdx      # 0x7362
callq 0x69fe
leaq -0xb8(%rbp), %rdi
movq %r14, -0x60(%rbp)
movq %r14, %rsi
callq 0x304e
movq -0xb8(%rbp), %r15
movq -0xb0(%rbp), %r14
cmpq %r14, %r15
je 0x5664
leaq -0x80(%rbp), %r12
leaq -0x160(%rbp), %r13
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x6964
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq %rbx, %rdi
leaq 0x1db7(%rip), %rsi      # 0x7363
callq 0x22b0
leaq -0x70(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x6964
movq %r13, %rdi
movq -0x60(%rbp), %rsi
movq %r12, %rdx
callq 0x4796
leaq -0xa0(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %r13, %rdx
callq 0x5846
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x561c
callq 0x21d0
movq %r13, %rdi
callq 0x2d88
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x5636
callq 0x21d0
movq %rbx, %rdi
leaq 0x1c48(%rip), %rsi      # 0x7288
callq 0x22b0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5657
callq 0x21d0
addq $0x20, %r15
cmpq %r14, %r15
jne 0x5577
movq %rbx, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2230
leaq 0x1bf1(%rip), %rsi      # 0x726c
movq %rbx, %rdi
callq 0x22b0
leaq -0xb8(%rbp), %rdi
callq 0x3250
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56af
movq %rax, %r14
movq -0x30(%rbp), %r15
jmp 0x5724
movq %rax, %r14
movq -0x30(%rbp), %r15
jmp 0x5718
jmp 0x56ff
movq %rax, %r14
jmp 0x56eb
movq %rax, %r14
jmp 0x56df
movq %rax, %r14
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x56df
callq 0x21d0
leaq -0x160(%rbp), %rdi
callq 0x2d88
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rax
cmpq %rax, %rdi
je 0x5702
callq 0x21d0
jmp 0x5702
movq %rax, %r14
movq -0x30(%rbp), %r15
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5718
callq 0x21d0
leaq -0xb8(%rbp), %rdi
callq 0x3250
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5731
callq 0x21d0
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x1c23(%rip), %rsi      # 0x7389
leaq 0x1c1e(%rip), %rdx      # 0x738b
callq 0x69fe
movq %r14, %rdi
callq 0x46ec
testq %rax, %rax
je 0x57e0
xorl %r12d, %r12d
leaq 0x1aff(%rip), %r13      # 0x7288
movq %r14, %rdi
movq %r12, %rsi
callq 0x4740
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x5846
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x57c5
callq 0x21d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22b0
incq %r12
movq %r14, %rdi
callq 0x46ec
cmpq %rax, %r12
jb 0x5789
movq %rbx, %rdi
callq 0x2230
movq %rbx, %rdi
callq 0x2230
leaq 0x1b95(%rip), %rsi      # 0x738c
movq %rbx, %rdi
callq 0x22b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x582c
jmp 0x582c
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x582f
callq 0x21d0
jmp 0x582f
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x583d
callq 0x21d0
movq %r14, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x181a(%rip), %rcx      # 0x707c
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmpq *%rsi
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x590a
jmp 0x58df
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x248c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x59ba
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58df
callq 0x21d0
jmp 0x58df
movsd 0x28(%rdx), %xmm0
leaq -0x38(%rbp), %rdx
movsd %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5964
jmp 0x58df
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x58df
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 -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5902
callq 0x21d0
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x2, %edx
je 0x5934
cmpl $0x1, %edx
jne 0x5944
leaq 0x178a(%rip), %rsi      # 0x70b5
leaq 0x1787(%rip), %rdx      # 0x70b9
jmp 0x5952
leaq 0x177f(%rip), %rsi      # 0x70ba
leaq 0x177d(%rip), %rdx      # 0x70bf
jmp 0x5952
leaq 0x1765(%rip), %rsi      # 0x70b0
leaq 0x1762(%rip), %rdx      # 0x70b4
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
leaq 0x198e(%rip), %rsi      # 0x7371
leaq 0x1988(%rip), %rdx      # 0x7372
callq 0x69fe
movq 0x8(%r14), %r13
testq %r13, %r13
je 0x5aae
movq (%r14), %r14
leaq 0x1692(%rip), %r15      # 0x7098
xorl %r12d, %r12d
movzbl (%r14,%r12), %eax
leal -0x8(%rax), %ecx
cmpl $0x5, %ecx
ja 0x5a28
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
leaq 0x194d(%rip), %rsi      # 0x7373
jmp 0x5a8c
leaq 0x1941(%rip), %rsi      # 0x7370
cmpl $0x22, %eax
je 0x5a8c
cmpl $0x5c, %eax
jne 0x5a42
leaq 0x192d(%rip), %rsi      # 0x736d
jmp 0x5a8c
movsbl %al, %edx
cmpb $0x1f, %dl
jg 0x5aa2
leaq -0x2f(%rbp), %rdi
leaq 0x192d(%rip), %rsi      # 0x7382
xorl %eax, %eax
callq 0x2070
movq %rbx, %rdi
leaq -0x2f(%rbp), %rsi
callq 0x22b0
jmp 0x5a94
leaq 0x190e(%rip), %rsi      # 0x737f
jmp 0x5a8c
leaq 0x18ff(%rip), %rsi      # 0x7379
jmp 0x5a8c
leaq 0x18f3(%rip), %rsi      # 0x7376
jmp 0x5a8c
leaq 0x18f0(%rip), %rsi      # 0x737c
movq %rbx, %rdi
callq 0x22b0
incq %r12
cmpq %r12, %r13
jne 0x5a09
jmp 0x5aae
movq %rbx, %rdi
movl %edx, %esi
callq 0x21b0
jmp 0x5a94
movq %rbx, %rdi
movl $0x22, %esi
callq 0x21b0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ad1
jmp 0x5ad1
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5ae2
callq 0x21d0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x1609(%rip), %rsi      # 0x7399
callq 0x22b0
incq 0x8(%r14)
movq %r15, -0x30(%rbp)
movq %r15, %rdi
callq 0x46ec
testq %rax, %rax
je 0x5e58
xorl %r12d, %r12d
leaq 0x15d9(%rip), %r13      # 0x7391
cmpq $0x0, 0x8(%r14)
je 0x5dd6
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22b0
incq %r15
cmpq 0x8(%r14), %r15
jb 0x5dc2
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0x4740
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x5846
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq %rbx, %rdi
callq 0x2090
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5e13
callq 0x21d0
incq %r12
movq -0x30(%rbp), %rdi
callq 0x46ec
cmpq %rax, %r12
jne 0x5e37
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21b0
decq 0x8(%r14)
jmp 0x5e46
movq %rbx, %rdi
leaq 0x1555(%rip), %rsi      # 0x7396
callq 0x22b0
movq -0x30(%rbp), %rdi
callq 0x46ec
cmpq %rax, %r12
jb 0x5db8
cmpq $0x0, 0x8(%r14)
je 0x5e7d
xorl %r12d, %r12d
leaq 0x1528(%rip), %r15      # 0x7391
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22b0
incq %r12
cmpq 0x8(%r14), %r12
jb 0x5e69
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x21b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ebb
jmp 0x5ebb
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x5ebe
callq 0x21d0
jmp 0x5ebe
jmp 0x5ebb
jmp 0x5ebb
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0x5ecc
callq 0x21d0
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd1f(%rip), %rsi       # 0x2004
leaq 0xd1c(%rip), %rdx       # 0x2008
leaq -0x30(%rbp), %rdi
callq 0x1856
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15d8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1317
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xce4(%rip), %rsi       # 0x2009
leaq 0xce1(%rip), %rdx       # 0x200d
callq 0x1856
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15d8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1353
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xcad(%rip), %rsi       # 0x200e
leaq 0xca8(%rip), %rdx       # 0x2010
callq 0x1856
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15d8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x138f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq -0x30(%rbp), %rdi
movq %r14, (%rdi)
leaq 0xc74(%rip), %rsi       # 0x2011
leaq 0xc73(%rip), %rdx       # 0x2017
callq 0x1856
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15d8
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x13cb
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq 0xc46(%rip), %rdx       # 0x2018
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1484
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq 0x2bea(%rip), %rdi      # 0x3fd8
callq 0x1120
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1432
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq -0x50(%rbp), %rdi
callq 0x156e
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x1456
jmp 0x145b
jmp 0x1456
jmp 0x145b
jmp 0x1456
jmp 0x145b
jmp 0x1456
jmp 0x145b
movq %rax, %rbx
jmp 0x1473
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1473
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x1110
leaq -0x50(%rbp), %rdi
callq 0x156e
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0x36b1(%rip), %rax      # 0x48c8
testq %rax, %rax
jle 0x1240
leaq (,%rax,4), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
leaq 0x3670(%rip), %rsi      # 0x48a0
addss (%rdx,%rsi), %xmm0
addq $0x4, %rdx
cmpq %rdx, %rcx
jne 0x1230
jmp 0x1243
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xdae(%rip), %rdi       # 0x2004
movb $0x1, %al
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd9f(%rip), %rsi       # 0x200b
callq 0x1050
movq %rax, %rbx
leaq 0x2e25(%rip), %r14      # 0x40a0
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x1060
movl $0x1, %esi
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_O1/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 0x8ce4
leaq 0x1300a(%rip), %rsi     # 0x16034
leaq -0x278(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
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 0x30be
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2110
cmpl $0x0, -0x2c(%rbp)
jle 0x3064
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r13, %rsi
callq 0x587c
movq %rax, %rdi
movq %r15, %rsi
callq 0x58fc
incl %r12d
cmpl -0x2c(%rbp), %r12d
jl 0x3092
jmp 0x3064
leaq -0x278(%rbp), %rdi
callq 0x2060
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x30e3
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x30fc
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
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 0x311e
jmp 0x311e
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x313a
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x3153
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x890a
leaq 0x12e7e(%rip), %rsi     # 0x16020
leaq -0x290(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x78(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x58(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x68(%rbp), %r15
leaq -0x88(%rbp), %r12
leaq -0x48(%rbp), %r13
movq -0x290(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x328c
movq -0x290(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2300
movq %rbx, %rdi
movq %r15, %rsi
callq 0x57fc
movq %rax, %rdi
movq %r12, %rsi
callq 0x20f0
movq -0x290(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2300
jmp 0x31f1
leaq -0x290(%rbp), %rdi
callq 0x2060
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x32b1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x32ca
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x32e6
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
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 0x3306
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3322
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x333b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rax
cmpq %rax, %rdi
je 0x3357
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x290(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ce4
leaq 0x12c8e(%rip), %rsi     # 0x16034
leaq -0x278(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
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 0x343a
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2110
cmpl $0x0, -0x2c(%rbp)
jle 0x33e0
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r15, %rsi
callq 0x587c
movq %rax, %rdi
movq %r13, %rsi
callq 0x58fc
incl %r12d
cmpl -0x2c(%rbp), %r12d
jl 0x340e
jmp 0x33e0
leaq -0x278(%rbp), %rdi
callq 0x2060
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x345f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x3478
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
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 0x349a
jmp 0x349a
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x34b6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x34cf
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ce4
leaq -0x78(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1b4cd(%rip), %rsi     # 0x1f218
leaq -0x80(%rbp), %rdi
callq 0x66ea
leaq -0x48(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x1b4fb(%rip), %rsi     # 0x1f278
leaq -0x50(%rbp), %rdi
callq 0x6a7a
movq -0x38(%rbp), %r14
cmpq %r12, %r14
je 0x3dc6
leaq -0x80(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x57fc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x587c
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x5948
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
cmpq %r12, %rax
jne 0x3d93
leaq -0x50(%rbp), %rdi
callq 0x6262
leaq -0x80(%rbp), %rdi
callq 0x61b2
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3dec
movq %rax, %rbx
jmp 0x3df8
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6262
leaq -0x80(%rbp), %rdi
callq 0x61b2
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ce4
leaq -0x78(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1b56d(%rip), %rsi     # 0x1f3c8
leaq -0x80(%rbp), %rdi
callq 0x7396
leaq -0x48(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x1b44b(%rip), %rsi     # 0x1f2d8
leaq -0x50(%rbp), %rdi
callq 0x6a7a
movq -0x38(%rbp), %r14
cmpq %r12, %r14
je 0x3eda
leaq -0x80(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x5ad6
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x587c
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x5948
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
cmpq %r12, %rax
jne 0x3ea3
leaq -0x50(%rbp), %rdi
callq 0x6262
leaq -0x80(%rbp), %rdi
callq 0x63ae
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f00
movq %rax, %rbx
jmp 0x3f0c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x6262
leaq -0x80(%rbp), %rdi
callq 0x63ae
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x97c4
leaq 0x11ec2(%rip), %rsi     # 0x16078
leaq -0x268(%rbp), %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movl $0x18, %edi
callq 0x21a0
leaq -0x40(%rbp), %r14
movq %rax, (%r14)
movq %rax, 0x8(%r14)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rcx, 0x8(%r14)
leaq -0x268(%rbp), %r15
leaq -0x60(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x426d
xorl %r13d, %r13d
movq -0x40(%rbp), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x2110
addq $0x4, %r13
cmpq $0x18, %r13
jne 0x423c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5b56
movq %rax, %rdi
movq %r14, %rsi
callq 0x5bd6
jmp 0x4220
leaq -0x268(%rbp), %rdi
callq 0x2060
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
leaq -0x50(%rbp), %rbx
je 0x4292
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
cmpq %rbx, %rdi
je 0x42a7
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x268(%rbp), %rdi
callq 0x2070
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42d2
movq %rax, %rbx
leaq -0x50(%rbp), %r14
jmp 0x42ee
jmp 0x42d2
movq %rax, %rbx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
leaq -0x50(%rbp), %r14
je 0x42ee
movq -0x30(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0x4303
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x268(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop