LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: nextch()
static bool nextch() 
{
    if (g_pos == g_line.size()) {
        if (!safeGetline(source_stream, g_line)) {
            if (check_remaining_flag) {
                return false;
            }
            error(ERR_PROGRAM_INCOMPLETE);
            printCachedErrors();
            std::exit(1);
        }
        g_line.push_back('\n');
        
        g_pos = 0;
        g_line_no++;

        std::cout << std::setw(4) << (int)g_line_no 
            << " " << g_line;
    } 
    ch = g_line[g_pos];
    g_pos++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x1d422(%rip), %eax     # 0x4b720
movq %rax, -0x48(%rbp)
leaq 0x1d3f7(%rip), %rdi     # 0x4b700
callq 0x3260
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0x2e44d
leaq 0x19de3(%rip), %rdi     # 0x48108
leaq 0x1d3d4(%rip), %rsi     # 0x4b700
callq 0x2e910
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3180
testb $0x1, %al
jne 0x2e349
jmp 0x2e3db
testb $0x1, 0x1d3dc(%rip)     # 0x4b72c
je 0x2e35b
movb $0x0, -0x1(%rbp)
jmp 0x2e47c
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3570
movq -0x50(%rbp), %rdx
leaq 0x822c(%rip), %rsi      # 0x3659f
leaq -0x28(%rbp), %rdi
callq 0x3440
jmp 0x2e37e
leaq -0x28(%rbp), %rdi
callq 0x18620
jmp 0x2e389
leaq -0x28(%rbp), %rdi
callq 0x35e8
leaq -0x29(%rbp), %rdi
callq 0x3370
callq 0x17fa0
movl $0x1, %edi
callq 0x33c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2e3cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35e8
leaq -0x29(%rbp), %rdi
callq 0x3370
jmp 0x2e487
leaq 0x1d31e(%rip), %rdi     # 0x4b700
movl $0xa, %esi
callq 0x3290
movl $0x0, 0x1d32a(%rip)     # 0x4b720
movl 0x1d328(%rip), %eax     # 0x4b724
addl $0x1, %eax
movl %eax, 0x1d31f(%rip)     # 0x4b724
movl $0x4, %edi
callq 0x2ef20
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %esi
movq 0x16bac(%rip), %rdi     # 0x44fc8
callq 0x33a0
movq %rax, %rdi
movl 0x1d2fa(%rip), %esi     # 0x4b724
callq 0x3550
movq %rax, %rdi
leaq 0x7a6f(%rip), %rsi      # 0x35ea8
callq 0x3300
movq %rax, %rdi
leaq 0x1d2b8(%rip), %rsi     # 0x4b700
callq 0x32c0
movl 0x1d2cd(%rip), %eax     # 0x4b720
movl %eax, %esi
leaq 0x1d2a4(%rip), %rdi     # 0x4b700
callq 0x35c0
movb (%rax), %al
movb %al, 0x16e9f(%rip)      # 0x45308
movl 0x1d2b1(%rip), %eax     # 0x4b720
addl $0x1, %eax
movl %eax, 0x1d2a8(%rip)     # 0x4b720
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3560
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: readUnsignedInteger()
static void readUnsignedInteger() 
{
    g_num = 0;
    while (ch >= '0' && ch <= '9') {
        g_num = 10 * g_num + ch - '0';
        nextch();
    }
    g_sym = INTVALUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x1d23a(%rip)     # 0x4b6dc
movsbl 0x16e5f(%rip), %ecx     # 0x45308
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x1(%rbp)
jl 0x2e4c3
movsbl 0x16e4e(%rip), %eax     # 0x45308
cmpl $0x39, %eax
setle %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x2e4cc
jmp 0x2e4ec
imull $0xa, 0x1d209(%rip), %eax # 0x4b6dc
movsbl 0x16e2e(%rip), %ecx     # 0x45308
addl %ecx, %eax
subl $0x30, %eax
movl %eax, 0x1d1f7(%rip)     # 0x4b6dc
callq 0x2e2f0
jmp 0x2e4a2
movl $0x11, 0x1d1ba(%rip)    # 0x4b6b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: readIdentifier()
static void readIdentifier() 
{
    /**
     * Important: identifiers is not case-sensitve.
     */
    g_id.clear();
    while (std::isdigit(ch) || std::isalpha(ch)
            || ch == '_') {
        ch = std::tolower(ch);
        g_id.push_back(ch);
        nextch();
    }
    // map will return 0 if key is not in map,
    // which is exactly what we want, because
    // user-defined identifier's enum value is 0
    g_sym = key2sym[g_id];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x1d1a9(%rip), %rdi     # 0x4b6b8
callq 0x33f0
movsbl 0x16ded(%rip), %edi     # 0x45308
callq 0x32d0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
jne 0x2e554
movsbl 0x16dd5(%rip), %edi     # 0x45308
callq 0x3500
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
jne 0x2e554
movsbl 0x16dbd(%rip), %eax     # 0x45308
cmpl $0x5f, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
testb $0x1, %al
jne 0x2e55d
jmp 0x2e589
movsbl 0x16da4(%rip), %edi     # 0x45308
callq 0x3470
movb %al, 0x16d99(%rip)      # 0x45308
leaq 0x1d142(%rip), %rdi     # 0x4b6b8
movsbl 0x16d8b(%rip), %esi     # 0x45308
callq 0x3290
callq 0x2e2f0
jmp 0x2e514
leaq 0x19b20(%rip), %rdi     # 0x480b0
leaq 0x1d121(%rip), %rsi     # 0x4b6b8
callq 0x2ea00
movl (%rax), %eax
movl %eax, 0x1d10c(%rip)     # 0x4b6b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: readString()
static void readString()
{
    /**
     * Valid ASCII characters of string are:
     * 32(space), 33('!'), 35-126
	 * use `should_skip_line_break` to control whether
	 * nextch() will skip line break characters.
     */
    g_str.clear();
    nextch();
    while (ch != '\"') {
		if (ch == '\n') {
            error(ERR_STRING_NOT_END);
            break;
            // may go to next line and comtinue compiling
		}
        if (!(ch == 32 || ch == 33 ||
              (ch >= 35 && ch <= 126))) {
            error(ERR_STRING_INVALID_CHARACTER);
            nextch();
            continue;
        }
        g_str.push_back(ch);
        //if (ch == '\\')
        //    g_str.push_back('\\');
        nextch();
    }
    g_sym = STRVALUE;
    // next character must be right quotation mark, skip it
    nextch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x1d121(%rip), %rdi     # 0x4b6e0
callq 0x33f0
callq 0x2e2f0
movsbl 0x16d38(%rip), %eax     # 0x45308
cmpl $0x22, %eax
je 0x2e728
movsbl 0x16d28(%rip), %eax     # 0x45308
cmpl $0xa, %eax
jne 0x2e65b
leaq -0x21(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3570
movq -0x68(%rbp), %rdx
leaq 0x7f6f(%rip), %rsi      # 0x3656c
leaq -0x20(%rbp), %rdi
callq 0x3440
jmp 0x2e608
leaq -0x20(%rbp), %rdi
callq 0x18620
jmp 0x2e613
leaq -0x20(%rbp), %rdi
callq 0x35e8
leaq -0x21(%rbp), %rdi
callq 0x3370
jmp 0x2e728
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2e64d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x35e8
leaq -0x21(%rbp), %rdi
callq 0x3370
jmp 0x2e73d
movsbl 0x16ca6(%rip), %eax     # 0x45308
cmpl $0x20, %eax
je 0x2e70b
movsbl 0x16c96(%rip), %eax     # 0x45308
cmpl $0x21, %eax
je 0x2e70b
movsbl 0x16c86(%rip), %eax     # 0x45308
cmpl $0x23, %eax
jl 0x2e693
movsbl 0x16c7a(%rip), %eax     # 0x45308
cmpl $0x7e, %eax
jle 0x2e70b
leaq -0x59(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3570
movq -0x70(%rbp), %rdx
leaq 0x7ed8(%rip), %rsi      # 0x36583
leaq -0x58(%rbp), %rdi
callq 0x3440
jmp 0x2e6b6
leaq -0x58(%rbp), %rdi
callq 0x18620
jmp 0x2e6c1
leaq -0x58(%rbp), %rdi
callq 0x35e8
leaq -0x59(%rbp), %rdi
callq 0x3370
callq 0x2e2f0
jmp 0x2e5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2e700
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x35e8
leaq -0x59(%rbp), %rdi
callq 0x3370
jmp 0x2e73d
leaq 0x1cfce(%rip), %rdi     # 0x4b6e0
movsbl 0x16bef(%rip), %esi     # 0x45308
callq 0x3290
callq 0x2e2f0
jmp 0x2e5c9
movl $0x12, 0x1cf7e(%rip)    # 0x4b6b0
callq 0x2e2f0
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: readCharacter()
static void readCharacter() 
{
    /**
     * Valid characters of char are:
     * +, -, *, /, _, alpha, digit
     */
    nextch();
    if (ch != '+' && ch != '-' && ch != '*' && 
            ch != '/' && ch != '_' && 
            !std::isdigit(ch) && !std::isalpha(ch)) {
        std::cout << "Invalid ASCII character in char " 
            << ch << std::endl;
    }
    g_char = ch;
    nextch();
    if (ch != '\'') {
        std::cout << "Single quotation mark missing at char "
            << ch << std::endl;
    }
    g_sym = CHARVALUE;
    nextch();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2e2f0
movsbl 0x16ba8(%rip), %eax     # 0x45308
cmpl $0x2b, %eax
je 0x2e7ec
movsbl 0x16b98(%rip), %eax     # 0x45308
cmpl $0x2d, %eax
je 0x2e7ec
movsbl 0x16b8c(%rip), %eax     # 0x45308
cmpl $0x2a, %eax
je 0x2e7ec
movsbl 0x16b80(%rip), %eax     # 0x45308
cmpl $0x2f, %eax
je 0x2e7ec
movsbl 0x16b74(%rip), %eax     # 0x45308
cmpl $0x5f, %eax
je 0x2e7ec
movsbl 0x16b68(%rip), %edi     # 0x45308
callq 0x32d0
cmpl $0x0, %eax
jne 0x2e7ec
movsbl 0x16b57(%rip), %edi     # 0x45308
callq 0x3500
cmpl $0x0, %eax
jne 0x2e7ec
movq 0x16806(%rip), %rdi     # 0x44fc8
leaq 0x7d5b(%rip), %rsi      # 0x36524
callq 0x3300
movq %rax, %rdi
movsbl 0x16b30(%rip), %esi     # 0x45308
callq 0x33b0
movq %rax, %rdi
movq 0x167c1(%rip), %rsi     # 0x44fa8
callq 0x3360
movb 0x16b16(%rip), %al      # 0x45308
movb %al, 0x1cee0(%rip)      # 0x4b6d8
callq 0x2e2f0
movsbl 0x16b04(%rip), %eax     # 0x45308
cmpl $0x27, %eax
je 0x2e83a
movq 0x167b8(%rip), %rdi     # 0x44fc8
leaq 0x7d2e(%rip), %rsi      # 0x36545
callq 0x3300
movq %rax, %rdi
movsbl 0x16ae2(%rip), %esi     # 0x45308
callq 0x33b0
movq %rax, %rdi
movq 0x16773(%rip), %rsi     # 0x44fa8
callq 0x3360
movl $0x10, 0x1ce6c(%rip)    # 0x4b6b0
callq 0x2e2f0
popq %rbp
retq
nopl (%rax,%rax)
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: extraCodeChecking()
void extraCodeChecking()
{
    check_remaining_flag = true;
    while (nextch()) {
        if (!isBlankCharacter(ch)) {
            error(ERR_REDUNDENT_CODE);
            printCachedErrors();
            std::exit(1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb $0x1, 0x1cecd(%rip)     # 0x4b72c
callq 0x2e2f0
testb $0x1, %al
jne 0x2e86d
jmp 0x2e8ff
movsbl 0x16a94(%rip), %edi     # 0x45308
callq 0x2e2b0
testb $0x1, %al
jne 0x2e8fa
leaq -0x21(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3570
movq -0x40(%rbp), %rdx
leaq 0x7c70(%rip), %rsi      # 0x36505
leaq -0x20(%rbp), %rdi
callq 0x3440
jmp 0x2e8a0
leaq -0x20(%rbp), %rdi
callq 0x18620
jmp 0x2e8ab
leaq -0x20(%rbp), %rdi
callq 0x35e8
leaq -0x21(%rbp), %rdi
callq 0x3370
callq 0x17fa0
movl $0x1, %edi
callq 0x33c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2e8ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x35e8
leaq -0x21(%rbp), %rdi
callq 0x3370
jmp 0x2e905
jmp 0x2e85f
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3560
nop
// File: fondoger[P]C0-Compiler/src/symbol.cpp
// Function: safeGetline(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static std::istream& safeGetline(std::istream& is, std::string& t)
{
    t.clear();
    std::istream::sentry se(is, true);
    std::streambuf* sb = is.rdbuf();
    for(;;) {
        int c = sb->sbumpc();
        switch (c) {
        case '\n':
            return is;
        case '\r':
            if(sb->sgetc() == '\n')
                sb->sbumpc();
            return is;
        case std::streambuf::traits_type::eof():
            if(t.empty())
                is.setstate(std::ios::eofbit);
            return is;
        default:
            t += (char)c;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x33f0
movq -0x10(%rbp), %rsi
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
callq 0x34e0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3160
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x31a0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $-0x1, %eax
je 0x2e9a7
jmp 0x2e968
movl -0x30(%rbp), %eax
subl $0xa, %eax
je 0x2e97c
jmp 0x2e972
movl -0x30(%rbp), %eax
subl $0xd, %eax
je 0x2e986
jmp 0x2e9d5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e9e9
movq -0x28(%rbp), %rdi
callq 0x3490
cmpl $0xa, %eax
jne 0x2e99d
movq -0x28(%rbp), %rdi
callq 0x31a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e9e9
movq -0x18(%rbp), %rdi
callq 0x3530
testb $0x1, %al
jne 0x2e9b6
jmp 0x2e9cb
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0x2, %esi
callq 0x3200
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2e9e9
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rdi
movsbl %al, %esi
callq 0x31f0
jmp 0x2e94f
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: tabInsertParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, DataType&)
void tabInsertParam(const std::string &id, DataType &dtype)
{
    std::unordered_map<std::string, std::vector
        <DataType>>::iterator it;
    if ((it = funcParams.find(id)) == funcParams.end()) {
        std::vector<DataType> params;
        params.push_back(dtype);
        funcParams[id] = params;
    } 
    else {
        std::vector<DataType> &params = (*it).second;
        params.push_back(dtype);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2f7f0
movq -0x8(%rbp), %rsi
leaq 0x1d36c(%rip), %rdi     # 0x4c2d0
callq 0x2f840
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1d354(%rip), %rdi     # 0x4c2d0
callq 0x2f870
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2f810
testb $0x1, %al
jne 0x2ef98
jmp 0x2effb
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2f8a0
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f8c0
jmp 0x2efb4
movq -0x8(%rbp), %rsi
leaq 0x1d311(%rip), %rdi     # 0x4c2d0
callq 0x2f930
movq %rax, -0x68(%rbp)
jmp 0x2efca
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2f960
jmp 0x2efd9
leaq -0x40(%rbp), %rdi
callq 0x2fbb0
jmp 0x2f019
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2fbb0
jmp 0x2f01f
leaq -0x18(%rbp), %rdi
callq 0x2fc10
addq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2f8c0
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3560
nopl (%rax,%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: tabGetParams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const std::vector<DataType> & tabGetParams(const std::string &id) 
{
    const static std::vector<DataType> EMPTY_PARAMS;
    std::unordered_map<std::string, std::vector
        <DataType>>::iterator it;
    if ((it = funcParams.find(id)) != funcParams.end()) {
        return (*it).second;
    }
    else return EMPTY_PARAMS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpb $0x0, 0x1d2dd(%rip)     # 0x4c320
jne 0x2f088
leaq 0x1d2d4(%rip), %rdi     # 0x4c320
callq 0x3580
cmpl $0x0, %eax
je 0x2f088
leaq 0x1d2ab(%rip), %rdi     # 0x4c308
callq 0x2f8a0
leaq 0xb47(%rip), %rdi       # 0x2fbb0
leaq 0x1d298(%rip), %rsi     # 0x4c308
leaq 0x16281(%rip), %rdx     # 0x452f8
callq 0x32b0
leaq 0x1d29d(%rip), %rdi     # 0x4c320
callq 0x3220
leaq -0x18(%rbp), %rdi
callq 0x2f7f0
movq -0x10(%rbp), %rsi
leaq 0x1d234(%rip), %rdi     # 0x4c2d0
callq 0x2f840
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1d21c(%rip), %rdi     # 0x4c2d0
callq 0x2f870
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2fc40
testb $0x1, %al
jne 0x2f0d0
jmp 0x2f0e3
leaq -0x18(%rbp), %rdi
callq 0x2fc10
addq $0x20, %rax
movq %rax, -0x8(%rbp)
jmp 0x2f0ee
leaq 0x1d21e(%rip), %rax     # 0x4c308
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: tabFind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _TabEntry&)
bool tabFind(const std::string &id, TabEntry &entry)
{
    std::unordered_map<std::string, TabEntry>::iterator it;
    // find in local
    if ((it = symbolTableL.find(id)) != symbolTableL.end()) {
        entry = (*it).second;
        return true;
    }
    // find in global
    if ((it = symbolTableG.find(id)) != symbolTableG.end()) {
        entry = (*it).second;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2fc70
movq -0x10(%rbp), %rsi
leaq 0x1d174(%rip), %rdi     # 0x4c298
callq 0x2fcc0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1d15c(%rip), %rdi     # 0x4c298
callq 0x2fcf0
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fc90
testb $0x1, %al
jne 0x2f158
jmp 0x2f183
leaq -0x20(%rbp), %rdi
callq 0x2fd20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rcx), %rdx
movq %rdx, (%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x30(%rcx), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2f1f1
movq -0x10(%rbp), %rsi
leaq 0x1d0d2(%rip), %rdi     # 0x4c260
callq 0x2fcc0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x1d0ba(%rip), %rdi     # 0x4c260
callq 0x2fcf0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2fc90
testb $0x1, %al
jne 0x2f1c2
jmp 0x2f1ed
leaq -0x20(%rbp), %rdi
callq 0x2fd20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rcx), %rdx
movq %rdx, (%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x30(%rcx), %ecx
movl %ecx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2f1f1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: printSymbolTable(IdentScope)
void printSymbolTable(IdentScope scope)
{
    std::cout << (scope == GLOBAL ? 
        "##############Global table##############\n":
        "##############Local table###############\n");
    const std::unordered_map<std::string, TabEntry> &symbolTable =
        (scope == GLOBAL) ? symbolTableG : symbolTableL;
    int count = 0;
    for (auto const& item : symbolTable) {
        count++;
        std::cout << count << ":";
        printTabEntry(item.first, item.second);
    }
    std::cout << "################Table End###########\n";
    count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x2f21e
leaq 0x739a(%rip), %rax      # 0x365b2
movq %rax, -0x40(%rbp)
jmp 0x2f22b
leaq 0x73b7(%rip), %rax      # 0x365dc
movq %rax, -0x40(%rbp)
jmp 0x2f22b
movq -0x40(%rbp), %rsi
movq 0x15d92(%rip), %rdi     # 0x44fc8
callq 0x3300
cmpl $0x0, -0x4(%rbp)
jne 0x2f24e
leaq 0x1d018(%rip), %rax     # 0x4c260
movq %rax, -0x48(%rbp)
jmp 0x2f25b
leaq 0x1d043(%rip), %rax     # 0x4c298
movq %rax, -0x48(%rbp)
jmp 0x2f25b
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2fd50
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2fd80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2fc90
testb $0x1, %al
jne 0x2f29f
jmp 0x2f2ef
leaq -0x28(%rbp), %rdi
callq 0x2fdb0
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq 0x15d09(%rip), %rdi     # 0x44fc8
callq 0x3550
movq %rax, %rdi
leaq 0x5f4c(%rip), %rsi      # 0x3521a
callq 0x3300
movq -0x38(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
callq 0x2f310
leaq -0x28(%rbp), %rdi
callq 0x2fde0
jmp 0x2f28c
movq 0x15cd2(%rip), %rdi     # 0x44fc8
leaq 0x7309(%rip), %rsi      # 0x36606
callq 0x3300
movl $0x0, -0x14(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: printTabEntry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _TabEntry const&)
static void printTabEntry(const std::string &id, 
        const TabEntry &entry)
{
    std::cout << id 
        << ", " << itype2str[entry.itype]
        << ", " << dtype2str[entry.dtype] 
        << ", ";
    if (entry.itype == IT_CONST) {
        if (entry.dtype == DT_INT)
            std::cout << entry.value;
        else // DT_CHAR
            std::cout << (char)entry.value;
    }
    else
        std::cout << entry.value;
    std::cout << ", " << entry.addr;
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq 0x15c9d(%rip), %rdi     # 0x44fc8
callq 0x32c0
movq %rax, %rdi
leaq 0x6f5c(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
leaq 0x1cdb0(%rip), %rsi     # 0x4c100
shlq $0x5, %rax
addq %rax, %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x6f30(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
leaq 0x1cde4(%rip), %rsi     # 0x4c160
shlq $0x5, %rax
addq %rax, %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x6f04(%rip), %rsi      # 0x36296
callq 0x3300
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2f3d8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x2f3c0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq 0x15c0f(%rip), %rdi     # 0x44fc8
callq 0x3550
jmp 0x2f3d6
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq 0x15bfa(%rip), %rdi     # 0x44fc8
movsbl %al, %esi
callq 0x33b0
jmp 0x2f3eb
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
movq 0x15be2(%rip), %rdi     # 0x44fc8
callq 0x3550
movq 0x15bd6(%rip), %rdi     # 0x44fc8
leaq 0x6e9d(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x3550
movq 0x15bb4(%rip), %rdi     # 0x44fc8
movq 0x15b8d(%rip), %rsi     # 0x44fa8
callq 0x3360
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: tabInsert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _TabEntry const&)
void tabInsert(
    const std::string &id, 
    const TabEntry &entry)
{
    // TODO: 
    // local variable name can't be same with the name
    // of the function where the local variable is defined in.
    // (What a stupid rule!)
    std::unordered_map<std::string, TabEntry> &symbolTable =
        (entry.scope == GLOBAL) ? symbolTableG : symbolTableL;
    if (symbolTable.find(id) != symbolTable.end()) {
        error(entry.scope == GLOBAL ? ERR_DUPLICATE_GLOBAL_IDENTIFIER :
                ERR_DUPLICATE_LOCAL_IDENTIFIER);
        return;
    }
    symbolTable[id] = entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2f459
leaq 0x1ce0d(%rip), %rax     # 0x4c260
movq %rax, -0x68(%rbp)
jmp 0x2f466
leaq 0x1ce38(%rip), %rax     # 0x4c298
movq %rax, -0x68(%rbp)
jmp 0x2f466
movq -0x68(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2fcc0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2fcf0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2fc90
testb $0x1, %al
jne 0x2f4a2
jmp 0x2f52d
movq -0x10(%rbp), %rax
movl (%rax), %eax
testl %eax, %eax
leaq 0x717b(%rip), %rcx      # 0x3662c
leaq 0x71cd(%rip), %rax      # 0x36685
cmoveq %rcx, %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3570
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3440
jmp 0x2f4e0
leaq -0x48(%rbp), %rdi
callq 0x18620
jmp 0x2f4eb
leaq -0x48(%rbp), %rdi
callq 0x35e8
leaq -0x49(%rbp), %rdi
callq 0x3370
jmp 0x2f55a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2f522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35e8
leaq -0x49(%rbp), %rdi
callq 0x3370
jmp 0x2f563
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2fe10
movq -0x80(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/table.cpp
// Function: string2label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string string2label(const std::string &str)
{
    std::map<std::string, std::string>::iterator it;
    if ((it = strings_table.find(str)) != strings_table.end()) {
        return (*it).second;
    }
    std::stringstream ss;
    ss << "$STRING_" << strings_count;
    std::string label = ss.str();
    strings_table[str] = label;
    strings_count++;
    return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2fea0
movq -0x10(%rbp), %rsi
leaq 0x1cd30(%rip), %rdi     # 0x4c328
callq 0x2fec0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1cd18(%rip), %rdi     # 0x4c328
callq 0x2d350
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2d380
testb $0x1, %al
jne 0x2f62c
jmp 0x2f64d
leaq -0x18(%rbp), %rdi
callq 0x2d3b0
movq -0x1d0(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x3140
jmp 0x2f750
leaq -0x1b0(%rbp), %rdi
callq 0x3270
leaq -0x1a0(%rbp), %rdi
leaq 0x70a7(%rip), %rsi      # 0x3670e
callq 0x3300
movq %rax, -0x1d8(%rbp)
jmp 0x2f675
movq -0x1d8(%rbp), %rdi
movl 0x1ccd6(%rip), %esi     # 0x4c358
callq 0x3550
jmp 0x2f689
movq -0x1d0(%rbp), %rdi
movb $0x0, -0x1bd(%rbp)
leaq -0x1b0(%rbp), %rsi
callq 0x32f0
jmp 0x2f6a5
movq -0x10(%rbp), %rsi
leaq 0x1cc78(%rip), %rdi     # 0x4c328
callq 0x2fef0
movq %rax, -0x1e0(%rbp)
jmp 0x2f6be
movq -0x1d0(%rbp), %rsi
movq -0x1e0(%rbp), %rdi
callq 0x3040
jmp 0x2f6d3
movl 0x1cc7f(%rip), %eax     # 0x4c358
addl $0x1, %eax
movl %eax, 0x1cc76(%rip)     # 0x4c358
movb $0x1, -0x1bd(%rbp)
testb $0x1, -0x1bd(%rbp)
jne 0x2f734
jmp 0x2f728
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x2f742
movq -0x1d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
callq 0x35e8
jmp 0x2f742
movq -0x1d0(%rbp), %rdi
callq 0x35e8
leaq -0x1b0(%rbp), %rdi
callq 0x35f0
jmp 0x2f750
leaq -0x1b0(%rbp), %rdi
callq 0x35f0
jmp 0x2f760
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/compareSpec.cc
// Function: main
int main()
{
	int *p1 = new int(45);
	int *p2 = new int(42);

	// because we're comparing pointer values, the result of
    // this call may vary each time the program is run
	cout << compare(*p1, *p2) << endl;
	cout << compare(p1, p2) << endl;

	cout << strcmp("hi", "mom") << endl;
	cout << compare("hi", "mom") << endl;

	const char *cp1 = "hi", *cp2= "mom";
	cout << compare(cp1, cp2) << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x4, %edi
callq 0x1050
movl $0x2d, (%rax)
movq %rax, -0x10(%rbp)
movl $0x4, %edi
callq 0x1050
movl $0x2a, (%rax)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1360
movl %eax, %esi
movq 0x2d5b(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
movq 0x2d3c(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x13f0
movl %eax, %esi
movq 0x2d31(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
movq 0x2d12(%rip), %rsi      # 0x3fc8
callq 0x1060
movq 0x2d16(%rip), %rdi      # 0x3fd8
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1090
movq %rax, %rdi
movq 0x2cf2(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq 0xd3e(%rip), %rdi       # 0x2020
leaq 0xd3a(%rip), %rsi       # 0x2023
callq 0x1480
movl %eax, %esi
movq 0x2ce1(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
movq 0x2cc2(%rip), %rsi      # 0x3fc8
callq 0x1060
leaq 0xd0e(%rip), %rax       # 0x2020
movq %rax, -0x20(%rbp)
leaq 0xd06(%rip), %rax       # 0x2023
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11e0
movl %eax, %esi
movq 0x2ca1(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
movq 0x2c82(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/compareSpec.cc
// Function: int compare<int>(int const&, int const&)
int compare(const T& v1, const T& v2)
{
	cout << "compare(T)" << "\t";

	if (less<T>()(v1, v2)) return -1;
	if (less<T>()(v2, v1)) return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x2c61(%rip), %rdi      # 0x3fd8
leaq 0xca9(%rip), %rsi       # 0x2027
callq 0x1040
movq %rax, %rdi
leaq 0xc91(%rip), %rsi       # 0x201e
callq 0x1040
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x19(%rbp), %rdi
callq 0x14d0
testb $0x1, %al
jne 0x13a9
jmp 0x13b2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13d9
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x1a(%rbp), %rdi
callq 0x14d0
testb $0x1, %al
jne 0x13c9
jmp 0x13d2
movl $0x1, -0x4(%rbp)
jmp 0x13d9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BleuLlama[P]msf-tools/DiskUtils.cpp
// Function: DiskUtils::MakeDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void DiskUtils::MakeDir( std::string _path )
{
	// if it's already there, we're done
	if( DiskUtils::IsValidDir( _path )) return;

	// okay. try to create it
#if defined (_WIN32) || defined( __MINGW32__ )
	_mkdir( _path.c_str() );
#else
	mkdir( _path.c_str(), 0755 );
#endif

	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, %rsi
movq %rsi, -0x48(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x20a0
movq -0x40(%rbp), %rdi
callq 0x2640
movb %al, -0x35(%rbp)
jmp 0x25ee
leaq -0x28(%rbp), %rdi
callq 0x20e0
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x2600
jmp 0x2619
jmp 0x262f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20e0
jmp 0x2635
movq -0x48(%rbp), %rdi
callq 0x2090
movq %rax, %rdi
movl $0x1ed, %esi            # imm = 0x1ED
callq 0x20c0
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2320
nop
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::ConfigurePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void VoiceFile::ConfigurePath( std::string _path )
{
	this->vrDir.assign( _path );
	this->vrVoiceDir.assign( _path );
	vrVoiceDir += "/VOICE/";

	vrMSFFile.assign( vrVoiceDir );
	vrMSFFile += "MSGLISTS.MSF";

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
callq 0x2350
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2350
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
leaq 0x29aa(%rip), %rsi      # 0x610f
callq 0x2170
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x30, %rsi
callq 0x2350
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
leaq 0x298a(%rip), %rsi      # 0x6117
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFolderName[abi:cxx11](int)
std::string VoiceFile::GetFolderName( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return "";

	long folderOffset = this->GetOffsetToFolder( folderIndex );
	
	char * folderName = (char * ) (this->buffer + folderOffset  + 4);

	return folderName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %esi
callq 0x47e0
testb $0x1, %al
jne 0x408a
leaq -0x15(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2330
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x214e(%rip), %rsi      # 0x61ac
callq 0x2e40
jmp 0x4065
leaq -0x15(%rbp), %rdi
callq 0x21c0
jmp 0x40fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x21c0
jmp 0x4106
movq -0x48(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4820
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
leaq 0x4(%rax,%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2330
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x2e40
jmp 0x40da
leaq -0x39(%rbp), %rdi
callq 0x21c0
jmp 0x40fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x21c0
jmp 0x4106
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nop
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetPathForFolder[abi:cxx11](int)
std::string VoiceFile::GetPathForFolder( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return "";

	std::string folderPath( this->vrVoiceDir );
	folderPath.append( this->GetFolderName( folderIndex ));
	folderPath.append( "/" );

	return folderPath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0x14(%rbp), %esi
callq 0x47e0
testb $0x1, %al
jne 0x418d
leaq -0x15(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2330
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0x204e(%rip), %rsi      # 0x61ac
callq 0x2e40
jmp 0x4165
leaq -0x15(%rbp), %rdi
callq 0x21c0
jmp 0x4225
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x15(%rbp), %rdi
callq 0x21c0
jmp 0x422f
movq -0x50(%rbp), %rsi
movq -0x60(%rbp), %rdi
movb $0x0, -0x25(%rbp)
addq $0x30, %rsi
callq 0x20a0
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x4010
jmp 0x41b4
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2390
jmp 0x41c3
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq -0x60(%rbp), %rdi
leaq 0x1f3e(%rip), %rsi      # 0x6115
callq 0x2360
jmp 0x41de
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x4218
jmp 0x420f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x421a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20e0
jmp 0x421a
movq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x4225
movq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0x422f
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2320
nopl (%rax,%rax)
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFileCountForFolder(int)
int VoiceFile::GetFileCountForFolder( int folderIndex )
{
	if( !this->ValidFolder( folderIndex )) return 0;

	long offs = this->GetOffsetToFolder( folderIndex );

	int count = 0;

	offs += kFolderHeaderSz;

	// check for items until we find a null item
	for( count = 0 ; (count < kFolderNItems) && (this->buffer[offs] != '\0') ; count++, offs+= kFolderItemSz);

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl -0x14(%rbp), %esi
callq 0x47e0
testb $0x1, %al
jne 0x426c
movl $0x0, -0x4(%rbp)
jmp 0x42e2
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x4820
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpl $0x63, -0x24(%rbp)
movb %al, -0x31(%rbp)
jge 0x42ba
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x42c3
jmp 0x42dc
jmp 0x42c5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x20(%rbp)
jmp 0x4296
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::GetFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::GetFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	// get the offset to the item
	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );
	
	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];
	char fn[9];


	for( int i=0 ; i<8 ; i++ ) {
		fn[i] = fi->file[i];
	}
	fn[8] = '\0';

	std::string filename( fn );
	filename.append( ".MP3" );

	return filename;
}

// 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)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, (%rax)
je 0x4334
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x48b0
testb $0x1, %al
jne 0x437f
leaq -0x19(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2330
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0x1e5c(%rip), %rsi      # 0x61ac
callq 0x2e40
jmp 0x4357
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x446a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x4477
movq -0x60(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4820
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x4870
movq %rax, %rcx
movq -0x60(%rbp), %rax
addq -0x38(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x50(%rbp)
cmpl $0x8, -0x50(%rbp)
jge 0x43e2
movq -0x40(%rbp), %rax
movslq -0x50(%rbp), %rcx
movb 0x10(%rax,%rcx), %cl
movslq -0x50(%rbp), %rax
movb %cl, -0x49(%rbp,%rax)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x43bd
movb $0x0, -0x41(%rbp)
movb $0x0, -0x51(%rbp)
leaq -0x52(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2330
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq -0x49(%rbp), %rsi
callq 0x2e40
jmp 0x440a
leaq -0x52(%rbp), %rdi
callq 0x21c0
movq -0x70(%rbp), %rdi
leaq 0x1db2(%rip), %rsi      # 0x61d0
callq 0x2360
jmp 0x4425
movb $0x1, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x4468
jmp 0x445f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x52(%rbp), %rdi
callq 0x21c0
jmp 0x4477
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20e0
jmp 0x4477
movq -0x70(%rbp), %rdi
callq 0x20e0
jmp 0x446a
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2320
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::PrintableDateForFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::PrintableDateForFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );

	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];

	char b[128];

	snprintf( b, 127, "%d-%02d-%02d  %02d:%02d:%02d",
		fi->Year + 1980, fi->Month, fi->Day,
		fi->Hour, fi->Minute, fi->Second );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
testb $0x1, (%rax)
je 0x44d0
movq -0xd0(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x48b0
testb $0x1, %al
jne 0x4524
leaq -0x19(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2330
movq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rdx
leaq 0x1cb7(%rip), %rsi      # 0x61ac
callq 0x2e40
jmp 0x44fc
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x4611
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x4621
movq -0xd0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4820
movq -0xd0(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x4870
movq %rax, %rdx
movq -0xd0(%rbp), %rax
movq -0x38(%rbp), %rcx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x18(%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x19(%rax), %r8d
movzbl 0x1a(%rax), %r9d
movzbl 0x1b(%rax), %edx
movzbl 0x1c(%rax), %esi
movzbl 0x1d(%rax), %edi
movq %rsp, %rax
movl %edi, 0x10(%rax)
movl %esi, 0x8(%rax)
movl %edx, (%rax)
leaq 0x1c35(%rip), %rdx      # 0x61d5
xorl %eax, %eax
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movl $0x7f, %esi
callq 0x22e0
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x2330
movq -0xe0(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x2e40
jmp 0x45e9
leaq -0xc1(%rbp), %rdi
callq 0x21c0
jmp 0x4611
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc1(%rbp), %rdi
callq 0x21c0
jmp 0x4621
movq -0xd8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::SortableDateForFileInFolder[abi:cxx11](int, int)
std::string VoiceFile::SortableDateForFileInFolder( int fileIndex, int folderIndex )
{
	if( !this->valid || !this->ValidFile( fileIndex, folderIndex )) return "";

	long offs = this->GetOffsetToFolder( folderIndex );
	offs += this->GetOffsetToFile( fileIndex );

	sFldItm *fi = (sFldItm *)&this->buffer[ offs ];

	char b[128];

	snprintf( b, 127, "%d_%02d_%02d_%02d%02d%02d",
		fi->Year + 1980, fi->Month, fi->Day,
		fi->Hour, fi->Minute, fi->Second );

	return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
testb $0x1, (%rax)
je 0x4680
movq -0xd0(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x48b0
testb $0x1, %al
jne 0x46d4
leaq -0x19(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x2330
movq -0xe0(%rbp), %rdi
movq -0xe8(%rbp), %rdx
leaq 0x1b07(%rip), %rsi      # 0x61ac
callq 0x2e40
jmp 0x46ac
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x47c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x21c0
jmp 0x47d1
movq -0xd0(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x4820
movq -0xd0(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0x4870
movq %rax, %rdx
movq -0xd0(%rbp), %rax
movq -0x38(%rbp), %rcx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x18(%rax), %ecx
addl $0x7bc, %ecx            # imm = 0x7BC
movzbl 0x19(%rax), %r8d
movzbl 0x1a(%rax), %r9d
movzbl 0x1b(%rax), %edx
movzbl 0x1c(%rax), %esi
movzbl 0x1d(%rax), %edi
movq %rsp, %rax
movl %edi, 0x10(%rax)
movl %esi, 0x8(%rax)
movl %edx, (%rax)
leaq 0x1aa2(%rip), %rdx      # 0x61f2
xorl %eax, %eax
leaq -0xc0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
movl $0x7f, %esi
callq 0x22e0
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x2330
movq -0xe0(%rbp), %rdi
movq -0xf8(%rbp), %rsi
movq -0xf0(%rbp), %rdx
callq 0x2e40
jmp 0x4799
leaq -0xc1(%rbp), %rdi
callq 0x21c0
jmp 0x47c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xc1(%rbp), %rdi
callq 0x21c0
jmp 0x47d1
movq -0xd8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2320
nopw (%rax,%rax)
// File: BleuLlama[P]msf-tools/VoiceFile.cpp
// Function: VoiceFile::ValidFile(int, int)
bool VoiceFile::ValidFile( int fileIndex, int folderIndex )
{
	if( !this->ValidFolder( folderIndex ) ) return false;
	if( fileIndex < 0 ) return false;
	if( fileIndex >= this->GetFileCountForFolder( folderIndex )) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x18(%rbp), %esi
callq 0x47e0
testb $0x1, %al
jne 0x48dc
movb $0x0, -0x1(%rbp)
jmp 0x490d
cmpl $0x0, -0x14(%rbp)
jge 0x48e8
movb $0x0, -0x1(%rbp)
jmp 0x490d
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %esi
callq 0x4240
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x4909
movb $0x0, -0x1(%rbp)
jmp 0x490d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BleuLlama[P]msf-tools/msf-autosave.cpp
// Function: usage(char*)
void usage( char * av0 )
{
	std::cout << "Usage:  " << av0 << " <LOCAL PATH TO SAVE TO>" << std::endl;
	std::cout << std::endl;
	std::cout << "note: define VOICERECORDER env var to set root path." << std::endl;
	std::cout << "  eg:" << std::endl;
	std::cout << "      export VOICERECORDER=/Volumes/IC_RECORDER" << std::endl;
	std::cout << "      export VOICERECORDER=/v/" << std::endl;
	std::cout << "      export VOICERECORDER=v:\\" << std::endl;

	std::cout << std::endl;
	std::cout << "Version 1.0  yorgle@gmail.com  Scott Lawrence" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x453d(%rip), %rdi      # 0x8fd0
leaq 0x177e(%rip), %rsi      # 0x6218
callq 0x2180
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2180
movq %rax, %rdi
leaq 0x176c(%rip), %rsi      # 0x6221
callq 0x2180
movq %rax, %rdi
movq 0x44fc(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4500(%rip), %rdi      # 0x8fd0
movq 0x44e9(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x44ed(%rip), %rdi      # 0x8fd0
leaq 0x1750(%rip), %rsi      # 0x623a
callq 0x2180
movq %rax, %rdi
movq 0x44c7(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x44cb(%rip), %rdi      # 0x8fd0
leaq 0x1763(%rip), %rsi      # 0x626f
callq 0x2180
movq %rax, %rdi
movq 0x44a5(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x44a9(%rip), %rdi      # 0x8fd0
leaq 0x1747(%rip), %rsi      # 0x6275
callq 0x2180
movq %rax, %rdi
movq 0x4483(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4487(%rip), %rdi      # 0x8fd0
leaq 0x1755(%rip), %rsi      # 0x62a5
callq 0x2180
movq %rax, %rdi
movq 0x4461(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4465(%rip), %rdi      # 0x8fd0
leaq 0x1752(%rip), %rsi      # 0x62c4
callq 0x2180
movq %rax, %rdi
movq 0x443f(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4443(%rip), %rdi      # 0x8fd0
movq 0x442c(%rip), %rsi      # 0x8fc0
callq 0x21a0
movq 0x4430(%rip), %rdi      # 0x8fd0
leaq 0x173c(%rip), %rsi      # 0x62e3
callq 0x2180
movq %rax, %rdi
movq 0x440a(%rip), %rsi      # 0x8fc0
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)