LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: parseProduct(Section&, char*)
void parseProduct(Section& s, char *product) {

    char *ver = NULL;
    char *ptr = strtok_r(product, "/", &ver);

    // remove json '\' character, ex: Mozilla\/5.0
    remove_rchar(product);

    s.name = product;
    if (ptr != NULL) {
        s.version = ver;
    } else {
        s.version = "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x56629(%rip), %rsi     # 0x6ae4c
leaq -0x18(%rbp), %rdx
callq 0x88f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14880
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x8670
cmpq $0x0, -0x20(%rbp)
je 0x14860
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8670
jmp 0x14874
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq 0x55b9d(%rip), %rsi     # 0x6a40c
callq 0x8670
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yayuntian[P]user_agent/./userAgent.h
// Function: remove_rchar(char*)
static inline void remove_rchar(char *buf) {
    // remove json '\' character, ex: Mozilla\/5.0
    int len = strlen(buf);
    while (buf[--len] == '\\') {
        buf[len] = '\0';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x81d0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
jne 0x148bf
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x14898
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: parseSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int, int&)
Section parseSection(string& ua, int ua_len, int& index) {
    char buf[512] = {0,};

    readUtil(ua, ua_len, buf, index, ' ', false);

    Section s;
    parseProduct(s, buf);

    if (index < ua_len && ua[index] == '(') {
        index++;
        memset(buf, 0, 512);
        readUtil(ua, ua_len, buf, index, ')', true);
        split_regex(s.comment, buf, boost::regex("; ")) ;
        index++;
    }

    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x258(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x250(%rbp)
xorl %esi, %esi
movl %esi, -0x25c(%rbp)
movl $0x200, %edx            # imm = 0x200
callq 0x8260
movl -0x25c(%rbp), %r9d
movq -0x250(%rbp), %rdx
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rcx
movl $0x20, %r8d
callq 0x14690
movq -0x258(%rbp), %rdi
movb $0x0, -0x221(%rbp)
callq 0x15410
movq -0x258(%rbp), %rdi
movq -0x250(%rbp), %rsi
callq 0x14800
jmp 0x14967
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x14a7f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x89b0
movq %rax, -0x270(%rbp)
jmp 0x1498f
movq -0x270(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
jne 0x14a7f
movq -0x20(%rbp), %rax
movl (%rax), %ecx
incl %ecx
movl %ecx, (%rax)
leaq -0x220(%rbp), %rdi
movq %rdi, -0x278(%rbp)
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x8260
movq -0x278(%rbp), %rdx
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rcx
movl $0x29, %r8d
movl $0x1, %r9d
callq 0x14690
jmp 0x149eb
movq -0x258(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x280(%rbp)
leaq 0x5644a(%rip), %rsi     # 0x6ae4e
leaq -0x248(%rbp), %rdi
xorl %edx, %edx
callq 0x154c0
jmp 0x14a14
movq -0x280(%rbp), %rdi
leaq -0x220(%rbp), %rsi
leaq -0x248(%rbp), %rdx
xorl %ecx, %ecx
callq 0x15450
jmp 0x14a32
leaq -0x248(%rbp), %rdi
callq 0x15520
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x14a7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x14aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x15520
jmp 0x14aab
movb $0x1, -0x221(%rbp)
testb $0x1, -0x221(%rbp)
jne 0x14a9b
movq -0x258(%rbp), %rdi
callq 0x15540
movq -0x268(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x258(%rbp), %rdi
callq 0x15540
movq -0x230(%rbp), %rdi
callq 0x88a0
nopw %cs:(%rax,%rax)
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: initialize(UserAgent&)
void initialize(UserAgent& p) {
    p.ua = "";
    p.mozilla = "";
    p.platform = "";
    p.os = "";
    p.localization = "";
    p.browser.Engine = "";
    p.browser.EngineVersion = "";
    p.browser.Name = "";
    p.browser.Version = "";
    p.bot = false;
    p.mobile = false;
    p.undecided = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x55925(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq 0x55911(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x558fd(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x558e9(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
leaq 0x558d2(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x558bb(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x20, %rdi
leaq 0x558a0(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x40, %rdi
leaq 0x55885(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x60, %rdi
leaq 0x5586a(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rax
movb $0x0, 0x120(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x121(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x122(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: yayuntian[P]user_agent/userAgent.cpp
// Function: print_val(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void print_val(string key, bool val) {
    if (val) {
        printf("%s: %s\n", key.c_str(), "true");
    } else {
        printf("%s: %s\n", key.c_str(), "false");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x14eb1
movq -0x18(%rbp), %rdi
callq 0x81a0
movq %rax, %rsi
leaq 0x55fb0(%rip), %rdi     # 0x6ae51
leaq 0x5470e(%rip), %rdx     # 0x695b6
movb $0x0, %al
callq 0x8070
jmp 0x14ed2
movq -0x18(%rbp), %rdi
callq 0x81a0
movq %rax, %rsi
leaq 0x55f8d(%rip), %rdi     # 0x6ae51
leaq 0x5378a(%rip), %rdx     # 0x68655
movb $0x0, %al
callq 0x8070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: yayuntian[P]user_agent/operatingSystem.cpp
// Function: trident(UserAgent&, 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>>>>&, int)
void trident(UserAgent& p, vector<string>& comment, int slen) {
    p.platform = "Windows";

    if (p.os == "") {
        if (slen > 2) {
            p.os = normalizeOS(comment[2]);
        } else {
            p.os = "Windows NT 4.0";
        }
    }
    for (int i = 0; i < slen; i++) {
        if (starts_with(comment[i], "IEMobile")) {
            p.mobile = true;
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x1fdb1(%rip), %rsi     # 0x6e5a3
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x1bc06(%rip), %rsi     # 0x6a40c
callq 0x155a0
testb $0x1, %al
jne 0x4e814
jmp 0x4e899
cmpl $0x2, -0x14(%rbp)
jle 0x4e883
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x4f7a0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x81c0
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4da10
jmp 0x4e847
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq -0x38(%rbp), %rsi
callq 0x85b0
leaq -0x38(%rbp), %rdi
callq 0x89e8
leaq -0x58(%rbp), %rdi
callq 0x89e8
jmp 0x4e897
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x89e8
jmp 0x4e8ea
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x1fdbf(%rip), %rsi     # 0x6e651
callq 0x8670
jmp 0x4e899
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4e8e4
movq -0x10(%rbp), %rdi
movslq -0x68(%rbp), %rsi
callq 0x4f7a0
movq %rax, %rdi
leaq 0x1fda1(%rip), %rsi     # 0x6e660
callq 0x4fa80
testb $0x1, %al
jne 0x4e8ca
jmp 0x4e8d7
movq -0x8(%rbp), %rax
movb $0x1, 0x121(%rax)
jmp 0x4e8e4
jmp 0x4e8d9
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0x4e8a0
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x88a0
nopw %cs:(%rax,%rax)
// File: yayuntian[P]user_agent/operatingSystem.cpp
// Function: dalvik(UserAgent&, 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>>>>&, int)
void dalvik(UserAgent& p, vector<string>& comment, int slen) {
    if (starts_with(comment[0], "Linux")) {
        p.platform = comment[0];
        if (slen > 2) {
            p.os = comment[2];
        }
        p.mobile = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4f7a0
movq %rax, %rdi
leaq 0x19718(%rip), %rsi     # 0x68242
callq 0x4f7f0
testb $0x1, %al
jne 0x4eb35
jmp 0x4eb81
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4f7a0
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x8060
cmpl $0x2, -0x14(%rbp)
jle 0x4eb76
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x4f7a0
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x8060
movq -0x8(%rbp), %rax
movb $0x1, 0x121(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: yayuntian[P]user_agent/operatingSystem.cpp
// Function: split_v(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>>>> const&, int, int)
vector<string> split_v(const vector<string>& data, int start, int end)
{
    int n = end - start;
    if (n <= 0) {
        return std::vector<string>();
    }

    std::vector<string> y(n);
    for (int i = 0; i < n; i++) {
        y[i] = data[start++];
    }
    return y;
}

// 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 %ecx, -0x18(%rbp)
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0x4ebde
movq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x8260
movq -0x40(%rbp), %rdi
callq 0x15710
jmp 0x4eca5
movb $0x0, -0x1d(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3bd50
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x4fab0
jmp 0x4ec0a
leaq -0x1e(%rbp), %rdi
callq 0x3be70
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4ec90
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movl %esi, %eax
incl %eax
movl %eax, -0x14(%rbp)
callq 0x4fb20
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
movslq -0x30(%rbp), %rsi
callq 0x4f7a0
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0x8060
jmp 0x4ec55
jmp 0x4ec57
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x4ec1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x3be70
jmp 0x4ecaf
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x15790
jmp 0x4ecaf
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x4eca3
movq -0x40(%rbp), %rdi
callq 0x15790
jmp 0x4eca5
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x88a0
nopl (%rax,%rax)
// File: yayuntian[P]user_agent/bot.cpp
// Function: googleBot(UserAgent&)
bool googleBot(UserAgent& p) {
    if (contains(p.ua, "Googlebot")) {
        p.platform = "";
        p.undecided = true;
    }
    return p.undecided;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x180fd(%rip), %rsi     # 0x6e754
callq 0x571b0
testb $0x1, %al
jne 0x56662
jmp 0x56681
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
leaq 0x13d9b(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rax
movb $0x1, 0x122(%rax)
movq -0x8(%rbp), %rax
movb 0x122(%rax), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yayuntian[P]user_agent/bot.cpp
// Function: setSimple(UserAgent&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void setSimple(UserAgent& p, string name, string version, bool bot) {
    p.bot = bot;
    if(!bot) {
        p.mozilla = "";
    }
    p.browser.Name = replace_all_copy(name, "\\", "");
    p.browser.Version = version;
    p.browser.Engine = "";
    p.browser.EngineVersion = "";
    p.os = "";
    p.localization = "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x120(%rax)
testb $0x1, -0x19(%rbp)
jne 0x566ed
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq 0x13d24(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x48(%rbp), %rsi
leaq -0x40(%rbp), %rdi
leaq 0x18062(%rip), %rdx     # 0x6e75e
leaq 0x13d09(%rip), %rcx     # 0x6a40c
callq 0x4f990
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x40, %rdi
leaq -0x40(%rbp), %rsi
callq 0x85b0
leaq -0x40(%rbp), %rdi
callq 0x89e8
movq -0x50(%rbp), %rsi
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x60, %rdi
callq 0x8060
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
leaq 0x13cb9(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x20, %rdi
leaq 0x13c9e(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
leaq 0x13c8a(%rip), %rsi     # 0x6a40c
callq 0x8670
movq -0x8(%rbp), %rdi
addq $0x80, %rdi
leaq 0x13c73(%rip), %rsi     # 0x6a40c
callq 0x8670
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yayuntian[P]user_agent/bot.cpp
// Function: fixOther(UserAgent&, std::vector<Section, std::allocator<Section>>&, int)
void fixOther(UserAgent& p, vector<Section>& sections, int slen) {
    if (slen > 0) {
        p.browser.Name = sections[0].name;
        p.browser.Version = sections[0].version;
        p.mozilla = "";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x56829
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15670
movq %rax, %rsi
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x40, %rdi
callq 0x8060
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15670
movq %rax, %rsi
addq $0x20, %rsi
movq -0x8(%rbp), %rdi
addq $0xa0, %rdi
addq $0x60, %rdi
callq 0x8060
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq 0x13be8(%rip), %rsi     # 0x6a40c
callq 0x8670
addq $0x20, %rsp
popq %rbp
retq
nop
// File: shirat74[P]resample/Image.cc
// Function: Image::Image(int, int, signed char, signed char)
Image::Image (int32_t width, int32_t height, int8_t num_comp, int8_t bpc)
{
  this->width  = width;
  this->height = height;
  this->nComps = num_comp;
  this->bpc    = bpc;

  data = new Color[width*height];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0x12(%rbp), %cl
movb %cl, 0x9(%rax)
movl -0xc(%rbp), %eax
imull -0x10(%rbp), %eax
cltq
movq %rax, -0x38(%rbp)
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3040
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
cmpq $0x0, %rax
je 0x381b
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
imulq $0xc, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x42d0
jmp 0x3806
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0x37f7
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x35a0
movq -0x20(%rbp), %rdi
callq 0x34f0
nop
// File: shirat74[P]resample/Image.cc
// Function: Image::Image(int, int, signed char, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Image::Image (int32_t width, int32_t height, int8_t nComps, int8_t bpc,
              const std::string& raster)
{
  this->width  = width;
  this->height = height;
  this->nComps = nComps;
  this->bpc    = bpc;

  data = data_from_string(raster, width, height, nComps, bpc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0x12(%rbp), %cl
movb %cl, 0x9(%rax)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3160
movq -0x60(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsbl -0x11(%rbp), %ecx
movsbl -0x12(%rbp), %r8d
callq 0x3900
movq %rax, -0x58(%rbp)
jmp 0x38bd
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x40(%rbp), %rdi
callq 0x3210
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: shirat74[P]resample/Image.cc
// Function: Image::getPixel(int, int) const
Color
Image::getPixel (int32_t x, int32_t y) const
{
  if (x < 0) {
    while (x < 0)
      x += width;
  } else if (x >= width) {
    while (x >= width)
      x -= width;
  }
  if (y < 0) {
    while (y < 0)
      y += height;
  } else if (y >= height) {
    while (y >= height)
      y -= height;
  }
  return data[y * width + x];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x3e64
jmp 0x3e4e
cmpl $0x0, -0x1c(%rbp)
jge 0x3e62
movq -0x38(%rbp), %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e4e
jmp 0x3e90
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jl 0x3e8e
jmp 0x3e71
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jl 0x3e8c
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e71
jmp 0x3e8e
jmp 0x3e90
cmpl $0x0, -0x20(%rbp)
jge 0x3eaf
jmp 0x3e98
cmpl $0x0, -0x20(%rbp)
jge 0x3ead
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3e98
jmp 0x3ede
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x3edc
jmp 0x3ebd
movq -0x38(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x3eda
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movl -0x20(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x3ebd
jmp 0x3edc
jmp 0x3ede
movq -0x38(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x20(%rbp), %ecx
movl (%rdx), %edx
imull %edx, %ecx
movl -0x1c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,4), %edx
movl %edx, -0x8(%rbp)
movq (%rax,%rcx,4), %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x28(%rbp), %edx
popq %rbp
retq
// File: shirat74[P]resample/Image.cc
// Function: Image::putPixel(int, int, Color)
void
Image::putPixel (int32_t x, int32_t y, Color value)
{
  if (x < 0) {
    while (x < 0)
      x += width;
  } else if (x >= width) {
    while (x >= width)
      x -= width;
  }
  if (y < 0) {
    while (y < 0)
      y += height;
  } else if (y >= height) {
    while (y >= height)
      y -= height;
  }
  data[y * width + x] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rcx, -0x1c(%rbp)
movl %r8d, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movl %edx, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x3f6a
jmp 0x3f54
cmpl $0x0, -0x2c(%rbp)
jge 0x3f68
movq -0x38(%rbp), %rax
movl (%rax), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3f54
jmp 0x3f96
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jl 0x3f94
jmp 0x3f77
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jl 0x3f92
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3f77
jmp 0x3f94
jmp 0x3f96
cmpl $0x0, -0x30(%rbp)
jge 0x3fb5
jmp 0x3f9e
cmpl $0x0, -0x30(%rbp)
jge 0x3fb3
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x3f9e
jmp 0x3fe4
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x3fe2
jmp 0x3fc3
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x4(%rcx), %eax
jl 0x3fe0
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x30(%rbp)
jmp 0x3fc3
jmp 0x3fe2
jmp 0x3fe4
movq -0x38(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x30(%rbp), %ecx
imull (%rdx), %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movw -0x4(%rbp), %cx
movw %cx, 0x8(%rax)
movb -0x2(%rbp), %cl
movb %cl, 0xa(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shirat74[P]resample/./Image.hh
// Function: Image::reset(int, int, signed char, signed char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void reset(int32_t width, int32_t height,
             int8_t nComps, int8_t bpc, const std::string raster)
  {
    this->width  = width;
    this->height = height;
    this->nComps = nComps;
    this->bpc    = bpc;
    delete data;
    data = data_from_string(raster, width, height, nComps, bpc);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %r9, -0x68(%rbp)
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movb -0x11(%rbp), %cl
movb %cl, 0x8(%rax)
movb -0x12(%rbp), %cl
movb %cl, 0x9(%rax)
movq 0x10(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x5601
movq -0x58(%rbp), %rdi
movl $0xc, %esi
callq 0x3340
movq -0x68(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3160
movq -0x78(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movsbl -0x11(%rbp), %ecx
movsbl -0x12(%rbp), %r8d
callq 0x3900
movq %rax, -0x70(%rbp)
jmp 0x5630
movq -0x60(%rbp), %rax
movq -0x70(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x40(%rbp), %rdi
callq 0x3210
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3210
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: shirat74[P]resample/Resampler.cc
// Function: Resampler::B_spline_filter(float)
float Resampler::B_spline_filter (float t)
{
  if (t < 0.0)
    t = -t;
  if (t < 1.0) {
    return ((0.5 * t * t * t) - t * t + (2.0 / 3.0));
  } else if (t < 2) {
    t = 2 - t;
    return ((1.0 / 6.0) * (t * t * t));
  }
  return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6522
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6af5(%rip), %xmm0     # 0xd028
ucomisd %xmm1, %xmm0
jbe 0x65a8
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6ae6(%rip), %xmm0     # 0xd030
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movss -0x8(%rbp), %xmm1
mulss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x6b57(%rip), %xmm1     # 0xd0f0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x65fc
movss 0x6bc8(%rip), %xmm0     # 0xd178
ucomiss -0x8(%rbp), %xmm0
jbe 0x65f2
movss 0x6bba(%rip), %xmm0     # 0xd178
subss -0x8(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6b05(%rip), %xmm0     # 0xd0e8
mulsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x65fc
jmp 0x65f4
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: shirat74[P]resample/Resampler.cc
// Function: Resampler::bicubic_filter(float)
float Resampler::bicubic_filter (float t)
{
  if (t < 0.0)
    t = -t;
  if (t < 1.0)
    return ((a+2.0)*t*t*t - (a+3.0)*t*t + 1.0);
  else if (t < 2.0)
   return (a*t*t*t - 5.0*a*t*t + 8.0*a*t - 4.0*a);
  return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x6642
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x69d5(%rip), %xmm0     # 0xd028
ucomisd %xmm1, %xmm0
jbe 0x66e3
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6ab2(%rip), %xmm0     # 0xd120
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm0
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movss -0x8(%rbp), %xmm1
cvtss2sd %xmm1, %xmm3
movsd 0x6a7f(%rip), %xmm1     # 0xd118
mulsd %xmm3, %xmm1
movss -0x8(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x6957(%rip), %xmm1     # 0xd028
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x67a4
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x6a04(%rip), %xmm0     # 0xd0f8
ucomisd %xmm1, %xmm0
jbe 0x679a
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x69d1(%rip), %xmm1     # 0xd0e0
mulsd %xmm0, %xmm1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
mulsd %xmm0, %xmm1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm2
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm3
movsd 0x69d6(%rip), %xmm0     # 0xd110
mulsd %xmm3, %xmm0
movss -0x8(%rbp), %xmm3
cvtss2sd %xmm3, %xmm3
mulsd %xmm3, %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x698d(%rip), %xmm2     # 0xd108
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x6975(%rip), %xmm1     # 0xd100
subsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x67a4
jmp 0x679c
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopl (%rax,%rax)
// File: shirat74[P]resample/Resampler.cc
// Function: Resampler::Mitchell_filter(float)
float Resampler::Mitchell_filter (float t)
{
  float tt = t*t;
  if (t < 0)
    t = -t;
  if (t < 1.0) {
    t = (((12.0 - 9.0 * B - 6.0 * C) * (t * tt))
        + ((-18.0 + 12.0 * B + 6.0 * C) * tt)
        + (6.0 - 2 * B));
    return (t / 6.0);
  } else if (t < 2.0) {
    t = (((-1.0 * B - 6.0 * C) * (t * tt))
        + ((6.0 * B + 30.0 * C) * tt)
        + ((-12.0 * B - 48.0 * C) * t)
        + (8.0 * B + 24 * C));
    return (t / 6.0);
  }
  return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
mulss -0x8(%rbp), %xmm0
movss %xmm0, -0xc(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x6958
movss -0x8(%rbp), %xmm0
movd %xmm0, %eax
xorl $0x80000000, %eax       # imm = 0x80000000
movd %eax, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x66bf(%rip), %xmm0     # 0xd028
ucomisd %xmm1, %xmm0
jbe 0x69da
movss -0x8(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm2
movsd 0x67e2(%rip), %xmm1     # 0xd170
mulsd %xmm2, %xmm1
movsd 0x67ce(%rip), %xmm2     # 0xd168
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x67b6(%rip), %xmm1     # 0xd160
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6770(%rip), %xmm1     # 0xd138
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x6a80
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x670d(%rip), %xmm0     # 0xd0f8
ucomisd %xmm1, %xmm0
jbe 0x6a76
movss -0x8(%rbp), %xmm0
mulss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm1
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm2
movsd 0x6744(%rip), %xmm0     # 0xd158
mulsd %xmm2, %xmm0
movsd 0x6730(%rip), %xmm2     # 0xd150
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x670f(%rip), %xmm2     # 0xd148
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x66f7(%rip), %xmm1     # 0xd140
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x66d1(%rip), %xmm1     # 0xd138
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
jmp 0x6a80
jmp 0x6a78
xorps %xmm0, %xmm0
movss %xmm0, -0x4(%rbp)
movss -0x4(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: shirat74[P]resample/Resampler.cc
// Function: Resampler::Resampler(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Resampler::Resampler (const std::string& filter)
{
  filter_fn = filters[0].func;
  support   = filters[0].support;
  for (int i = 0; i < NUM_FILTERS; i++) {
    if (filter == filters[i].name) {
      filter_fn = filters[i].func;
      support   = filters[i].support;
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq %rdi, -0x38(%rbp)
callq 0x7a80
movq -0x30(%rbp), %rax
movq 0xc100(%rip), %rcx      # 0x12c80
movq %rcx, (%rax)
movss 0xc0fd(%rip), %xmm0     # 0x12c88
movss %xmm0, 0x8(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x6, -0x14(%rbp)
jge 0x6c30
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
leaq 0xc0a8(%rip), %rsi      # 0x12c60
addq %rax, %rsi
callq 0x7bb0
movb %al, -0x39(%rbp)
jmp 0x6bc5
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6bce
jmp 0x6c20
movq -0x30(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xc083(%rip), %rcx      # 0x12c60
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq 0x20(%rcx), %rcx
movq %rcx, (%rax)
movslq -0x14(%rbp), %rdx
leaq 0xc06a(%rip), %rcx      # 0x12c60
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movss 0x28(%rcx), %xmm0
movss %xmm0, 0x8(%rax)
jmp 0x6c30
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7b50
jmp 0x6c36
jmp 0x6c22
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b97
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nop
// File: shirat74[P]resample/./PNGImage.hh
// Function: PNGImage::getChromaticity() const
std::vector<float> getChromaticity() const {
    std::vector<float> cal(8);
    cal[0] = colorSpace.calRGB.xw;
    cal[1] = colorSpace.calRGB.yw;
    cal[2] = colorSpace.calRGB.xr;
    cal[3] = colorSpace.calRGB.yr;
    cal[4] = colorSpace.calRGB.xg;
    cal[5] = colorSpace.calRGB.yg;
    cal[6] = colorSpace.calRGB.xb;
    cal[7] = colorSpace.calRGB.yb;
    return cal;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xbf00
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movl $0x8, %esi
callq 0xbf20
jmp 0xaeb8
leaq -0x12(%rbp), %rdi
callq 0xbf90
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movss 0x64(%rax), %xmm0
movss %xmm0, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xb0d0
movss -0x68(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x68(%rax), %xmm0
movss %xmm0, -0x64(%rbp)
movl $0x1, %esi
callq 0xb0d0
movss -0x64(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x6c(%rax), %xmm0
movss %xmm0, -0x60(%rbp)
movl $0x2, %esi
callq 0xb0d0
movss -0x60(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x70(%rax), %xmm0
movss %xmm0, -0x5c(%rbp)
movl $0x3, %esi
callq 0xb0d0
movss -0x5c(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x74(%rax), %xmm0
movss %xmm0, -0x58(%rbp)
movl $0x4, %esi
callq 0xb0d0
movss -0x58(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x78(%rax), %xmm0
movss %xmm0, -0x54(%rbp)
movl $0x5, %esi
callq 0xb0d0
movss -0x54(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x7c(%rax), %xmm0
movss %xmm0, -0x50(%rbp)
movl $0x6, %esi
callq 0xb0d0
movss -0x50(%rbp), %xmm0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x40(%rbp), %rax
movss %xmm0, (%rcx)
movss 0x80(%rax), %xmm0
movss %xmm0, -0x4c(%rbp)
movl $0x7, %esi
callq 0xb0d0
movss -0x4c(%rbp), %xmm0
movss %xmm0, (%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xb02c
jmp 0xb023
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0xbf90
jmp 0xb036
movq -0x38(%rbp), %rdi
callq 0xb140
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nop
// File: shirat74[P]resample/./PNGImage.hh
// Function: PNGImage::setChromaticity(float, float, float, float, float, float, float, float)
void setChromaticity(float xw, float yw, float xr, float yr,
                       float xg, float yg, float xb, float yb) {
    colorSpace.calRGB.xw = xw;
    colorSpace.calRGB.yw = yw;
    colorSpace.calRGB.xr = xr;
    colorSpace.calRGB.yr = yr;
    colorSpace.calRGB.xg = xg;
    colorSpace.calRGB.yg = yg;
    colorSpace.calRGB.xb = xb;
    colorSpace.calRGB.yb = yb;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss %xmm4, -0x1c(%rbp)
movss %xmm5, -0x20(%rbp)
movss %xmm6, -0x24(%rbp)
movss %xmm7, -0x28(%rbp)
movq -0x8(%rbp), %rax
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x64(%rax)
movss -0x10(%rbp), %xmm0
movss %xmm0, 0x68(%rax)
movss -0x14(%rbp), %xmm0
movss %xmm0, 0x6c(%rax)
movss -0x18(%rbp), %xmm0
movss %xmm0, 0x70(%rax)
movss -0x1c(%rbp), %xmm0
movss %xmm0, 0x74(%rax)
movss -0x20(%rbp), %xmm0
movss %xmm0, 0x78(%rax)
movss -0x24(%rbp), %xmm0
movss %xmm0, 0x7c(%rax)
movss -0x28(%rbp), %xmm0
movss %xmm0, 0x80(%rax)
popq %rbp
retq
nopl (%rax)
// File: akw0088[P]openssl/aes_download_reverse.cpp
// Function: aes_decrypt(unsigned char*, unsigned char*, unsigned char*, unsigned int, unsigned int&, char*, char*)
int aes_decrypt(unsigned char *key, unsigned char *iv, unsigned char *ciphertext, unsigned int size, unsigned int &decryptedtext_len, char *remote_hash, char *filename)
{

	/* Buffer for the decrypted text */
	unsigned char *decryptedtext = (unsigned char *)malloc(size);
	if (decryptedtext == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	unsigned int ciphertext_len = size;

	decryptedtext_len = decrypt(ciphertext, ciphertext_len, key, iv, decryptedtext);
	decryptedtext[decryptedtext_len] = '\0';

	char new_filename[256] = {0};



	unsigned char local_hash[33] = {0};

	md5sum((char *)decryptedtext, decryptedtext_len, (char *)&local_hash[0]);


	if (strcmp(remote_hash, (char *)&local_hash[0]) == 0)
	{
		printf("MD5 Hash Pass: %s\r\n", remote_hash);
	}
	else
	{
		printf("MD5 Hash Fail: local %s != remote %s\r\n", local_hash, remote_hash);
		free((void *)decryptedtext);
		return -1;
	}


	sprintf(new_filename, "%s_decrypted", filename);

	printf("Saving decrypted file as \"%s\"\r\n", new_filename);
	write_file(new_filename, (char *)decryptedtext, decryptedtext_len);
	free((void *)decryptedtext);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x2290
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x2f83
leaq 0x1131(%rip), %rdi      # 0x40a3
callq 0x21d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x309b
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movl -0x44(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %r8
callq 0x2e50
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
movb $0x0, (%rax,%rcx)
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2150
leaq -0x180(%rbp), %rdi
xorl %esi, %esi
movl $0x21, %edx
callq 0x2150
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
leaq -0x180(%rbp), %rdx
callq 0x24e0
movq -0x38(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x22a0
cmpl $0x0, %eax
jne 0x301c
movq -0x38(%rbp), %rsi
leaq 0x114b(%rip), %rdi      # 0x415e
movb $0x0, %al
callq 0x2050
jmp 0x3047
leaq -0x180(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq 0x1144(%rip), %rdi      # 0x4172
movb $0x0, %al
callq 0x2050
movq -0x40(%rbp), %rdi
callq 0x2250
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x309b
leaq -0x150(%rbp), %rdi
movq 0x10(%rbp), %rdx
leaq 0x1140(%rip), %rsi      # 0x4199
movb $0x0, %al
callq 0x2080
leaq -0x150(%rbp), %rsi
leaq 0x1138(%rip), %rdi      # 0x41a6
movb $0x0, %al
callq 0x2050
leaq -0x150(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
movl (%rax), %edx
callq 0x26a0
movq -0x40(%rbp), %rdi
callq 0x2250
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopw (%rax,%rax)
// File: akw0088[P]openssl/aes_download_reverse.cpp
// Function: main
int main(int argc, char *argv[])
{
	unsigned short port = 65535;
	unsigned int max_malloc_size = 0;
	unsigned char encrypted_key[256] = {0};
	char remote_hash[33] = {0};

	if (argc < 4)
	{
		printf("Usage: aes_download_reverse port max_size prikey\r\n");
		printf("Example: ./aes_download_reverse 65535 70912 id_rsa\r\n");
		return 0;
	}

	port = atoi(argv[1]);
	max_malloc_size = atoi(argv[2]);

	unsigned int prikey_size = 0;
	unsigned char *prikey = (unsigned char *)get_file(argv[3], &prikey_size);


	printf("Waiting for download file on port %d\r\n", (int)port);
	int ret = aes_file_download_reverse(port, prikey, max_malloc_size);

	delete [] prikey;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw $0xffff, -0x12(%rbp)    # imm = 0xFFFF
movl $0x0, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2150
leaq -0x150(%rbp), %rdi
xorl %esi, %esi
movl $0x21, %edx
callq 0x2150
cmpl $0x4, -0x8(%rbp)
jge 0x312a
leaq 0x1214(%rip), %rdi      # 0x431d
movb $0x0, %al
callq 0x2050
leaq 0x1239(%rip), %rdi      # 0x4350
movb $0x0, %al
callq 0x2050
movl $0x0, -0x4(%rbp)
jmp 0x31c5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22c0
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x22c0
movl %eax, -0x18(%rbp)
movl $0x0, -0x154(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x154(%rbp), %rsi
callq 0x25a0
movq %rax, -0x160(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0x120a(%rip), %rdi      # 0x4385
movb $0x0, %al
callq 0x2050
movw -0x12(%rbp), %ax
movq -0x160(%rbp), %rsi
movl -0x18(%rbp), %edx
movzwl %ax, %edi
callq 0x2740
movl %eax, -0x164(%rbp)
movq -0x160(%rbp), %rax
movq %rax, -0x170(%rbp)
cmpq $0x0, %rax
je 0x31be
movq -0x170(%rbp), %rdi
callq 0x2270
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
// File: dsesami[P]superscalar-processor-model/main.cc
// Function: advance_cycle()
bool advance_cycle() {
    cycles++;
    //status();
    if(FE_continue || DE_register.size() || RN_register.size() || RR_register.size()
            || DI_register.size() || !isIQempty() || execute_list.size()
            || WB_register.size() || !isROBempty()) return true;
    else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xe476(%rip), %eax      # 0x111d4
addl $0x1, %eax
movl %eax, 0xe46d(%rip)      # 0x111d4
cmpl $0x0, 0xe6da(%rip)      # 0x11448
jne 0x2df4
leaq 0xe6d5(%rip), %rdi      # 0x11450
callq 0x3700
cmpq $0x0, %rax
jne 0x2df4
leaq 0xe713(%rip), %rdi      # 0x114a0
callq 0x3700
cmpq $0x0, %rax
jne 0x2df4
leaq 0xe751(%rip), %rdi      # 0x114f0
callq 0x3700
cmpq $0x0, %rax
jne 0x2df4
leaq 0xe78f(%rip), %rdi      # 0x11540
callq 0x3700
cmpq $0x0, %rax
jne 0x2df4
callq 0x2e10
testb $0x1, %al
jne 0x2dc7
jmp 0x2df4
leaq 0xe662(%rip), %rdi      # 0x11430
callq 0x3730
cmpq $0x0, %rax
jne 0x2df4
leaq 0xe7b0(%rip), %rdi      # 0x11590
callq 0x3700
cmpq $0x0, %rax
jne 0x2df4
callq 0x2e60
testb $0x1, %al
jne 0x2dfa
movb $0x1, -0x1(%rbp)
jmp 0x2dfe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: dsesami[P]superscalar-processor-model/main.cc
// Function: isIQempty()
bool isIQempty() {
    bool empty = true;
    for(u_int i=0; i<IQ_SIZE; i++)
        if(IQ.at(i).valid) empty = false;
    return empty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x1, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xe394(%rip), %eax      # 0x111c0
jae 0x2e55
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0xe5de(%rip), %rdi      # 0x11418
callq 0x3750
testb $0x1, (%rax)
je 0x2e48
movb $0x0, -0x1(%rbp)
jmp 0x2e4a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2e23
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: dsesami[P]superscalar-processor-model/main.cc
// Function: isROBempty()
bool isROBempty() {
    bool empty = true;
    for(u_int i=0; i<ROBSIZE; i++)
        if(ROB.at(i).valid) empty = false;
    return empty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x1, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xe340(%rip), %eax      # 0x111bc
jae 0x2ea5
movl -0x8(%rbp), %eax
movl %eax, %esi
leaq 0xe55e(%rip), %rdi      # 0x113e8
callq 0x3790
testb $0x1, (%rax)
je 0x2e98
movb $0x0, -0x1(%rbp)
jmp 0x2e9a
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2e73
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
// File: dsesami[P]superscalar-processor-model/main.cc
// Function: status()
void status () {

    cout << "DE_register: " << DE_register.size() << endl;
    cout << "RN_register: " << RN_register.size() << endl;
    cout << "RR_register: " << RR_register.size() << endl;
    cout << "DI_register: " << DI_register.size() << endl;
    cout << "Is IQ Empty: " << isIQempty() << endl;
    cout << "execute_list: " << execute_list.size() << endl;
    cout << "WB_register: " << WB_register.size() << endl;
    cout << "Is ROB Empty: " << isROBempty() << endl;
    cout << "cycles: " << cycles << endl;
    robstatus();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0xe119(%rip), %rdi      # 0x10fd8
leaq 0x8301(%rip), %rsi      # 0xb1c7
callq 0x2190
movq %rax, -0x40(%rbp)
leaq 0xe57a(%rip), %rdi      # 0x11450
callq 0x3700
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xe0d7(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xe0db(%rip), %rdi      # 0x10fd8
leaq 0x82d1(%rip), %rsi      # 0xb1d5
callq 0x2190
movq %rax, -0x38(%rbp)
leaq 0xe58c(%rip), %rdi      # 0x114a0
callq 0x3700
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xe099(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xe09d(%rip), %rdi      # 0x10fd8
leaq 0x82a1(%rip), %rsi      # 0xb1e3
callq 0x2190
movq %rax, -0x30(%rbp)
leaq 0xe59e(%rip), %rdi      # 0x114f0
callq 0x3700
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xe05b(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xe05f(%rip), %rdi      # 0x10fd8
leaq 0x8271(%rip), %rsi      # 0xb1f1
callq 0x2190
movq %rax, -0x28(%rbp)
leaq 0xe5b0(%rip), %rdi      # 0x11540
callq 0x3700
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xe01d(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xe021(%rip), %rdi      # 0x10fd8
leaq 0x8241(%rip), %rsi      # 0xb1ff
callq 0x2190
movq %rax, -0x20(%rbp)
callq 0x2e10
movq -0x20(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x22f0
movq %rax, %rdi
movq 0xdfe3(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xdfe7(%rip), %rdi      # 0x10fd8
leaq 0x8215(%rip), %rsi      # 0xb20d
callq 0x2190
movq %rax, -0x18(%rbp)
leaq 0xe428(%rip), %rdi      # 0x11430
callq 0x3730
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xdfa5(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xdfa9(%rip), %rdi      # 0x10fd8
leaq 0x81e6(%rip), %rsi      # 0xb21c
callq 0x2190
movq %rax, -0x10(%rbp)
leaq 0xe54a(%rip), %rdi      # 0x11590
callq 0x3700
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x2050
movq %rax, %rdi
movq 0xdf67(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xdf6b(%rip), %rdi      # 0x10fd8
leaq 0x81b6(%rip), %rsi      # 0xb22a
callq 0x2190
movq %rax, -0x8(%rbp)
callq 0x2e60
movq -0x8(%rbp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x22f0
movq %rax, %rdi
movq 0xdf2d(%rip), %rsi      # 0x10fc8
callq 0x21c0
movq 0xdf31(%rip), %rdi      # 0x10fd8
leaq 0x818b(%rip), %rsi      # 0xb239
callq 0x2190
movq %rax, %rdi
movl 0xe118(%rip), %esi      # 0x111d4
callq 0x2210
movq %rax, %rdi
movq 0xdefd(%rip), %rsi      # 0x10fc8
callq 0x21c0
callq 0x30e0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)