LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3c60
movq -0x28(%rbp), %rdi
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3cf0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x3af1
movq -0x28(%rbp), %rdi
callq 0x3c60
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
callq 0x20f0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x3eb0
testb $0x1, %al
jne 0x3ad9
jmp 0x3aef
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3700
movl $0x3, -0x4(%rbp)
jmp 0x3af7
jmp 0x3af1
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
callq 0x20f0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x3f70
testb $0x1, %al
jne 0x3d2f
jmp 0x3d3b
movl $0x1, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ef0
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
testl %eax, %eax
je 0x3e38
jmp 0x3d58
movl -0x34(%rbp), %eax
subl $0x22, %eax
je 0x3e26
jmp 0x3d66
movl -0x34(%rbp), %eax
subl $0x5b, %eax
je 0x3dff
jmp 0x3d74
movl -0x34(%rbp), %eax
subl $0x66, %eax
je 0x3dde
jmp 0x3d7e
movl -0x34(%rbp), %eax
subl $0x6e, %eax
je 0x3d9f
jmp 0x3d88
movl -0x34(%rbp), %eax
subl $0x74, %eax
je 0x3dbd
jmp 0x3d92
movl -0x34(%rbp), %eax
subl $0x7b, %eax
je 0x3e14
jmp 0x3e41
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x9412(%rip), %rsi      # 0xd1c0
xorl %edx, %edx
callq 0x3fb0
movl %eax, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x93f9(%rip), %rsi      # 0xd1c5
movl $0x1, %edx
callq 0x3fb0
movl %eax, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x93dd(%rip), %rsi      # 0xd1ca
movl $0x2, %edx
callq 0x3fb0
movl %eax, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x40d0
movl %eax, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movl %eax, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4930
movl %eax, -0x4(%rbp)
jmp 0x3e99
movl $0x1, -0x4(%rbp)
jmp 0x3e99
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ef0
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x3e80
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ef0
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x3e92
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x3ef0
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x3e92
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4a00
movl %eax, -0x4(%rbp)
jmp 0x3e99
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x38(%rbp), %rdi
movl %eax, -0x2c(%rbp)
addq $0x20, %rdi
callq 0x3ef0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x20d0
cmpl $0x0, %eax
jne 0x40be
movq -0x38(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
addq $0x20, %rdi
callq 0x4d60
cmpq $0x0, -0x28(%rbp)
je 0x4061
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x4039
jmp 0x4025
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x4044
jmp 0x402f
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x4054
jmp 0x405f
movq -0x28(%rbp), %rdi
callq 0x3700
jmp 0x405f
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x4d80
jmp 0x405f
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x4d80
jmp 0x40b5
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
testl %eax, %eax
je 0x4081
jmp 0x406d
movl -0x40(%rbp), %eax
subl $0x1, %eax
je 0x4090
jmp 0x4077
movl -0x40(%rbp), %eax
subl $0x2, %eax
je 0x40a4
jmp 0x40b3
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3700
jmp 0x40b3
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
movl $0x1, %esi
callq 0x4d80
jmp 0x40b3
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
callq 0x4d80
jmp 0x40b5
movl $0x0, -0x4(%rbp)
jmp 0x40c5
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22b0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq 0x20(%rdi), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdx
callq 0x8840
movl %eax, -0x50(%rbp)
jmp 0x4973
movl -0x50(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jne 0x49d1
movq -0x60(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x49ba
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95c0
jmp 0x49a1
jmp 0x49cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x49e9
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x95c0
jmp 0x49cd
jmp 0x49cf
jmp 0x49d1
movl -0x3c(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
movl -0x64(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jo-qzy[P]MyJson/./json.hpp
// Function: JSON::Value::operator=(bool)
void operator=(bool boolean) {
            clear();
            switch (boolean) {
            case true: type = JSON_TRUE; break;
            case false: type = JSON_FALSE; break;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x3700
movzbl -0x9(%rbp), %ecx
movb %cl, %al
andl $0x1, %ecx
movl %ecx, -0x10(%rbp)
testb $0x1, %al
je 0x4dc9
jmp 0x4db3
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x4dd3
jmp 0x4dbd
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
jmp 0x4dd3
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb $0x1, %al
cmpl $0x5, (%rcx)
movb %al, -0x11(%rbp)
je 0x708b
movq -0x20(%rbp), %rax
cmpl $0x6, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7094
jmp 0x7096
jmp 0x70b5
leaq 0x6343(%rip), %rdi      # 0xd3e0
leaq 0x630c(%rip), %rsi      # 0xd3b0
movl $0x6c, %edx
leaq 0x635a(%rip), %rcx      # 0xd40a
callq 0x2160
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x5, %eax
je 0x70cf
jmp 0x70c5
movl -0x24(%rbp), %eax
subl $0x6, %eax
je 0x70e2
jmp 0x70f5
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x5150
movq %rax, -0x8(%rbp)
jmp 0x70f7
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x72f0
movq %rax, -0x8(%rbp)
jmp 0x70f7
ud2
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rdi, -0x40(%rbp)
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x68, %rdi
callq 0x7b40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x68, %rdi
callq 0x7ba0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7b70
testb $0x1, %al
jne 0x7283
jmp 0x729e
leaq -0x20(%rbp), %rdi
callq 0x7bd0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x5820
jmp 0x72a7
movq -0x40(%rbp), %rdi
callq 0x2de0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movb $0x0, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x9395
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shll $0x4, %ecx
movl %ecx, (%rax)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x20f0
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3f70
testb $0x1, %al
jne 0x92de
jmp 0x92ea
movl $0x5, -0x4(%rbp)
jmp 0x939c
jmp 0x92ec
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x3f10
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3ef0
movb (%rax), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x30, %eax
jl 0x932c
movsbl -0x21(%rbp), %eax
cmpl $0x39, %eax
jg 0x932c
movsbl -0x21(%rbp), %ecx
subl $0x30, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x9385
movsbl -0x21(%rbp), %eax
cmpl $0x61, %eax
jl 0x9352
movsbl -0x21(%rbp), %eax
cmpl $0x66, %eax
jg 0x9352
movsbl -0x21(%rbp), %ecx
subl $0x61, %ecx
addl $0xa, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x9383
movsbl -0x21(%rbp), %eax
cmpl $0x41, %eax
jl 0x9378
movsbl -0x21(%rbp), %eax
cmpl $0x46, %eax
jg 0x9378
movsbl -0x21(%rbp), %ecx
subl $0x41, %ecx
addl $0xa, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x9381
movl $0x8, -0x4(%rbp)
jmp 0x939c
jmp 0x9383
jmp 0x9385
jmp 0x9387
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x92a1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7f, (%rax)
ja 0x93e9
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
jmp 0x950e
movq -0x10(%rbp), %rax
cmpl $0x7ff, (%rax)          # imm = 0x7FF
ja 0x9433
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x6, %eax
andl $0xff, %eax
orl $0xc0, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
jmp 0x950c
movq -0x10(%rbp), %rax
cmpl $0xffff, (%rax)         # imm = 0xFFFF
ja 0x9497
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0xc, %eax
andl $0xff, %eax
orl $0xe0, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
jmp 0x950a
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x12, %eax
andl $0xff, %eax
orl $0xf0, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
orl $0x80, %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x2130
jmp 0x950c
jmp 0x950e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2300
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x3b98(%rip), %rsi      # 0xd4d2
callq 0x22a0
jmp 0x9941
leaq -0x1a(%rbp), %rdi
callq 0x2240
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7060
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x9a08
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7110
movq -0x70(%rbp), %rsi
movq %rax, %rdx
leaq -0x58(%rbp), %rdi
callq 0x9a60
jmp 0x9992
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2280
jmp 0x99a1
leaq -0x58(%rbp), %rdi
callq 0x2120
movq -0x68(%rbp), %rdi
leaq 0x39e3(%rip), %rsi      # 0xd398
callq 0x21f0
jmp 0x99bc
jmp 0x99be
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x9952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x2240
jmp 0x9a55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x9a4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2120
jmp 0x9a4c
movq -0x68(%rbp), %rdi
callq 0x2260
movq -0x68(%rbp), %rdi
callq 0x2260
movq -0x68(%rbp), %rdi
leaq 0x3ab0(%rip), %rsi      # 0xd4d5
callq 0x21f0
jmp 0x9a2c
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x9a3f
movq -0x68(%rbp), %rdi
callq 0x2120
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x22f0
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6fc0
movl %eax, %ecx
movq %rcx, -0x58(%rbp)
subl $0x6, %eax
ja 0x9b9c
movq -0x58(%rbp), %rax
leaq 0x36f7(%rip), %rcx      # 0xd1a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rdi
callq 0x6fc0
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %eax, %edx
callq 0x9bc0
jmp 0x9b9e
movq -0x18(%rbp), %rdi
callq 0x6fc0
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %eax, %edx
callq 0x9bc0
jmp 0x9b9e
movq -0x18(%rbp), %rdi
callq 0x6fc0
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %eax, %edx
callq 0x9bc0
jmp 0x9b9e
movq -0x18(%rbp), %rdi
callq 0x7010
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rdx
callq 0x9cf0
jmp 0x9b9e
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2470
movq -0x70(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x9d90
jmp 0x9b52
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x9b9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2120
jmp 0x9bab
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
callq *0x10(%rax)
jmp 0x9b9e
movq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
callq *0x8(%rax)
jmp 0x9b9e
ud2
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x9c05
jmp 0x9bea
movl -0x2c(%rbp), %eax
subl $0x1, %eax
je 0x9c50
jmp 0x9bf4
movl -0x2c(%rbp), %eax
subl $0x2, %eax
je 0x9c95
jmp 0x9cda
leaq -0x15(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2300
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x359f(%rip), %rsi      # 0xd1c0
callq 0x22a0
jmp 0x9c28
leaq -0x15(%rbp), %rdi
callq 0x2240
jmp 0x9cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x2240
jmp 0x9ce6
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2300
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x3559(%rip), %rsi      # 0xd1c5
callq 0x22a0
jmp 0x9c73
leaq -0x25(%rbp), %rdi
callq 0x2240
jmp 0x9cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x2240
jmp 0x9ce6
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2300
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x3519(%rip), %rsi      # 0xd1ca
callq 0x22a0
jmp 0x9cb8
leaq -0x26(%rbp), %rdi
callq 0x2240
jmp 0x9cdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x2240
jmp 0x9ce6
ud2
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22f0
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x22b0
movq -0x70(%rbp), %rdi
leaq 0x3104(%rip), %rsi      # 0xd4e2
callq 0x21f0
jmp 0xa3e5
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7060
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0xa532
jmp 0xa426
movq $0x0, -0x40(%rbp)
movq -0x78(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xa46f
movq -0x70(%rbp), %rdi
leaq 0x3093(%rip), %rsi      # 0xd4da
callq 0x21f0
jmp 0xa44e
jmp 0xa450
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xa42e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0xa5a0
jmp 0xa471
jmp 0xa473
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7110
movq -0x78(%rbp), %rsi
movq %rax, %rdx
leaq -0x60(%rbp), %rdi
callq 0x9a60
jmp 0xa492
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2280
jmp 0xa4a1
leaq -0x60(%rbp), %rdi
callq 0x2120
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7060
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
je 0xa4ff
movq -0x70(%rbp), %rdi
leaq 0x3003(%rip), %rsi      # 0xd4df
callq 0x21f0
jmp 0xa4e3
jmp 0xa51f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0xa5a0
movq -0x70(%rbp), %rdi
movl $0xa, %esi
callq 0x2130
jmp 0xa50f
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0xa521
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xa3fd
jmp 0xa534
movq $0x0, -0x68(%rbp)
movq -0x78(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xa56c
movq -0x70(%rbp), %rdi
leaq 0x2f85(%rip), %rsi      # 0xd4da
callq 0x21f0
jmp 0xa55c
jmp 0xa55e
movq -0x68(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x68(%rbp)
jmp 0xa53c
jmp 0xa56e
jmp 0xa570
movq -0x70(%rbp), %rdi
movl $0x5d, %esi
callq 0x2130
jmp 0xa580
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xa593
movq -0x70(%rbp), %rdi
callq 0x2120
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x10, %rsp
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x3698(%rip), %eax      # 0x48c8
jge 0x1257
movss -0x4(%rbp), %xmm0
movslq -0x8(%rbp), %rcx
leaq 0x365e(%rip), %rax      # 0x48a0
addss (%rax,%rcx,4), %xmm0
movss %xmm0, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1227
movss -0x4(%rbp), %xmm0
cvtsi2ssl 0x3664(%rip), %xmm1 # 0x48c8
divss %xmm1, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xd87(%rip), %rdi       # 0x2004
movb $0x1, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd64(%rip), %rsi       # 0x200b
callq 0x1050
movq %rax, -0x10(%rbp)
leaq 0x2de9(%rip), %rdi      # 0x40a0
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1060
movq -0x10(%rbp), %rcx
leaq 0x2dd2(%rip), %rdi      # 0x40a0
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x10b0
movq -0x10(%rbp), %rdi
callq 0x10a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6920
leaq -0x218(%rbp), %rdi
leaq 0x2b34a(%rip), %rsi     # 0x2f004
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x278(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3080
movq %rax, -0x290(%rbp)
jmp 0x3d04
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x291(%rbp)
jmp 0x3d22
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x3d31
jmp 0x3dd2
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3080
jmp 0x3d46
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x6940
movq %rax, -0x2a0(%rbp)
jmp 0x3d5f
movq -0x2a0(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3050
jmp 0x3d74
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x3d89
jmp 0x3ce8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x3e19
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x3de0
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a50
leaq -0x218(%rbp), %rdi
leaq 0x2b18e(%rip), %rsi     # 0x2f018
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3320
movq %rax, -0x278(%rbp)
jmp 0x3ec8
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x279(%rbp)
jmp 0x3ee6
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x3ef5
jmp 0x3fb9
leaq -0x218(%rbp), %rdi
leaq -0x25c(%rbp), %rsi
callq 0x3170
jmp 0x3f0a
movl $0x0, -0x270(%rbp)
movl -0x270(%rbp), %eax
cmpl -0x25c(%rbp), %eax
jge 0x3fb4
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3320
jmp 0x3f3b
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x6a70
movq %rax, -0x288(%rbp)
jmp 0x3f54
movq -0x288(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6b50
jmp 0x3f69
jmp 0x3f6b
movl -0x270(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x270(%rbp)
jmp 0x3f14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x3ff4
jmp 0x3eac
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x3fc7
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x268(%rbp), %rdi
callq 0x3410
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6920
leaq -0x218(%rbp), %rdi
leaq 0x2afaa(%rip), %rsi     # 0x2f004
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x278(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3080
movq %rax, -0x290(%rbp)
jmp 0x40a4
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x291(%rbp)
jmp 0x40c2
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x40d1
jmp 0x4172
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3080
jmp 0x40e6
movq -0x10(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6940
movq %rax, -0x2a0(%rbp)
jmp 0x40ff
movq -0x2a0(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3050
jmp 0x4114
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x4129
jmp 0x4088
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x41b9
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x4180
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a50
leaq -0x218(%rbp), %rdi
leaq 0x2adee(%rip), %rsi     # 0x2f018
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3320
movq %rax, -0x278(%rbp)
jmp 0x4268
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x279(%rbp)
jmp 0x4286
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x4295
jmp 0x4359
leaq -0x218(%rbp), %rdi
leaq -0x25c(%rbp), %rsi
callq 0x3170
jmp 0x42aa
movl $0x0, -0x270(%rbp)
movl -0x270(%rbp), %eax
cmpl -0x25c(%rbp), %eax
jge 0x4354
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3320
jmp 0x42db
movq -0x10(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6a70
movq %rax, -0x288(%rbp)
jmp 0x42f4
movq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x6b50
jmp 0x4309
jmp 0x430b
movl -0x270(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x270(%rbp)
jmp 0x42b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x4394
jmp 0x424c
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x4367
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x268(%rbp), %rdi
callq 0x3410
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a50
leaq -0x218(%rbp), %rdi
leaq 0x2ac32(%rip), %rsi     # 0x2f02c
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x278(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3080
movq %rax, -0x290(%rbp)
jmp 0x4444
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x291(%rbp)
jmp 0x4462
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x4471
jmp 0x4552
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3080
jmp 0x4486
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x449b
jmp 0x449d
leaq 0x2b0bc(%rip), %rsi     # 0x2f560
leaq -0x278(%rbp), %rdi
callq 0x6bc0
movb %al, -0x292(%rbp)
jmp 0x44b8
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x44c4
jmp 0x451f
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x44d9
jmp 0x449d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x4599
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x6a70
movq %rax, -0x2a0(%rbp)
jmp 0x4538
movq -0x2a0(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6b50
jmp 0x454d
jmp 0x4428
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x4560
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a50
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x6730
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x4000
jmp 0x4bac
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6770
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x43a0
jmp 0x4bd1
leaq -0x80(%rbp), %rdi
callq 0x6c30
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6c90
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6c60
testb $0x1, %al
jne 0x4c0d
jmp 0x4cc9
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6cc0
movq -0xd0(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x6cc0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x6940
movq %rax, -0xb8(%rbp)
jmp 0x4c57
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0x6a70
movq %rax, -0xd8(%rbp)
jmp 0x4c73
movq -0xc8(%rbp), %rsi
movq -0xd8(%rbp), %rdi
callq 0x6ce0
jmp 0x4c88
jmp 0x4c8a
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
callq 0x6f30
movq %rax, -0x98(%rbp)
jmp 0x4be1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4ce4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6790
jmp 0x4ce4
leaq -0x80(%rbp), %rdi
callq 0x6790
leaq -0x40(%rbp), %rdi
callq 0x6750
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x6750
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6a50
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x67f0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x4ed0
jmp 0x4d7c
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6770
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x48c0
jmp 0x4da1
leaq -0x80(%rbp), %rdi
callq 0x6c30
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6c90
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x6c60
testb $0x1, %al
jne 0x4ddd
jmp 0x4e9d
leaq -0x88(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x6cc0
movq -0xd0(%rbp), %rdi
addq $0x20, %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
callq 0x6cc0
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x6f70
movq %rax, -0xb8(%rbp)
jmp 0x4e27
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
addq $0x20, %rsi
callq 0x6a70
movq %rax, -0xd8(%rbp)
jmp 0x4e47
movq -0xc8(%rbp), %rsi
movq -0xd8(%rbp), %rdi
callq 0x6ce0
jmp 0x4e5c
jmp 0x4e5e
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
callq 0x6f30
movq %rax, -0x98(%rbp)
jmp 0x4db1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x4eb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6790
jmp 0x4eb8
leaq -0x80(%rbp), %rdi
callq 0x6790
leaq -0x40(%rbp), %rdi
callq 0x6810
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x6810
movq -0x48(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)