LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::changeLocation(int, int)
void CTableController::changeLocation(int row, int col) {
    if (row < 1 || col < 1) {
	  return;
    } else {
	  m_rowPosition = row;
	  m_colPosition = col;

	  renderLocation();
	  renderValue();
	  renderExpression();
	  renderTable();
    }
}

// Assembly:
testl %esi, %esi
setle %al
testl %edx, %edx
setle %cl
orb %al, %cl
je 0x93ef
retq
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x78(%rdi)
movl %edx, 0x7c(%rdi)
callq 0x9e16
movq %rbx, %rdi
callq 0x9e8e
movq %rbx, %rdi
callq 0x9f30
movq %rbx, %rdi
popq %rbx
jmp 0x950e
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::redraw()
void CTableController::redraw() {
    clear();

    renderHeader();
    renderTable();
    renderMenu();

    refresh();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x4570
movq %rbx, %rdi
callq 0x943c
movq %rbx, %rdi
callq 0x950e
callq 0x9d94
popq %rbx
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderHeader() const
void CTableController::renderHeader() const {
    attron(A_BOLD | A_UNDERLINE);
    mvprintw(0, 1, "Position");
    attroff(A_BOLD | A_UNDERLINE);
    renderLocation();

    attron(A_BOLD | A_UNDERLINE);
    mvprintw(3, 1, "Cell Value");
    attroff(A_BOLD | A_UNDERLINE);
    renderValue();

    attron(A_BOLD | A_UNDERLINE);
    mvprintw(4, 1, "Expression");
    attroff(A_BOLD | A_UNDERLINE);
    renderExpression();

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9b6e(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x5222(%rip), %rdx      # 0xe682
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43b0
movq %rbx, %rdi
callq 0x9e16
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x51f0(%rip), %rdx      # 0xe68b
movl $0x3, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43b0
movq %rbx, %rdi
callq 0x9e8e
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x51bd(%rip), %rdx      # 0xe696
movl $0x4, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x43b0
movq %rbx, %rdi
callq 0x9f30
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderMenu() const
void CTableController::renderMenu() const {
    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " E - edit the expression ");
    mvprintw(maxY - 1, 27, " F3 - help ");
    mvprintw(maxY - 1, 39, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x9219(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9dad
movswl 0x4(%rdi), %ebx
jmp 0x9db2
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl $0x100, %esi            # imm = 0x100
callq 0x4310
leaq 0x48eb(%rip), %rdx      # 0xe6ae
movl %ebx, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x48f0(%rip), %rdx      # 0xe6c8
movl %ebx, %edi
movl $0x1b, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x465a(%rip), %rdx      # 0xe447
movl %ebx, %edi
movl $0x27, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderLocation() const
void CTableController::renderLocation() const {
    move(0, HEADER_VALUES_COLUMN);
    clrtoeol();
    move(1, HEADER_VALUES_COLUMN + 2);
    clrtoeol();

    mvprintw(0, HEADER_VALUES_COLUMN, ": row    = %d", m_rowPosition);
    mvprintw(1, HEADER_VALUES_COLUMN + 2, "column = %d", m_colPosition);

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
movl $0xb, %esi
callq 0x41e0
movq 0x9188(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
callq 0x4300
movl $0x1, %edi
movl $0xd, %esi
callq 0x41e0
movq (%r14), %rdi
callq 0x4300
movl 0x78(%rbx), %ecx
leaq 0x480a(%rip), %rdx      # 0xe663
xorl %edi, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
movl 0x7c(%rbx), %ecx
leaq 0x4800(%rip), %rdx      # 0xe671
movl $0x1, %edi
movl $0xd, %esi
xorl %eax, %eax
callq 0x43d0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderValue() const
void CTableController::renderValue() const {
    move(3, HEADER_VALUES_COLUMN);
    clrtoeol();

    mvprintw(3, HEADER_VALUES_COLUMN, ": %s",
		m_database.getValue(m_rowPosition, m_colPosition).c_str());

    refresh();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x3, %edi
movl $0xb, %esi
callq 0x41e0
movq 0x910c(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
callq 0x4300
leaq 0x8(%rbx), %rsi
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5c8e
movq (%rbx), %rcx
leaq 0x47aa(%rip), %rdx      # 0xe67d
movl $0x3, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9eff
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
callq 0x4550
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f28
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::renderExpression() const
void CTableController::renderExpression() const {
    move(4, HEADER_VALUES_COLUMN);
    clrtoeol();

    mvprintw(4, HEADER_VALUES_COLUMN, ": %s",
		m_database.getExpression(m_rowPosition, m_colPosition).c_str());

    refresh();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x4, %edi
movl $0xb, %esi
callq 0x41e0
movq 0x906a(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
callq 0x4300
leaq 0x8(%rbx), %rsi
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x5e04
movq (%rbx), %rcx
leaq 0x4708(%rip), %rdx      # 0xe67d
movl $0x4, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fa1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
callq 0x4550
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fca
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CSplashscreenController.cpp
// Function: CSplashscreenController::redraw()
void CSplashscreenController::redraw() {
    clear();

    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    init_pair(2, COLOR_RED, COLOR_WHITE);
    attron(A_BOLD | COLOR_PAIR(2));
    mvprintw(0, 1, "Your terminal window is too small!");
    attroff(A_BOLD | COLOR_PAIR(2));

    mvprintw(2, 1, "Make sure it is at least 78x27.");
    mvprintw(3, 1, "Try resizing it.");


    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x4570
movq 0x8f68(%rip), %r14      # 0x12fb8
movq (%r14), %rax
testq %rax, %rax
je 0xa05e
movswl 0x4(%rax), %ebx
jmp 0xa063
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl $0x2, %edi
movl $0x1, %esi
movl $0x7, %edx
callq 0x4050
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x4140
leaq 0x475c(%rip), %rdx      # 0xe7e9
xorl %edi, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x43b0
leaq 0x475b(%rip), %rdx      # 0xe80c
movl $0x2, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x4763(%rip), %rdx      # 0xe82c
movl $0x3, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4310
leaq 0x4359(%rip), %rdx      # 0xe447
movl %ebx, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CWelcomeController.cpp
// Function: CWelcomeController::redraw()
void CWelcomeController::redraw() {
    clear();

    int maxY, maxX;
    getmaxyx(stdscr, maxY, maxX);

    init_pair(2, COLOR_RED, COLOR_WHITE);
    attron(A_BOLD | COLOR_PAIR(2));
    mvprintw(1, 1, " WELCOME TO THE ULTIMATE SPREADSHEET EDITOR! ");
    attroff(A_BOLD | COLOR_PAIR(2));

    attrset(COLOR_PAIR(1));
    mvprintw(maxY - 1, 1, " F3 - go to the spreadsheet ");
    mvprintw(maxY - 1, 30, " F4 - exit ");
    attroff(COLOR_PAIR(1));

    refresh();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x4570
movq 0x8e78(%rip), %r14      # 0x12fb8
movq (%r14), %rax
testq %rax, %rax
je 0xa14e
movswl 0x4(%rax), %ebx
jmp 0xa153
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl $0x2, %edi
movl $0x1, %esi
movl $0x7, %edx
callq 0x4050
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x4140
leaq 0x46da(%rip), %rdx      # 0xe857
movl $0x1, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %edx, %edx
callq 0x43b0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4310
leaq 0x46d4(%rip), %rdx      # 0xe885
movl %ebx, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x4281(%rip), %rdx      # 0xe447
movl %ebx, %edi
movl $0x1e, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %edx, %edx
callq 0x43b0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpArgCount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
unsigned int OpArgCount(const std::string& s) {
    unsigned int val = 1;

    if (s == "*" || s == "/" || s == "%" || s == "+" || s == "-" || s == "="
		|| s == "^" || s == "POW") {
	  val = 2;
    } else if (s == "!") {
	  val = 1;
    }

    return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x46ce(%rip), %rsi      # 0xe8f8
callq 0x40a0
movl $0x2, %ebx
testl %eax, %eax
je 0xa2d9
leaq 0x46b7(%rip), %rsi      # 0xe8fa
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4698(%rip), %rsi      # 0xe8f2
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4687(%rip), %rsi      # 0xe8f4
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4676(%rip), %rsi      # 0xe8f6
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4223(%rip), %rsi      # 0xe4b6
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4121(%rip), %rsi      # 0xe3c7
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x4645(%rip), %rsi      # 0xe8fe
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2d9
leaq 0x453e(%rip), %rsi      # 0xe80a
movq %r14, %rdi
callq 0x40a0
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpPrecedence(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int OpPrecedence(const std::string& s) {
    int precedence = 1;

    if (s == "!") {
	  precedence = 4;
    } else if (s == "*" || s == "/" || s == "%") {
	  precedence = 3;
    } else if (s == "+" || s == "-") {
	  precedence = 2;
    } else if (s == "=") {
	  precedence = 1;
    }

    return precedence;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x451a(%rip), %rsi      # 0xe80a
callq 0x40a0
testl %eax, %eax
je 0xa378
leaq 0x45f8(%rip), %rsi      # 0xe8f8
movq %rbx, %rdi
callq 0x40a0
movl $0x3, %ebp
testl %eax, %eax
je 0xa37d
leaq 0x45e2(%rip), %rsi      # 0xe8fa
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa37d
leaq 0x45c7(%rip), %rsi      # 0xe8f2
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa37d
leaq 0x45b6(%rip), %rsi      # 0xe8f4
movq %rbx, %rdi
callq 0x40a0
movl $0x2, %ebp
testl %eax, %eax
je 0xa37d
leaq 0x45a0(%rip), %rsi      # 0xe8f6
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa37d
leaq 0x414d(%rip), %rsi      # 0xe4b6
movq %rbx, %rdi
callq 0x40a0
movl $0x1, %ebp
jmp 0xa37d
movl $0x4, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: OpLeftAssoc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool OpLeftAssoc(const std::string& s) {
    // left to right
    if (s == "*" || s == "/" || s == "%" || s == "+" || s == "-") {
	  return true;
    }// right to left
    else if (s == "=" || s == "!") {
	  return false;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4565(%rip), %rsi      # 0xe8f8
callq 0x40a0
movb $0x1, %bpl
testl %eax, %eax
je 0xa40f
leaq 0x4554(%rip), %rsi      # 0xe8fa
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa40f
leaq 0x4539(%rip), %rsi      # 0xe8f2
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa40f
leaq 0x4528(%rip), %rsi      # 0xe8f4
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa40f
leaq 0x4517(%rip), %rsi      # 0xe8f6
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa40f
leaq 0x40c4(%rip), %rsi      # 0xe4b6
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa40d
leaq 0x4405(%rip), %rsi      # 0xe80a
movq %rbx, %rdi
callq 0x40a0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsFloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsFloat(const std::string& s) {
    std::istringstream iss(s);
    float f;
    iss >> std::noskipws >> f;
    return iss.eof() && !iss.fail();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x4530
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x28(%rsp,%rax) # imm = 0xFFFFEFFF
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4620
leaq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x30(%rsp,%rax), %eax
andl $0x7, %eax
cmpl $0x2, %eax
sete %bl
movq 0x8667(%rip), %rsi      # 0x12fa8
callq 0x4420
leaq 0x88(%rsp), %rdi
callq 0x40d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x8640(%rip), %rsi      # 0x12fa8
leaq 0x10(%rsp), %rdi
callq 0x4420
leaq 0x88(%rsp), %rdi
callq 0x40d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsNumber(const std::string& s) {
    std::string::const_iterator it = s.begin();
    while (it != s.end() && std::isdigit(*it, std::locale())) {
	  ++it;
    }

    return !s.empty() && it == s.end();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
movq %rsp, %r14
movq (%rbx), %r12
addq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0xa9ce
movzbl (%r15), %r13d
movq %r14, %rdi
callq 0x4630
movq %r14, %rdi
callq 0x4120
movq 0x30(%rax), %rax
movb 0x1(%rax,%r13,2), %bpl
andb $0x8, %bpl
shrb $0x3, %bpl
jmp 0xa9d0
xorl %ebp, %ebp
cmpq %r12, %r15
je 0xa9dd
movq %r14, %rdi
callq 0x4410
testb %bpl, %bpl
je 0xa9e7
incq %r15
jmp 0xa99b
movq 0x8(%rbx), %rax
testq %rax, %rax
setne %cl
addq (%rbx), %rax
cmpq %rax, %r15
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4410
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O1/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: CExpressionParser::ReplaceAll(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void CExpressionParser::ReplaceAll(std::string& str, const std::string& from,
	  const std::string& to) {
    size_t start_pos = 0;

    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
	  str.replace(start_pos, from.length(), to);
	  start_pos += to.length(); // ...
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x4580
cmpq $-0x1, %rax
je 0xb790
movq %rax, %r12
movq 0x8(%r14), %rdx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %r12, %rsi
callq 0x4320
addq 0x8(%rbx), %r12
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq %r12, %rdx
callq 0x4580
movq %rax, %r12
cmpq $-0x1, %rax
jne 0xb75b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./init.cpp
// Function: main
int main(int argc, char** argv) {
	if(argc != 2){
		std::cout << "Usage ./pdg_cs17 [FileName]\n";
		return 1;
	}
	PDG p(argv[1]);
	if(!p.is_valid()) return print_exit();
	p.cdg();
	p.print_cdg();
	p.plot_cdg();
	p.ddg();
	if(!p.is_valid()) return print_exit();
	p.print_ddg();
	p.plot_ddg();
    return 0;
}

// Assembly:
pushq %rbx
subq $0x2a0, %rsp            # imm = 0x2A0
cmpl $0x2, %edi
jne 0x2596
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2622
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x26f0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x253a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21b0
leaq 0x30(%rsp), %rdi
callq 0x2e9c
testb %al, %al
je 0x25b5
leaq 0x30(%rsp), %rdi
callq 0x2ea4
leaq 0x30(%rsp), %rdi
callq 0x3038
leaq 0x30(%rsp), %rdi
callq 0x316e
leaq 0x30(%rsp), %rdi
callq 0x37d4
leaq 0x30(%rsp), %rdi
callq 0x2e9c
testb %al, %al
je 0x25b5
leaq 0x30(%rsp), %rdi
callq 0x3e8a
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x3fbc
jmp 0x25d2
movq 0x6a3b(%rip), %rdi      # 0x8fd8
leaq 0x3a70(%rip), %rsi      # 0x6014
movl $0x1c, %edx
callq 0x2200
movl $0x1, %ebx
jmp 0x25dc
movl $0x1, %ebx
movq 0x6a17(%rip), %rdi      # 0x8fd8
leaq 0x3a3c(%rip), %rsi      # 0x6004
movl $0xf, %edx
callq 0x2200
leaq 0x30(%rsp), %rdi
callq 0x2c80
movl %ebx, %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2619
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21b0
jmp 0x2619
movq %rax, %rbx
jmp 0x2619
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2c80
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::PDG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
PDG::PDG(std::string file_name){
 	valid = false;
 	in.open(file_name,std::ios::in);
 	if(in.fail()){
 		std::cout << "Could not open file\n" << file_name << std::endl;
 		return;
 	} else valid = true;
 	total_lines = 0;
 	if(make_program_map())
 		valid = true;
 	else return;
 	if(!allocate_g_cdg())
 		valid = false;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2220
leaq 0x218(%rbx), %r12
xorl %eax, %eax
movq %rax, 0x228(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x218(%rbx)
leaq 0x230(%rbx), %r14
leaq 0x238(%rbx), %rcx
movl $0x0, 0x238(%rbx)
movq %rax, 0x240(%rbx)
movq %rcx, 0x248(%rbx)
movq %rcx, 0x250(%rbx)
movq %rax, 0x258(%rbx)
movb $0x0, 0x210(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x2280
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x27cd
movq 0x685b(%rip), %rdi      # 0x8fd8
leaq 0x38ec(%rip), %rsi      # 0x6070
movl $0x14, %edx
callq 0x2200
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x683c(%rip), %rdi      # 0x8fd8
callq 0x2200
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
jmp 0x2804
movb $0x1, 0x210(%rbx)
movl $0x0, 0x214(%rbx)
movq %rbx, %rdi
callq 0x2844
testb %al, %al
je 0x2804
movb $0x1, 0x210(%rbx)
movq %rbx, %rdi
callq 0x2bc2
testb %al, %al
jne 0x2804
movb $0x0, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4b24
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2833
movq 0x228(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x20a0
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::allocate_g_cdg()
bool PDG::allocate_g_cdg(){
 	/* Allocate a graph of total_lines^2 size to **g_cdg */
 	g_cdg = (int**)malloc(sizeof(int*) * (total_lines + 1));
 	if(g_cdg == nullptr) return false;
 	for(int i = 0; i <= total_lines;i++){
 		g_cdg[i] = (int*) malloc(sizeof(int)*(total_lines+1));
 		for(int j = 0;j <= total_lines;j++) g_cdg[i][j] = 0;
 		if(g_cdg[i] == nullptr) return false;
 	}
 	return true;
 }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x214(%rdi), %rax
leaq 0x8(,%rax,8), %rdi
callq 0x2260
movq %rax, 0x260(%rbx)
testq %rax, %rax
je 0x2c72
movl 0x214(%rbx), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
testl %eax, %eax
js 0x2c74
xorl %r14d, %r14d
cltq
leaq 0x4(,%rax,4), %rdi
callq 0x2260
movq 0x260(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
cmpl $0x0, 0x214(%rbx)
js 0x2c4b
movq 0x260(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $-0x1, %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movslq 0x214(%rbx), %rdx
incq %rcx
cmpq %rdx, %rcx
jl 0x2c34
movq 0x260(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0x2c74
leaq 0x1(%r14), %rcx
movslq 0x214(%rbx), %rax
cmpq %rax, %r14
setge %bpl
movq %rcx, %r14
jl 0x2bff
jmp 0x2c74
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::get_line_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Line_Type PDG::get_line_type(std::string s){
 	decltype(s.find("")) f;
 	/* Check if string is an if */
 	if((f = s.find("if")) != std::string::npos){
 		if(s[f+2] == ' ' || s[f+2] == '(')
 			return Line_Type::IF;
 	} 	/* Check for else */
 	else if ((f = s.find("else"))!= std::string::npos){
 		if(s[f+4] == ' ' || s[f+4] == '(')
 			return Line_Type::ELSE;
 	} 	/* Checking for while */
 	else if ((f = s.find("while")) != std::string::npos){
 		if(s[f+5] == ' ' || s[f+5] == '(')
 			return Line_Type::WHILE;
 	} 	/* Checking for assignment */
 	else if((f = s.find("=")) != std::string::npos){
 		if(s[f+1]!= '=' && s[f-1] != '!')
 			return Line_Type::ASSIGNMENT;
 	} 	/* Checking for blocl close */
 	else if((f = s.find("}"))!= std::string::npos){
 		return Line_Type::SCOPE_CLOSE;
 	}
 	return ERROR;
 }

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x33ea(%rip), %rsi      # 0x60cf
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d16
movq (%rbx), %rcx
movb 0x2(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal 0x1(,%rcx,4), %eax
jmp 0x2db6
leaq 0x33b5(%rip), %rsi      # 0x60d2
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d4a
movq (%rbx), %rcx
movb 0x4(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal (%rcx,%rcx,2), %eax
addl $0x2, %eax
jmp 0x2db6
leaq 0x3386(%rip), %rsi      # 0x60d7
movl $0x5, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d7f
movq (%rbx), %rcx
movb 0x5(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal 0x3(,%rcx,2), %eax
jmp 0x2db6
leaq 0x3357(%rip), %rsi      # 0x60dd
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2db8
movq %rax, %rcx
movq (%rbx), %rdx
cmpb $0x3d, 0x1(%rdx,%rax)
je 0x2db1
xorl %eax, %eax
cmpb $0x21, -0x1(%rdx,%rcx)
jne 0x2db6
movl $0x5, %eax
popq %rbx
retq
leaq 0x3320(%rip), %rsi      # 0x60df
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
movq %rax, %rcx
movl $0x4, %eax
cmpq $-0x1, %rcx
jne 0x2db6
jmp 0x2db1
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::allocate_g_ddg()
bool PDG::allocate_g_ddg(){
 	/* Allocate a graph of total_lines^2 size to **g_cdg */
 	g_ddg = (int**)malloc(sizeof(int*) * (total_lines+1));
 	if(g_ddg == nullptr) return false;
 	for(int i = 0; i <= total_lines;i++){
 		g_ddg[i] = (int*) malloc(sizeof(int)*(total_lines+1));
 		for(int j = 0;j <= total_lines;j++) g_ddg[i][j] = 0;
 		if(g_ddg[i] == nullptr) return false;
 	}
 	return true;
 }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x214(%rdi), %rax
leaq 0x8(,%rax,8), %rdi
callq 0x2260
movq %rax, 0x268(%rbx)
testq %rax, %rax
je 0x2e8e
movl 0x214(%rbx), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
testl %eax, %eax
js 0x2e90
xorl %r14d, %r14d
cltq
leaq 0x4(,%rax,4), %rdi
callq 0x2260
movq 0x268(%rbx), %rcx
movq %rax, (%rcx,%r14,8)
cmpl $0x0, 0x214(%rbx)
js 0x2e67
movq 0x268(%rbx), %rax
movq (%rax,%r14,8), %rax
movq $-0x1, %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movslq 0x214(%rbx), %rdx
incq %rcx
cmpq %rdx, %rcx
jl 0x2e50
movq 0x268(%rbx), %rax
cmpq $0x0, (%rax,%r14,8)
je 0x2e90
leaq 0x1(%r14), %rcx
movslq 0x214(%rbx), %rax
cmpq %rax, %r14
setge %bpl
movq %rcx, %r14
jl 0x2e1b
jmp 0x2e90
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::print_cdg()
void PDG::print_cdg(){
 	std::printf("CDG\n   ");
 	for(int i = 0; i <= total_lines;i++)
 		std::printf("%3d ",i);
 	std::cout << std::endl;
 	for(int i = 0; i <= total_lines;i++){
 		std::printf("%3d",i);
 		std::cout.flush();
 		for(int j = 0; j <= total_lines; j++){
 			std::printf("%3d ",g_cdg[i][j]);
 			std::cout.flush();
 		}
 		std::cout << std::endl;
 	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30b7(%rip), %rdi      # 0x6104
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x214(%rbx)
js 0x307f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x30a3(%rip), %r14      # 0x610c
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
cmpl 0x214(%rbx), %ebp
jl 0x3069
movq 0x5f52(%rip), %r14      # 0x8fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
cmpl $0x0, 0x214(%rbx)
js 0x315e
leaq 0x3050(%rip), %r15      # 0x6111
leaq 0x3044(%rip), %r12      # 0x610c
xorl %r13d, %r13d
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2120
cmpl $0x0, 0x214(%rbx)
js 0x3120
movq $-0x1, %rbp
movq 0x260(%rbx), %rax
movq (%rax,%r13,8), %rax
movl 0x4(%rax,%rbp,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2120
movslq 0x214(%rbx), %rax
incq %rbp
cmpq %rax, %rbp
jl 0x30f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x1(%r13), %rax
movslq 0x214(%rbx), %rcx
cmpq %rcx, %r13
movq %rax, %r13
jl 0x30cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::print_ddg()
void PDG::print_ddg(){
 	std::printf("\nDDG\n   ");
 	for(int i = 1; i <= total_lines;i++)
 		std::printf("%3d ",i);
 	std::cout << std::endl;
 	for(int i = 1; i <= total_lines;i++){
 		std::printf("%3d",i);
 		std::cout.flush();
 		for(int j = 1; j <= total_lines; j++){
 			std::printf("%3d ",g_ddg[i][j]);
 			std::cout.flush();
 		}
 		std::cout << std::endl;
 	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22e8(%rip), %rdi      # 0x6187
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x214(%rbx)
jle 0x3ece
leaq 0x2256(%rip), %r14      # 0x610c
xorl %ebp, %ebp
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
cmpl 0x214(%rbx), %ebp
jl 0x3eb8
movq 0x5103(%rip), %r14      # 0x8fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
cmpl $0x0, 0x214(%rbx)
jle 0x3fac
movl $0x1, %r12d
leaq 0x21fb(%rip), %r15      # 0x6111
leaq 0x21ef(%rip), %r13      # 0x610c
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2120
cmpl $0x0, 0x214(%rbx)
jle 0x3f6d
xorl %ebp, %ebp
movq 0x268(%rbx), %rax
movq (%rax,%r12,8), %rax
movl 0x4(%rax,%rbp,4), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2120
movslq 0x214(%rbx), %rax
incq %rbp
cmpq %rax, %rbp
jl 0x3f3d
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2120
leaq 0x1(%r12), %rax
movslq 0x214(%rbx), %rcx
cmpq %rcx, %r12
movq %rax, %r12
jl 0x3f1d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]codecon/src/compliance.cc
// Function: main
int main() {
  auto word = std::string{};
  std::cin >> word;

  if (check(word)) {
    std::cout << "yes\n";
  } else {
    std::cout << "no\n";
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x2ce4(%rip), %rdi      # 0x3fe0
leaq 0x8(%rsp), %rsi
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x122c
leaq 0xced(%rip), %rcx       # 0x2004
leaq 0xceb(%rip), %rsi       # 0x2009
testb %al, %al
cmovneq %rcx, %rsi
movzbl %al, %edx
addq $0x3, %rdx
movq 0x2c9e(%rip), %rdi      # 0x3fd0
callq 0x10b0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x134e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1090
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1372
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/main/db_lsm.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	std::cout
		<< "Usage:"	<< '\n'
		<< "\t"		<< cmd	<< " r [lsm_path] [key] - load lsm_path, then search for the key"	<< '\n'
		<< "\t"		<< cmd	<< " l [lsm_path] -     - load lsm_path, then list using iterator"	<< '\n'
		<< "\t"		<< cmd	<< " l [lsm_path] [key] - load lsm_path, then list using iterator"	<< '\n'

		<< "\t\tPath names must be written without extention"		<< '\n'
		<< "\t\tExample 'directory/file.*'"				<< '\n'

		<< '\n';
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8774(%rip), %r14      # 0xafd0
leaq 0x47a1(%rip), %rsi      # 0x7004
movl $0x6, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0x9(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x477c(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x28b9
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x28d3
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x4733(%rip), %rsi      # 0x700d
movl $0x3c, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0xa(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x4705(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x2930
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x294a
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x46f9(%rip), %rsi      # 0x704a
movl $0x3d, %edx
movq %r14, %rdi
callq 0x21f0
leaq 0xb(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq %rax, %r14
leaq 0x468e(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x29a7
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x29c1
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x46c0(%rip), %rsi      # 0x7088
movl $0x3d, %edx
movq %r14, %rdi
callq 0x21f0
movb $0xa, %bpl
leaq 0xc(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21f0
movq %rax, %rbx
leaq 0x46cf(%rip), %rsi      # 0x70c6
movl $0x2e, %edx
movq %rax, %rdi
callq 0x21f0
leaq 0xd(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rbx
leaq 0x46d2(%rip), %rsi      # 0x70f5
movl $0x1c, %edx
movq %rax, %rdi
callq 0x21f0
leaq 0xe(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x21f0
leaq 0xf(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/btbujiangjun[P]abcdl/example/sessionq.cpp
// Function: SessionQ::pass(abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>)
void pass(abcdl::algebra::Mat train_data,
              abcdl::algebra::Mat train_label,
              abcdl::algebra::Mat test_data,
              abcdl::algebra::Mat test_label){
        real loss = 0;
        fnn.train(train_data, train_label);
        fnn.evaluate(test_data, test_label, &loss);
        fnn.write_model();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
movl $0x0, (%r12)
callq 0x253c4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x25c3c
leaq 0x10(%r15), %rsi
movq %r15, %rdi
callq 0x267a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Get(hlkvds::DB*)
void Get(hlkvds::DB *db) {
    int key_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        key_len = key.length();
        std::string get_data;
        db->Get(key.c_str(), key_len, get_data);
        std::cout << "Get Item Success. key = " << key << " ,value = "
                << get_data << std::endl;
    }

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x6310
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x66d0
leaq 0x68(%rsp), %rsi
movq %rsp, %rdi
callq 0x6630
movl 0x8(%rsp), %ecx
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq (%rsp), %rdx
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %r8
movq %rbx, %rsi
callq 0x129f2
movq 0x296ae(%rip), %rdi     # 0x32fd0
leaq 0x176db(%rip), %rsi     # 0x21004
movl $0x18, %edx
callq 0x6490
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x2968d(%rip), %rdi     # 0x32fd0
callq 0x6490
movq %rax, %rbx
leaq 0x176cb(%rip), %rsi     # 0x2101d
movl $0xa, %edx
movq %rax, %rdi
callq 0x6490
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x6490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x99aa
callq 0x6430
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x99bd
callq 0x6430
movq 0x295e4(%rip), %rsi     # 0x32fa8
leaq 0x50(%rsp), %rdi
callq 0x6360
leaq 0xd0(%rsp), %rdi
callq 0x6140
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
jmp 0x99e8
movq %rax, %rbx
jmp 0x9a12
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x99ff
callq 0x6430
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9a12
callq 0x6430
movq 0x2958f(%rip), %rsi     # 0x32fa8
leaq 0x50(%rsp), %rdi
callq 0x6360
leaq 0xd0(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Insert(hlkvds::DB*)
void Insert(hlkvds::DB *db) {
    int key_len;
    int value_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        std::string value = "Begin" + key + "End";
        key_len = key.length();
        value_len = value.length();
        db->Insert(key.c_str(), key_len, value.c_str(), value_len);
        std::cout << "Insert Item Success. key = " << key << " ,value = "
                << value << std::endl;
    }

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x80(%rsp), %rdi
callq 0x6310
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
callq 0x66d0
leaq 0x98(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x6630
leaq 0x175ae(%rip), %rsi     # 0x21028
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x9ef4
leaq 0x1759e(%rip), %rsi     # 0x2102e
leaq 0x50(%rsp), %rdi
callq 0x6780
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x9ac1
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x9ac8
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9af3
callq 0x6430
movl 0x38(%rsp), %ecx
movzwl 0x18(%rsp), %r9d
movq 0x30(%rsp), %rdx
movq 0x10(%rsp), %r8
movl $0x0, (%rsp)
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x12926
movq 0x294ae(%rip), %rdi     # 0x32fd0
leaq 0x17509(%rip), %rsi     # 0x21032
movl $0x1b, %edx
callq 0x6490
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x2948c(%rip), %rdi     # 0x32fd0
callq 0x6490
movq %rax, %rbx
leaq 0x174ca(%rip), %rsi     # 0x2101d
movl $0xa, %edx
movq %rax, %rdi
callq 0x6490
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x6490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x9bab
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9bbe
callq 0x6430
movq 0x293e3(%rip), %rsi     # 0x32fa8
leaq 0x80(%rsp), %rdi
callq 0x6360
leaq 0x100(%rsp), %rdi
callq 0x6140
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x9c16
jmp 0x9c1b
movq %rax, %rbx
jmp 0x9c1b
jmp 0x9c04
movq %rax, %rbx
jmp 0x9c2e
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x9c1b
callq 0x6430
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9c2e
callq 0x6430
movq 0x29373(%rip), %rsi     # 0x32fa8
leaq 0x80(%rsp), %rdi
callq 0x6360
leaq 0x100(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O1/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Delete(hlkvds::DB*)
void Delete(hlkvds::DB *db) {
    int key_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        key_len = key.length();
        db->Delete(key.c_str(), key_len);
        std::cout << "Delete Item Success. key = " << key << std::endl;
    }

}

// Assembly:
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6310
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x66d0
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6630
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x12990
movq 0x2932c(%rip), %rdi     # 0x32fd0
leaq 0x173a3(%rip), %rsi     # 0x2104e
movl $0x1b, %edx
callq 0x6490
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x2930a(%rip), %rdi     # 0x32fd0
callq 0x6490
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6440
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d08
callq 0x6430
movq 0x29299(%rip), %rsi     # 0x32fa8
leaq 0x38(%rsp), %rdi
callq 0x6360
leaq 0xb8(%rsp), %rdi
callq 0x6140
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x9d31
movq %rax, %rbx
jmp 0x9d4c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d4c
callq 0x6430
movq 0x29255(%rip), %rsi     # 0x32fa8
leaq 0x38(%rsp), %rdi
callq 0x6360
leaq 0xb8(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66e0
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/exprtk_simple_example_20.cpp
// Function: vector_access_rtc::handle_runtime_violation(exprtk::vector_access_runtime_check::violation_context&)
bool handle_runtime_violation(violation_context& context)
   {
      const map_t::iterator itr     = vector_map.find(static_cast<void*>(context.base_ptr));
      const std::string vector_name = (itr != vector_map.end()) ?
                                      itr->second : "Unknown"   ;

      printf("Runtime vector access violation\n"
             "Vector: %s base: %p end: %p access: %p typesize: %d\n",
             vector_name.c_str(),
             context.base_ptr   ,
             context.end_ptr    ,
             context.access_ptr ,
             static_cast<unsigned int>(context.type_size));

      throw std::runtime_error
         ("Runtime vector access violation. Vector: " + vector_name);

      return false;
   }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x18(%rdi), %rdx
addq $0x10, %rdi
movq %rdi, %rcx
testq %rdx, %rdx
je 0x11b45b
movq %rdi, %rcx
xorl %esi, %esi
cmpq %rax, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x11b443
movq %rdi, %rdx
cmpq %rdi, %rcx
je 0x11b46e
cmpq 0x20(%rcx), %rax
cmovbq %rdi, %rcx
movq %rcx, %rdx
leaq 0x10(%rsp), %rax
cmpq %rdi, %rdx
jne 0x11b494
movq %rax, -0x10(%rax)
leaq 0x1ae54a(%rip), %rsi    # 0x2c99cd
leaq 0x1ae54a(%rip), %rdx    # 0x2c99d4
movq %rsp, %rdi
callq 0x119b74
jmp 0x11b4ab
movq %rax, -0x10(%rax)
movq 0x28(%rdx), %rsi
movq 0x30(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x11b5f6
movq %rsp, %r14
movq (%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %r8
movl 0x18(%rbx), %r9d
leaq 0x1ae50e(%rip), %rdi    # 0x2c99d5
xorl %eax, %eax
callq 0x116050
movl $0x10, %edi
callq 0x1161d0
movq %rax, %rbx
leaq 0x1ae548(%rip), %rsi    # 0x2c9a2a
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x11b56d
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x116140
xorl %ebp, %ebp
movq 0x31aae0(%rip), %rsi    # 0x435fe8
movq 0x31aad1(%rip), %rdx    # 0x435fe0
movq %rbx, %rdi
callq 0x1162d0
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11b53d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x116090
jmp 0x11b53d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x11b54a
movq %rbx, %rdi
callq 0x116440
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11b565
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x116090
movq %r14, %rdi
callq 0x1162f0
// File: /workspace/github_cpp_makefile_star2_O1/czinn[P]homeworlds/game.cc
// Function: operator==(Action const&, Action const&)
bool operator==(const Action& lhs, const Action& rhs) {
  return lhs.type == rhs.type &&
    lhs.system == rhs.system &&
    lhs.ship == rhs.ship &&
    lhs.system_target == rhs.system_target &&
    lhs.target == rhs.target;
}

// Assembly:
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x268c
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x268c
movl 0xc(%rdi), %ecx
xorl %eax, %eax
cmpl 0xc(%rsi), %ecx
jne 0x268b
movl 0x10(%rsi), %ecx
cmpl %ecx, 0x10(%rdi)
jne 0x268b
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
jne 0x268c
movl 0x18(%rdi), %eax
xorl 0x18(%rsi), %eax
movl 0x1c(%rsi), %ecx
xorl 0x1c(%rdi), %ecx
orl %eax, %ecx
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/czinn[P]homeworlds/game.cc
// Function: operator<(Action const&, Action const&)
bool operator<(const Action& lhs, const Action& rhs) {
  if (lhs.type < rhs.type) return true;
  if (lhs.type > rhs.type) return false;
  if (lhs.system < rhs.system) return true;
  if (lhs.system > rhs.system) return false;
  if (lhs.ship < rhs.ship) return true;
  if (!(lhs.ship == rhs.ship)) return false;
  if (lhs.system_target < rhs.system_target) return true;
  if (lhs.system_target > rhs.system_target) return false;
  if (lhs.target < rhs.target) return true;
  return false;
}

// Assembly:
movl 0x4(%rdi), %eax
movl 0x4(%rsi), %ecx
cmpl %ecx, %eax
jge 0x269c
movb $0x1, %al
retq
jle 0x26a1
xorl %eax, %eax
retq
movl 0x8(%rdi), %eax
movl 0x8(%rsi), %ecx
cmpl %ecx, %eax
jl 0x2699
jg 0x269e
movl 0xc(%rdi), %ecx
movl 0xc(%rsi), %edx
cmpl %edx, %ecx
jl 0x2699
jne 0x26c1
movl 0x10(%rdi), %eax
cmpl 0x10(%rsi), %eax
jl 0x2699
xorl %eax, %eax
cmpl %edx, %ecx
jne 0x269b
movl 0x10(%rsi), %ecx
cmpl %ecx, 0x10(%rdi)
jne 0x269b
movl 0x14(%rdi), %eax
movl 0x14(%rsi), %ecx
cmpl %ecx, %eax
jl 0x2699
jg 0x269e
movl 0x18(%rdi), %ecx
movl 0x18(%rsi), %edx
movb $0x1, %al
cmpl %edx, %ecx
jl 0x269b
jne 0x269e
movl 0x1c(%rdi), %eax
cmpl 0x1c(%rsi), %eax
setl %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/czinn[P]homeworlds/game.cc
// Function: Game::Game(int)
Game::Game(int num_players) :
    num_players_(num_players),
    cur_player_(1),
    done_main_action_(false),
    homeworlds_built_(0),
    next_system_(1),
    sacrifice_actions_(0),
    sacrifice_colour_(RED) {
  for (const auto colour : { RED, YELLOW, GREEN, BLUE }) {
    for (const auto size : { SMALL, MEDIUM, LARGE }) {
      Pyramid p { size, colour };
      stash_[p] = 1 + num_players;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movl %esi, (%rdi)
movl $0x1, 0x4(%rdi)
movb $0x0, 0x8(%rdi)
movsd 0x88f7(%rip), %xmm0     # 0xb010
movups %xmm0, 0xc(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
xorl %r12d, %r12d
movq %r12, 0x30(%rdi)
leaq 0x38(%rdi), %r14
leaq 0x40(%rdi), %rax
movl $0x0, 0x40(%rdi)
movq %r12, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %r12, 0x60(%rdi)
movaps 0x88c6(%rip), %xmm0     # 0xb020
movups %xmm0, 0x28(%rsp)
incl %ebp
leaq 0x8(%rsp), %r15
movl 0x28(%rsp,%r12), %ebx
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x1c(%rsp)
movl $0x3, 0x24(%rsp)
xorl %r13d, %r13d
movl 0x1c(%rsp,%r13), %eax
movl %eax, 0x8(%rsp)
movl %ebx, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x434e
movl %ebp, (%rax)
addq $0x4, %r13
cmpq $0xc, %r13
jne 0x2785
addq $0x4, %r12
cmpq $0x10, %r12
jne 0x2766
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x45a4
movq 0x10(%rsp), %rdi
callq 0x43d8
movq %r15, %rdi
callq 0x22d0
nop