LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/havluj[P]spreadsheet/src/CRuntime.cpp
// Function: CRuntime::CRuntime()
CRuntime::CRuntime() : m_currentView(-1) {
    m_controller = NULL;

    initscr();
    keypad(stdscr, TRUE);
    if (has_colors()) {
	  start_color();
    }
    init_pair(1, COLOR_BLACK, COLOR_WHITE);

    m_controllers.insert(std::make_pair((int) SPLASHSCREEN_VIEW, new CSplashscreenController()));
    m_controllers.insert(std::make_pair((int) WELCOME_VIEW, new CWelcomeController()));
    m_controllers.insert(std::make_pair((int) TABLE_VIEW, new CTableController()));
    m_controllers.insert(std::make_pair((int) HELP_VIEW, new CHelpController()));

    try {
	  changeView(WELCOME_VIEW);
    } catch (const std::invalid_argument& e) {
	  throw e;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0xa69d(%rip), %rax      # 0x12c58
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
leaq 0x10(%rdi), %rax
movl $0x0, 0x10(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %rcx, 0x40(%rdi)
callq 0x4460
movq 0xa9c2(%rip), %rax      # 0x12fb8
movq (%rax), %rdi
movl $0x1, %esi
callq 0x4100
callq 0x44b0
testb %al, %al
je 0x8611
callq 0x4080
movl $0x1, %edi
xorl %esi, %esi
movl $0x7, %edx
callq 0x4050
movl $0x8, %edi
callq 0x42c0
leaq 0xa68d(%rip), %rcx      # 0x12cc0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8c28
movl $0x8, %edi
callq 0x42c0
leaq 0xa6a8(%rip), %rcx      # 0x12d08
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x1, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8d6e
movl $0x88, %edi
callq 0x42c0
movq %rax, %r15
movq %rax, %rdi
callq 0x909c
movq %rsp, %rsi
movl $0x2, (%rsi)
movq %r15, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8e0a
movl $0x8, %edi
callq 0x42c0
leaq 0xa3f1(%rip), %rcx      # 0x12aa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %rsi
movl $0x3, (%rsi)
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x8ea6
movq %r14, %rdi
movl $0x1, %esi
callq 0x8778
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8768
movq %r14, %rdi
callq 0x4110
movq %rax, %r14
movl $0x10, %edi
callq 0x4150
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4520
movq 0xa884(%rip), %rax      # 0x12fa0
addq $0x10, %rax
movq %rax, (%r15)
movq 0xa8b6(%rip), %rsi      # 0x12fe0
movq 0xa897(%rip), %rdx      # 0x12fc8
movq %r15, %rdi
callq 0x4560
movq %rax, %r14
callq 0x4510
jmp 0x8768
movq %rax, %rdi
callq 0x5314
movq %rax, %r14
movl $0x88, %esi
movq %r15, %rdi
callq 0x42d0
jmp 0x8768
jmp 0x8765
jmp 0x8765
jmp 0x8765
jmp 0x8765
movq %rax, %r14
movq %rbx, %rdi
callq 0x8bd8
movq %r14, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/havluj[P]spreadsheet/src/CRuntime.cpp
// Function: CRuntime::changeView(int)
void CRuntime::changeView(int view) {
    auto it = m_controllers.find(view);
    if (it == m_controllers.end()) {
	  throw std::invalid_argument("unknown view");
    }


    m_currentView = view;
    m_controller = m_controllers[view];

    m_controller->redraw();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x87da
movq %rdi, %rbx
leaq 0x10(%rdi), %rdx
movq %rdx, %rcx
xorl %edi, %edi
cmpl %esi, 0x20(%rax)
setl %dil
cmovgeq %rax, %rcx
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x8793
cmpq %rdx, %rcx
je 0x87da
cmpl %esi, 0x20(%rcx)
jg 0x87da
leaq 0x8(%rbx), %rdi
movl %esi, 0x38(%rbx)
leaq 0x4(%rsp), %rsi
callq 0x8b72
movq (%rax), %rdi
movq %rdi, 0x40(%rbx)
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x4150
movq %rax, %rbx
leaq 0x5e3a(%rip), %rsi      # 0xe628
movq %rax, %rdi
callq 0x4600
movq 0xa7e3(%rip), %rsi      # 0x12fe0
movq 0xa7c4(%rip), %rdx      # 0x12fc8
movq %rbx, %rdi
callq 0x4560
movq %rax, %r14
movq %rbx, %rdi
callq 0x4210
movq %r14, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::handleKey(int)
void CTableController::handleKey(int key) {
    switch (key) {
	  case 'e':
	  case 'E':
		editExpression();
		break;

	  case KEY_DOWN:
		changeLocation(m_rowPosition + 1, m_colPosition);
		break;

	  case KEY_UP:
		changeLocation(m_rowPosition - 1, m_colPosition);
		break;

	  case KEY_RIGHT:
		changeLocation(m_rowPosition, m_colPosition + 1);
		break;

	  case KEY_LEFT:
		changeLocation(m_rowPosition, m_colPosition - 1);
		break;

	  default:
		break;
    }
}

// Assembly:
leal -0x102(%rsi), %eax
cmpl $0x3, %eax
ja 0x9152
leaq 0x5514(%rip), %rcx      # 0xe650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %esi
jmp 0x9352
cmpl $0x65, %esi
je 0x918e
cmpl $0x45, %esi
jne 0x9165
jmp 0x918e
retq
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %edx
jmp 0x9352
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
incl %edx
jmp 0x9352
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
decl %esi
jmp 0x9352
nop
// File: /workspace/github_cpp_makefile_star2_O3/havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::editExpression()
void CTableController::editExpression() {
    echo();
    curs_set(1);

    move(4, HEADER_VALUES_COLUMN + 2);
    clrtoeol();

    char str[66];

    move(4, HEADER_VALUES_COLUMN + 2);
    // push already existing expression into the buffer
    std::string expression = m_database.getExpression(m_rowPosition, m_colPosition);
    for (int i = ((int) expression.length() - 1); i >= 0; i--) {
	  ungetch(expression.at(i));
    }
    getnstr(str, 65);

    expression = str;
    m_database.updateElement(m_rowPosition, m_colPosition, expression);

    noecho();
    curs_set(0);

    renderValue();
    renderTable();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x40c0
movl $0x1, %edi
callq 0x4270
movl $0x4, %edi
movl $0xd, %esi
callq 0x41e0
movq 0x9df1(%rip), %r12      # 0x12fb8
movq (%r12), %rdi
callq 0x4300
movl $0x4, %edi
movl $0xd, %esi
callq 0x41e0
leaq 0x8(%rbx), %r14
movl 0x78(%rbx), %edx
movl 0x7c(%rbx), %ecx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e16
movl 0x8(%r15), %r15d
decq %r15
leal 0x1(%r15), %eax
testl %eax, %eax
jle 0x9227
movq 0x8(%rsp), %rdx
cmpq %r15, %rdx
jbe 0x92fa
movq (%rsp), %rax
movsbl (%rax,%r15), %edi
decq %r15
callq 0x43c0
jmp 0x91fe
movq (%r12), %rdi
leaq 0x40(%rsp), %rsi
movl $0x41, %edx
callq 0x4470
movq %rsp, %r15
movq 0x8(%r15), %r12
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x4130
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x44a0
movl 0x78(%rbx), %ebp
movl 0x7c(%rbx), %r15d
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x5370
leaq 0x20(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movl %r15d, %edx
callq 0x57f6
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x92b1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
callq 0x4340
xorl %edi, %edi
callq 0x4270
movq %rbx, %rdi
callq 0x9df0
movq %rbx, %rdi
callq 0x9480
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x92e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x53e3(%rip), %rdi      # 0xe6e4
movq %r15, %rsi
xorl %eax, %eax
callq 0x4480
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x932e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42d0
jmp 0x932e
jmp 0x932b
jmp 0x932b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9349
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9361
retq
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x78(%rdi)
movl %edx, 0x7c(%rdi)
callq 0x9d78
movq %rbx, %rdi
callq 0x9df0
movq %rbx, %rdi
callq 0x9e92
movq %rbx, %rdi
popq %rbx
jmp 0x9480
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x93ae
movq %rbx, %rdi
callq 0x9480
callq 0x9cf6
popq %rbx
jmp 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9bfc(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x52c0(%rip), %rdx      # 0xe692
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 0x9d78
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x528e(%rip), %rdx      # 0xe69b
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 0x9df0
movq (%r14), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %edx, %edx
callq 0x4140
leaq 0x525b(%rip), %rdx      # 0xe6a6
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 0x9e92
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x92b7(%rip), %r14      # 0x12fb8
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9d0f
movswl 0x4(%rdi), %ebx
jmp 0x9d14
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
movl $0x100, %esi            # imm = 0x100
callq 0x4310
leaq 0x4999(%rip), %rdx      # 0xe6be
movl %ebx, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x499e(%rip), %rdx      # 0xe6d8
movl %ebx, %edi
movl $0x1b, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x46f8(%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_O3/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 0x9226(%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 0x48b8(%rip), %rdx      # 0xe673
xorl %edi, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
movl 0x7c(%rbx), %ecx
leaq 0x48ae(%rip), %rdx      # 0xe681
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_O3/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 0x91aa(%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 0x5ca0
movq (%rbx), %rcx
leaq 0x4858(%rip), %rdx      # 0xe68d
movl $0x3, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e61
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 0x9e8a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9108(%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 0x5e16
movq (%rbx), %rcx
leaq 0x47b6(%rip), %rdx      # 0xe68d
movl $0x4, %edi
movl $0xb, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f03
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 0x9f2c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42d0
movq %rbx, %rdi
callq 0x45a0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9004(%rip), %r14      # 0x12fb8
movq (%r14), %rax
testq %rax, %rax
je 0x9fc2
movswl 0x4(%rax), %ebx
jmp 0x9fc7
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 0x4808(%rip), %rdx      # 0xe7f9
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 0x4807(%rip), %rdx      # 0xe81c
movl $0x2, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x480f(%rip), %rdx      # 0xe83c
movl $0x3, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
movq (%r14), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x4310
leaq 0x43f5(%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_O3/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 0x8f14(%rip), %r14      # 0x12fb8
movq (%r14), %rax
testq %rax, %rax
je 0xa0b2
movswl 0x4(%rax), %ebx
jmp 0xa0b7
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 0x4786(%rip), %rdx      # 0xe867
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 0x4780(%rip), %rdx      # 0xe895
movl %ebx, %edi
movl $0x1, %esi
xorl %eax, %eax
callq 0x43d0
leaq 0x431d(%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_O3/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 0x477a(%rip), %rsi      # 0xe908
callq 0x40a0
movl $0x2, %ebx
testl %eax, %eax
je 0xa23d
leaq 0x4763(%rip), %rsi      # 0xe90a
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x4744(%rip), %rsi      # 0xe902
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x4733(%rip), %rsi      # 0xe904
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x4722(%rip), %rsi      # 0xe906
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x42bf(%rip), %rsi      # 0xe4b6
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x41bd(%rip), %rsi      # 0xe3c7
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x46f1(%rip), %rsi      # 0xe90e
movq %r14, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa23d
leaq 0x45ea(%rip), %rsi      # 0xe81a
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_O3/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 0x45c6(%rip), %rsi      # 0xe81a
callq 0x40a0
testl %eax, %eax
je 0xa2dc
leaq 0x46a4(%rip), %rsi      # 0xe908
movq %rbx, %rdi
callq 0x40a0
movl $0x3, %ebp
testl %eax, %eax
je 0xa2e1
leaq 0x468e(%rip), %rsi      # 0xe90a
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2e1
leaq 0x4673(%rip), %rsi      # 0xe902
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2e1
leaq 0x4662(%rip), %rsi      # 0xe904
movq %rbx, %rdi
callq 0x40a0
movl $0x2, %ebp
testl %eax, %eax
je 0xa2e1
leaq 0x464c(%rip), %rsi      # 0xe906
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa2e1
leaq 0x41e9(%rip), %rsi      # 0xe4b6
movq %rbx, %rdi
callq 0x40a0
movl $0x1, %ebp
jmp 0xa2e1
movl $0x4, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4611(%rip), %rsi      # 0xe908
callq 0x40a0
movb $0x1, %bpl
testl %eax, %eax
je 0xa373
leaq 0x4600(%rip), %rsi      # 0xe90a
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa373
leaq 0x45e5(%rip), %rsi      # 0xe902
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa373
leaq 0x45d4(%rip), %rsi      # 0xe904
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa373
leaq 0x45c3(%rip), %rsi      # 0xe906
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa373
leaq 0x4160(%rip), %rsi      # 0xe4b6
movq %rbx, %rdi
callq 0x40a0
testl %eax, %eax
je 0xa371
leaq 0x44b1(%rip), %rsi      # 0xe81a
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_O3/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 0x8709(%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 0x86e2(%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_O3/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 0x26f8
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 0x2e72
testb %al, %al
je 0x25b5
leaq 0x30(%rsp), %rdi
callq 0x2e7a
leaq 0x30(%rsp), %rdi
callq 0x3064
leaq 0x30(%rsp), %rdi
callq 0x319a
leaq 0x30(%rsp), %rdi
callq 0x37fe
leaq 0x30(%rsp), %rdi
callq 0x2e72
testb %al, %al
je 0x25b5
leaq 0x30(%rsp), %rdi
callq 0x3eb4
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x3fe6
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 0x2c6c
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 0x2c6c
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27d5
movq 0x6853(%rip), %rdi      # 0x8fd8
leaq 0x38e4(%rip), %rsi      # 0x6070
movl $0x14, %edx
callq 0x2200
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x6834(%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 0x280c
movb $0x1, 0x210(%rbx)
movl $0x0, 0x214(%rbx)
movq %rbx, %rdi
callq 0x284c
testb %al, %al
je 0x280c
movb $0x1, 0x210(%rbx)
movq %rbx, %rdi
callq 0x2bc4
testb %al, %al
jne 0x280c
movb $0x0, 0x210(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4b56
movq (%r12), %rdi
testq %rdi, %rdi
je 0x283b
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_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x214(%rdi), %r12
leaq 0x8(,%r12,8), %rdi
callq 0x2260
movq %rax, 0x260(%r14)
testq %rax, %rax
je 0x2c58
movb $0x1, %bl
testl %r12d, %r12d
js 0x2c5a
movq %rax, %r15
xorl %r13d, %r13d
movslq %r12d, %rbp
leaq 0x4(,%rbp,4), %rdi
callq 0x2260
movq %rax, (%r15,%r13,8)
movq 0x260(%r14), %r15
movq (%r15,%r13,8), %rax
testl %ebp, %ebp
js 0x2c42
movq $-0x1, %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movslq 0x214(%r14), %r12
incq %rcx
cmpq %r12, %rcx
jl 0x2c29
jmp 0x2c47
testq %rax, %rax
je 0x2c58
leaq 0x1(%r13), %rax
movslq %r12d, %rcx
cmpq %rcx, %r13
movq %rax, %r13
jl 0x2bff
jmp 0x2c5a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33fe(%rip), %rsi      # 0x60cf
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d02
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 0x2da2
leaq 0x33c9(%rip), %rsi      # 0x60d2
movl $0x4, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d36
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 0x2da2
leaq 0x339a(%rip), %rsi      # 0x60d7
movl $0x5, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2d6b
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 0x2da2
leaq 0x336b(%rip), %rsi      # 0x60dd
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
cmpq $-0x1, %rax
je 0x2da4
movq %rax, %rcx
movq (%rbx), %rdx
cmpb $0x3d, 0x1(%rdx,%rax)
je 0x2d9d
xorl %eax, %eax
cmpb $0x21, -0x1(%rdx,%rcx)
jne 0x2da2
movl $0x5, %eax
popq %rbx
retq
leaq 0x3334(%rip), %rsi      # 0x60df
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2300
movq %rax, %rcx
movl $0x4, %eax
cmpq $-0x1, %rcx
jne 0x2da2
jmp 0x2d9d
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq 0x214(%rdi), %r12
leaq 0x8(,%r12,8), %rdi
callq 0x2260
movq %rax, 0x268(%r14)
testq %rax, %rax
je 0x2e5e
movb $0x1, %bl
testl %r12d, %r12d
js 0x2e60
movq %rax, %r15
xorl %r13d, %r13d
movslq %r12d, %rbp
leaq 0x4(,%rbp,4), %rdi
callq 0x2260
movq %rax, (%r15,%r13,8)
movq 0x268(%r14), %r15
movq (%r15,%r13,8), %rax
testl %ebp, %ebp
js 0x2e48
movq $-0x1, %rcx
movl $0x0, 0x4(%rax,%rcx,4)
movslq 0x214(%r14), %r12
incq %rcx
cmpq %r12, %rcx
jl 0x2e2f
jmp 0x2e4d
testq %rax, %rax
je 0x2e5e
leaq 0x1(%r13), %rax
movslq %r12d, %rcx
cmpq %rcx, %r13
movq %rax, %r13
jl 0x2e05
jmp 0x2e60
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x308b(%rip), %rdi      # 0x6104
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x214(%rbx)
js 0x30ab
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
leaq 0x3077(%rip), %r14      # 0x610c
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
cmpl 0x214(%rbx), %ebp
jl 0x3095
movq 0x5f26(%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 0x318a
leaq 0x3024(%rip), %r15      # 0x6111
leaq 0x3018(%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 0x314c
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 0x311c
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 0x30f7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22be(%rip), %rdi      # 0x6187
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x214(%rbx)
jle 0x3ef8
leaq 0x222c(%rip), %r14      # 0x610c
xorl %ebp, %ebp
incl %ebp
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
cmpl 0x214(%rbx), %ebp
jl 0x3ee2
movq 0x50d9(%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 0x3fd6
movl $0x1, %r12d
leaq 0x21d1(%rip), %r15      # 0x6111
leaq 0x21c5(%rip), %r13      # 0x610c
movq %r15, %rdi
movl %r12d, %esi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x2120
cmpl $0x0, 0x214(%rbx)
jle 0x3f97
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 0x3f67
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 0x3f47
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2cea(%rip), %rdi      # 0x3fe0
leaq 0x8(%rsp), %rsi
callq 0x10d0
leaq 0x8(%rsp), %rdi
callq 0x122c
leaq 0xcf3(%rip), %rcx       # 0x2004
leaq 0xcf1(%rip), %rsi       # 0x2009
testb %al, %al
cmovneq %rcx, %rsi
movzbl %al, %edx
addq $0x3, %rdx
movq 0x2ca4(%rip), %rdi      # 0x3fd0
callq 0x10b0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x1348
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 0x136c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8776(%rip), %r14      # 0xafd0
leaq 0x47a3(%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 0x477e(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x28b7
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x28d1
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x4735(%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 0x4707(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x292e
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x2948
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x46fb(%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 0x4690(%rip), %rsi      # 0x700b
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
testq %rbx, %rbx
je 0x29a5
movq %rbx, %rdi
callq 0x20b0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0x29bf
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x22c0
leaq 0x46c2(%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 0x46d1(%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 0x46d4(%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_O3/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 0x250b4
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x25964
leaq 0x10(%r15), %rsi
movq %r15, %rdi
callq 0x264fc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6300
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x68(%rsp), %rsi
movq %rsp, %rdi
callq 0x6620
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 0x12b2a
movq 0x2951e(%rip), %rdi     # 0x32fd0
leaq 0x1754b(%rip), %rsi     # 0x21004
movl $0x18, %edx
callq 0x6480
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x294fd(%rip), %rdi     # 0x32fd0
callq 0x6480
movq %rax, %rbx
leaq 0x1753b(%rip), %rsi     # 0x2101d
movl $0xa, %edx
movq %rax, %rdi
callq 0x6480
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x6480
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62e0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x9b3a
callq 0x6420
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b4d
callq 0x6420
movq 0x29454(%rip), %rsi     # 0x32fa8
leaq 0x50(%rsp), %rdi
callq 0x6350
leaq 0xd0(%rsp), %rdi
callq 0x6140
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
jmp 0x9b78
movq %rax, %rbx
jmp 0x9ba2
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x9b8f
callq 0x6420
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9ba2
callq 0x6420
movq 0x293ff(%rip), %rsi     # 0x32fa8
leaq 0x50(%rsp), %rdi
callq 0x6350
leaq 0xd0(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6300
leaq 0x90(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x98(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x6620
leaq 0x1741e(%rip), %rsi     # 0x21028
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xa08a
leaq 0x1740e(%rip), %rsi     # 0x2102e
leaq 0x50(%rsp), %rdi
callq 0x6770
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %r8
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %r8
je 0x9c51
movq %r8, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x9c5b
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq %r14, %r8
movq 0x8(%rax), %rsi
movq %rsi, 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 0x9c90
callq 0x6420
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rsi
movl 0x38(%rsp), %ecx
movq 0x30(%rsp), %rdx
movl $0x0, (%rsp)
movzwl %si, %r9d
leaq 0x70(%rsp), %rdi
movq %rbx, %rsi
callq 0x12a5e
movq 0x29318(%rip), %rdi     # 0x32fd0
leaq 0x17373(%rip), %rsi     # 0x21032
movl $0x1b, %edx
callq 0x6480
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x292f6(%rip), %rdi     # 0x32fd0
callq 0x6480
movq %rax, %rbx
leaq 0x17334(%rip), %rsi     # 0x2101d
movl $0xa, %edx
movq %rax, %rdi
callq 0x6480
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x6480
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62e0
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x9d41
callq 0x6420
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d54
callq 0x6420
movq 0x2924d(%rip), %rsi     # 0x32fa8
leaq 0x80(%rsp), %rdi
callq 0x6350
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 0x9dac
jmp 0x9db1
movq %rax, %rbx
jmp 0x9db1
jmp 0x9d9a
movq %rax, %rbx
jmp 0x9dc4
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x9db1
callq 0x6420
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9dc4
callq 0x6420
movq 0x291dd(%rip), %rsi     # 0x32fa8
leaq 0x80(%rsp), %rdi
callq 0x6350
leaq 0x100(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6300
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6620
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x12ac8
movq 0x29196(%rip), %rdi     # 0x32fd0
leaq 0x1720d(%rip), %rsi     # 0x2104e
movl $0x1b, %edx
callq 0x6480
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x29174(%rip), %rdi     # 0x32fd0
callq 0x6480
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6430
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6050
movq %rax, %rdi
callq 0x62e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9e9e
callq 0x6420
movq 0x29103(%rip), %rsi     # 0x32fa8
leaq 0x38(%rsp), %rdi
callq 0x6350
leaq 0xb8(%rsp), %rdi
callq 0x6140
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x9ec7
movq %rax, %rbx
jmp 0x9ee2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9ee2
callq 0x6420
movq 0x290bf(%rip), %rsi     # 0x32fa8
leaq 0x38(%rsp), %rdi
callq 0x6350
leaq 0xb8(%rsp), %rdi
callq 0x6140
movq %rbx, %rdi
callq 0x66d0