LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::compute()
void CEquation::compute() {
    std::string s = replaceOtherCells(m_expression);
    if (!m_error) {
	  CExpressionParser parser(s);

	  if (!parser.MatchingParetheses()) {
		m_error = true;
		m_errorMsg = "ERR: mismatched parentheses or empty input";
	  } else {
		std::vector<std::string> RPN;

		if (parser.InfixToRPN(RPN)) {
		    std::string str_result;
		    if (parser.Evaluate(RPN, str_result)) {
			  m_value = string_to_double(str_result);
		    }
		} else {
		    m_error = true;
		    m_errorMsg = "ERR: mismatched parentheses";
		}
	  }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x51b0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0xd920
jmp 0xd457
leaq -0x48(%rbp), %rdi
callq 0x52a0
movq -0xc0(%rbp), %rax
testb $0x1, 0x58(%rax)
jne 0xd630
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14e70
jmp 0xd480
leaq -0x78(%rbp), %rdi
callq 0x14ec0
movb %al, -0xc1(%rbp)
jmp 0xd491
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0xd4fb
jmp 0xd49d
movq -0xc0(%rbp), %rdi
movb $0x1, 0x58(%rdi)
addq $0x60, %rdi
leaq 0xf126(%rip), %rsi      # 0x1c5d9
callq 0x55a0
jmp 0xd4ba
jmp 0xd61a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x52a0
jmp 0xd64b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd642
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd625
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xf110
movq -0xd0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x170c0
movb %al, -0xc2(%rbp)
jmp 0xd526
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0xd535
jmp 0xd5df
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x55b0
movq -0xe0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x162e0
movb %al, -0xd1(%rbp)
jmp 0xd567
movb -0xd1(%rbp), %al
testb $0x1, %al
jne 0xd573
jmp 0xd5d1
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xd830
movsd %xmm0, -0xe8(%rbp)
jmp 0xd590
movq -0xc0(%rbp), %rax
movsd -0xe8(%rbp), %xmm0
movsd %xmm0, 0x80(%rax)
jmp 0xd5d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xd60c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x52a0
jmp 0xd60c
leaq -0xb0(%rbp), %rdi
callq 0x52a0
jmp 0xd5fe
movq -0xc0(%rbp), %rdi
movb $0x1, 0x58(%rdi)
addq $0x60, %rdi
leaq 0xf00f(%rip), %rsi      # 0x1c604
callq 0x55a0
jmp 0xd5fc
jmp 0xd5fe
leaq -0x90(%rbp), %rdi
callq 0xf130
jmp 0xd61a
leaq -0x90(%rbp), %rdi
callq 0xf130
jmp 0xd625
leaq -0x78(%rbp), %rdi
callq 0xf2b0
jmp 0xd630
leaq -0x78(%rbp), %rdi
callq 0xf2b0
jmp 0xd642
leaq -0x28(%rbp), %rdi
callq 0x52a0
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x52a0
movq -0x50(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::getValue() const
double CEquation::getValue() const {
    if (m_error) {
	  throw std::logic_error(m_errorMsg);
    } else {
	  return m_value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x58(%rax)
je 0xd6eb
movl $0x10, %edi
callq 0x5200
movq -0x20(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
addq $0x60, %rsi
callq 0x55f0
jmp 0xd6bd
movq -0x28(%rbp), %rdi
movq 0x1a910(%rip), %rsi     # 0x27fd8
movq 0x1a8f1(%rip), %rdx     # 0x27fc0
callq 0x56f0
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x5310
jmp 0xd6fd
movq -0x20(%rbp), %rax
movsd 0x80(%rax), %xmm0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::getValueAsString[abi:cxx11]() const
std::string CEquation::getValueAsString() const {
    if (m_error) {
	  return m_errorMsg;
    } else {
	  std::ostringstream out;
	  out << std::setprecision(3) << m_value;
	  return out.str();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
testb $0x1, 0x58(%rax)
je 0xd761
movq -0x1b8(%rbp), %rdi
movq -0x1a8(%rbp), %rsi
addq $0x60, %rsi
callq 0x51b0
jmp 0xd806
leaq -0x188(%rbp), %rdi
callq 0x5590
movl $0x3, %edi
callq 0xf1b0
movl %eax, -0x1bc(%rbp)
jmp 0xd77f
movl -0x1bc(%rbp), %eax
movl %eax, -0x18c(%rbp)
movl -0x18c(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x5660
movq %rax, -0x1c8(%rbp)
jmp 0xd7a6
movq -0x1c8(%rbp), %rdi
movq -0x1a8(%rbp), %rax
movsd 0x80(%rax), %xmm0
callq 0x57e0
jmp 0xd7c3
movq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x5440
jmp 0xd7d8
leaq -0x188(%rbp), %rdi
callq 0x50e0
jmp 0xd806
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x50e0
jmp 0xd816
movq -0x1b0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x198(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::string_to_double(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CEquation::string_to_double(const std::string& s) {
    std::istringstream i(s);
    double x;
    if (!(i >> x))
	  return 0;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
movl $0x8, %edx
callq 0x56d0
movq -0x1c0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x5390
movq %rax, -0x1b8(%rbp)
jmp 0xd87b
movq -0x1b8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x51d0
movb %al, -0x1c1(%rbp)
jmp 0xd899
movb -0x1c1(%rbp), %al
testb $0x1, %al
jne 0xd8a5
jmp 0xd8d9
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movl $0x1, -0x1b0(%rbp)
jmp 0xd8f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x51e0
jmp 0xd90a
movsd -0x1a0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movl $0x1, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x51e0
movsd -0x8(%rbp), %xmm0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x10c40
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
callq 0x10bc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10c70
testb $0x1, %al
jne 0x102dc
jmp 0x1032c
movl $0x10, %edi
callq 0x5200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0xc337(%rip), %rsi      # 0x1c62e
callq 0x57d0
jmp 0x102fe
movq -0x40(%rbp), %rdi
movq 0x17cd7(%rip), %rsi     # 0x27fe0
movq 0x17cb8(%rip), %rdx     # 0x27fc8
callq 0x56f0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x5310
jmp 0x10361
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x38(%rdi)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x10ca0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x40(%rax)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::CTableController()
CTableController::CTableController() {
    m_colPosition = 1;
    m_rowPosition = 1;
    m_colStartingPosition = 1;
    m_rowStartingPosition = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x10e50
movq -0x20(%rbp), %rdi
leaq 0x14ffc(%rip), %rax     # 0x27ca0
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x81c0
jmp 0x12cb2
movq -0x20(%rbp), %rax
movl $0x1, 0x7c(%rax)
movl $0x1, 0x78(%rax)
movl $0x1, 0x84(%rax)
movl $0x1, 0x80(%rax)
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd140
movq -0x10(%rbp), %rdi
callq 0x5730
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x45, %eax
je 0x12dce
jmp 0x12d94
movl -0x10(%rbp), %eax
subl $0x65, %eax
je 0x12dce
jmp 0x12d9e
movl -0x10(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0x12dd9
jmp 0x12daa
movl -0x10(%rbp), %eax
subl $0x103, %eax            # imm = 0x103
je 0x12ded
jmp 0x12db6
movl -0x10(%rbp), %eax
subl $0x104, %eax            # imm = 0x104
je 0x12e15
jmp 0x12dc2
movl -0x10(%rbp), %eax
subl $0x105, %eax            # imm = 0x105
je 0x12e01
jmp 0x12e29
movq -0x18(%rbp), %rdi
callq 0x12e40
jmp 0x12e2b
movq -0x18(%rbp), %rdi
movl 0x78(%rdi), %esi
addl $0x1, %esi
movl 0x7c(%rdi), %edx
callq 0x13010
jmp 0x12e2b
movq -0x18(%rbp), %rdi
movl 0x78(%rdi), %esi
subl $0x1, %esi
movl 0x7c(%rdi), %edx
callq 0x13010
jmp 0x12e2b
movq -0x18(%rbp), %rdi
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
addl $0x1, %edx
callq 0x13010
jmp 0x12e2b
movq -0x18(%rbp), %rdi
movl 0x78(%rdi), %esi
movl 0x7c(%rdi), %edx
subl $0x1, %edx
callq 0x13010
jmp 0x12e2b
jmp 0x12e2b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
callq 0x5120
movl $0x1, %edi
callq 0x5380
movl $0x4, %edi
movl $0xd, %esi
callq 0x52e0
movq 0x15139(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
callq 0x5480
movl $0x4, %edi
movl $0xd, %esi
callq 0x52e0
movq -0xb0(%rbp), %rax
movq %rax, %rsi
addq $0x8, %rsi
movl 0x78(%rax), %edx
movl 0x7c(%rax), %ecx
leaq -0x70(%rbp), %rdi
callq 0x8f40
leaq -0x70(%rbp), %rdi
callq 0x5620
subl $0x1, %eax
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jl 0x12f10
movslq -0x74(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x5800
movq %rax, -0xb8(%rbp)
jmp 0x12ede
movq -0xb8(%rbp), %rax
movsbl (%rax), %edi
callq 0x5560
jmp 0x12eef
jmp 0x12ef1
movl -0x74(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x12ec2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x12ff8
movq 0x150a1(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
leaq -0x50(%rbp), %rsi
movl $0x41, %edx
callq 0x5610
jmp 0x12f2a
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x55a0
jmp 0x12f39
movq -0xb0(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xc8(%rbp)
movl 0x78(%rax), %ecx
movl %ecx, -0xc0(%rbp)
movl 0x7c(%rax), %eax
movl %eax, -0xbc(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x51b0
jmp 0x12f72
movl -0xbc(%rbp), %edx
movl -0xc0(%rbp), %esi
movq -0xc8(%rbp), %rdi
leaq -0xa8(%rbp), %rcx
callq 0x8380
jmp 0x12f93
leaq -0xa8(%rbp), %rdi
callq 0x52a0
callq 0x54d0
jmp 0x12fa6
xorl %edi, %edi
callq 0x5380
jmp 0x12faf
movq -0xb0(%rbp), %rdi
callq 0x13d60
jmp 0x12fbd
movq -0xb0(%rbp), %rdi
callq 0x131c0
jmp 0x12fcb
leaq -0x70(%rbp), %rdi
callq 0x52a0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x52a0
leaq -0x70(%rbp), %rdi
callq 0x52a0
movq -0x80(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x13036
cmpl $0x1, -0x10(%rbp)
jge 0x13038
jmp 0x13068
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, 0x78(%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x7c(%rdi)
callq 0x13cc0
movq -0x18(%rbp), %rdi
callq 0x13d60
movq -0x18(%rbp), %rdi
callq 0x13e10
movq -0x18(%rbp), %rdi
callq 0x131c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: havluj[P]spreadsheet/src/CTableController.cpp
// Function: CTableController::redraw()
void CTableController::redraw() {
    clear();

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

    refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x5710
movq -0x10(%rbp), %rdi
callq 0x130b0
movq -0x10(%rbp), %rdi
callq 0x131c0
movq -0x10(%rbp), %rdi
callq 0x13bc0
callq 0x56e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x14eed(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
xorl %edi, %edi
movl $0x1, %esi
leaq 0x957a(%rip), %rdx      # 0x1c664
movb $0x0, %al
callq 0x5570
movq 0x14ec0(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movq -0x10(%rbp), %rdi
callq 0x13cc0
movq 0x14e9f(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
movl $0x3, %edi
movl $0x1, %esi
leaq 0x9532(%rip), %rdx      # 0x1c66d
movb $0x0, %al
callq 0x5570
movq 0x14e6f(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movq -0x10(%rbp), %rdi
callq 0x13d60
movq 0x14e4e(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
movl $0x4, %edi
movl $0x1, %esi
leaq 0x94ec(%rip), %rdx      # 0x1c678
movb $0x0, %al
callq 0x5570
movq 0x14e1e(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x220000, %esi         # imm = 0x220000
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movq -0x10(%rbp), %rdi
callq 0x13e10
callq 0x56e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movq 0x143e3(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x13bf0
movq 0x143d7(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13bfa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x13bfa
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x143af(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x13c24
movq 0x143a3(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13c2e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x13c2e
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x1437d(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x5490
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x1, %esi
leaq 0x8a36(%rip), %rdx      # 0x1c690
movb $0x0, %al
callq 0x5570
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x1b, %esi
leaq 0x8a37(%rip), %rdx      # 0x1c6aa
movb $0x0, %al
callq 0x5570
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x27, %esi
leaq 0x87c9(%rip), %rdx      # 0x1c455
movb $0x0, %al
callq 0x5570
movq 0x1431e(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
callq 0x56e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
xorl %edi, %edi
movl $0xb, %esi
callq 0x52e0
movq 0x142d1(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
callq 0x5480
movl $0x1, %edi
movl $0xd, %esi
callq 0x52e0
movq 0x142b3(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
callq 0x5480
movq -0x10(%rbp), %rax
movl 0x78(%rax), %ecx
xorl %edi, %edi
movl $0xb, %esi
leaq 0x8923(%rip), %rdx      # 0x1c645
movb $0x0, %al
callq 0x5570
movq -0x10(%rbp), %rax
movl 0x7c(%rax), %ecx
movl $0x1, %edi
movl $0xd, %esi
leaq 0x8912(%rip), %rdx      # 0x1c653
movb $0x0, %al
callq 0x5570
callq 0x56e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x3, %edi
movl %edi, -0x3c(%rbp)
movl $0xb, %esi
movl %esi, -0x38(%rbp)
callq 0x52e0
movq 0x14228(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
callq 0x5480
movq -0x50(%rbp), %rax
movq %rax, %rsi
addq $0x8, %rsi
movl 0x78(%rax), %edx
movl 0x7c(%rax), %ecx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8ce0
movq -0x48(%rbp), %rdi
callq 0x5190
movl -0x3c(%rbp), %edi
movl -0x38(%rbp), %esi
movq %rax, %rcx
leaq 0x8890(%rip), %rdx      # 0x1c65f
xorl %eax, %eax
callq 0x5570
jmp 0x13dd8
leaq -0x28(%rbp), %rdi
callq 0x52a0
callq 0x56e0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52a0
movq -0x30(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x4, %edi
movl %edi, -0x3c(%rbp)
movl $0xb, %esi
movl %esi, -0x38(%rbp)
callq 0x52e0
movq 0x14178(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
callq 0x5480
movq -0x50(%rbp), %rax
movq %rax, %rsi
addq $0x8, %rsi
movl 0x78(%rax), %edx
movl 0x7c(%rax), %ecx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x8f40
movq -0x48(%rbp), %rdi
callq 0x5190
movl -0x3c(%rbp), %edi
movl -0x38(%rbp), %esi
movq %rax, %rcx
leaq 0x87e0(%rip), %rdx      # 0x1c65f
xorl %eax, %eax
callq 0x5570
jmp 0x13e88
leaq -0x28(%rbp), %rdi
callq 0x52a0
callq 0x56e0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52a0
movq -0x30(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5710
xorl %eax, %eax
movq 0x13dce(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x14205
movq 0x13dc2(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1420f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x1420f
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x13d9a(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x14239
movq 0x13d8e(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x14243
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x14243
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x7, %edx
callq 0x5070
movq 0x13d54(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
xorl %edi, %edi
movl $0x1, %esi
leaq 0x8516(%rip), %rdx      # 0x1c799
movb $0x0, %al
callq 0x5570
movq 0x13d27(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movl $0x2, %edi
movl $0x1, %esi
leaq 0x8509(%rip), %rdx      # 0x1c7bc
movb $0x0, %al
callq 0x5570
movl $0x3, %edi
movl $0x1, %esi
leaq 0x8511(%rip), %rdx      # 0x1c7dc
movb $0x0, %al
callq 0x5570
movq 0x13cdf(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x5490
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x1, %esi
leaq 0x815d(%rip), %rdx      # 0x1c455
movb $0x0, %al
callq 0x5570
movq 0x13cb2(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
callq 0x56e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5710
xorl %eax, %eax
movq 0x13c1e(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x143b5
movq 0x13c12(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x4(%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x143bf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x14(%rbp)
jmp 0x143bf
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
movq 0x13bea(%rip), %rcx     # 0x27fb8
cmpq (%rcx), %rax
je 0x143e9
movq 0x13bde(%rip), %rax     # 0x27fb8
movq (%rax), %rax
movswl 0x6(%rax), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x143f3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x18(%rbp)
jmp 0x143f3
movl -0x18(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x2, %edi
movl $0x1, %esi
movl $0x7, %edx
callq 0x5070
movq 0x13ba4(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %eax, %eax
movl %eax, %edx
callq 0x51f0
movl $0x1, %esi
leaq 0x83d6(%rip), %rdx      # 0x1c807
movl %esi, %edi
movb $0x0, %al
callq 0x5570
movq 0x13b77(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x200200, %esi         # imm = 0x200200
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
movq 0x13b5f(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x5490
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x1, %esi
leaq 0x83bd(%rip), %rdx      # 0x1c835
movb $0x0, %al
callq 0x5570
movl -0xc(%rbp), %edi
subl $0x1, %edi
movl $0x1e, %esi
leaq 0x7fc4(%rip), %rdx      # 0x1c455
movb $0x0, %al
callq 0x5570
movq 0x13b19(%rip), %rax     # 0x27fb8
movq (%rax), %rdi
movl $0x100, %esi            # imm = 0x100
xorl %eax, %eax
movl %eax, %edx
callq 0x5550
callq 0x56e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7a9e(%rip), %rsi      # 0x1c00c
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7a88(%rip), %rsi      # 0x1c00e
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7a6c(%rip), %rsi      # 0x1c006
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7a5a(%rip), %rsi      # 0x1c008
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7a48(%rip), %rsi      # 0x1c00a
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7ee6(%rip), %rsi      # 0x1c4bc
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x7deb(%rip), %rsi      # 0x1c3d5
callq 0x17ac0
testb $0x1, %al
jne 0x14609
movq -0x8(%rbp), %rdi
leaq 0x8282(%rip), %rsi      # 0x1c880
callq 0x17ac0
testb $0x1, %al
jne 0x14609
jmp 0x14612
movl $0x2, -0xc(%rbp)
jmp 0x14631
movq -0x8(%rbp), %rdi
leaq 0x819d(%rip), %rsi      # 0x1c7ba
callq 0x17ac0
testb $0x1, %al
jne 0x14628
jmp 0x1462f
movl $0x1, -0xc(%rbp)
jmp 0x14631
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x815c(%rip), %rsi      # 0x1c7ba
callq 0x17ac0
testb $0x1, %al
jne 0x14669
jmp 0x14675
movl $0x4, -0xc(%rbp)
jmp 0x14712
movq -0x8(%rbp), %rdi
leaq 0x798c(%rip), %rsi      # 0x1c00c
callq 0x17ac0
testb $0x1, %al
jne 0x146b3
movq -0x8(%rbp), %rdi
leaq 0x797a(%rip), %rsi      # 0x1c00e
callq 0x17ac0
testb $0x1, %al
jne 0x146b3
movq -0x8(%rbp), %rdi
leaq 0x795e(%rip), %rsi      # 0x1c006
callq 0x17ac0
testb $0x1, %al
jne 0x146b3
jmp 0x146bc
movl $0x3, -0xc(%rbp)
jmp 0x14710
movq -0x8(%rbp), %rdi
leaq 0x7941(%rip), %rsi      # 0x1c008
callq 0x17ac0
testb $0x1, %al
jne 0x146e6
movq -0x8(%rbp), %rdi
leaq 0x792f(%rip), %rsi      # 0x1c00a
callq 0x17ac0
testb $0x1, %al
jne 0x146e6
jmp 0x146ef
movl $0x2, -0xc(%rbp)
jmp 0x1470e
movq -0x8(%rbp), %rdi
leaq 0x7dc2(%rip), %rsi      # 0x1c4bc
callq 0x17ac0
testb $0x1, %al
jne 0x14705
jmp 0x1470c
movl $0x1, -0xc(%rbp)
jmp 0x1470e
jmp 0x14710
jmp 0x14712
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x78d5(%rip), %rsi      # 0x1c00c
callq 0x17ac0
testb $0x1, %al
jne 0x14792
movq -0x10(%rbp), %rdi
leaq 0x78c3(%rip), %rsi      # 0x1c00e
callq 0x17ac0
testb $0x1, %al
jne 0x14792
movq -0x10(%rbp), %rdi
leaq 0x78a7(%rip), %rsi      # 0x1c006
callq 0x17ac0
testb $0x1, %al
jne 0x14792
movq -0x10(%rbp), %rdi
leaq 0x7895(%rip), %rsi      # 0x1c008
callq 0x17ac0
testb $0x1, %al
jne 0x14792
movq -0x10(%rbp), %rdi
leaq 0x7883(%rip), %rsi      # 0x1c00a
callq 0x17ac0
testb $0x1, %al
jne 0x14792
jmp 0x14798
movb $0x1, -0x1(%rbp)
jmp 0x147ce
movq -0x10(%rbp), %rdi
leaq 0x7d19(%rip), %rsi      # 0x1c4bc
callq 0x17ac0
testb $0x1, %al
jne 0x147c2
movq -0x10(%rbp), %rdi
leaq 0x8003(%rip), %rsi      # 0x1c7ba
callq 0x17ac0
testb $0x1, %al
jne 0x147c2
jmp 0x147c8
movb $0x0, -0x1(%rbp)
jmp 0x147ce
jmp 0x147ca
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: IsFunction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool IsFunction(const std::string& s) {
    std::string str = UpperCase(s);

    if (str.find("^") != std::string::npos
		|| str.find("SIN") != std::string::npos
		|| str.find("COS") != std::string::npos
		|| str.find("TAN") != std::string::npos
		|| str.find("LN") != std::string::npos
		|| str.find("LOG") != std::string::npos
		|| str.find("EXP") != std::string::npos
		|| str.find("POW") != std::string::npos
		|| str.find("SQRT") != std::string::npos) {
	  return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x51b0
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x148f0
leaq -0x50(%rbp), %rdi
callq 0x52a0
leaq -0x30(%rbp), %rdi
leaq 0x78cb(%rip), %rsi      # 0x1c3d5
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7d61(%rip), %rsi      # 0x1c889
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7d47(%rip), %rsi      # 0x1c88d
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7d2d(%rip), %rsi      # 0x1c891
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7d13(%rip), %rsi      # 0x1c895
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7cfc(%rip), %rsi      # 0x1c898
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7ce6(%rip), %rsi      # 0x1c89c
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7cb0(%rip), %rsi      # 0x1c880
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
jne 0x14bf9
leaq -0x30(%rbp), %rdi
leaq 0x7cb6(%rip), %rsi      # 0x1c8a0
xorl %eax, %eax
movl %eax, %edx
callq 0x5830
cmpq $-0x1, %rax
je 0x14c06
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x14c11
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movl $0x8, %edx
callq 0x56d0
movq -0x1b0(%rbp), %rdi
leaq 0x2e87(%rip), %rsi      # 0x17af0
callq 0x56b0
movq %rax, -0x1a8(%rbp)
jmp 0x14c77
movq -0x1a8(%rbp), %rdi
leaq -0x18c(%rbp), %rsi
callq 0x50a0
jmp 0x14c8c
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x188(%rbp,%rax), %rdi
callq 0x5780
movb %al, -0x1b1(%rbp)
jmp 0x14cac
movb -0x1b1(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x1b2(%rbp)
jne 0x14cc1
jmp 0x14cef
movq -0x188(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x188(%rbp,%rax), %rdi
callq 0x5030
movb %al, -0x1b3(%rbp)
jmp 0x14ce1
movb -0x1b3(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1b2(%rbp)
movb -0x1b2(%rbp), %al
movb %al, -0x1b4(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x51e0
movb -0x1b4(%rbp), %al
andb $0x1, %al
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x51e0
movq -0x198(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5400
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57c0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x17b20
movb %al, %cl
movb $0x0, -0x21(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x14d95
jmp 0x14dce
leaq -0x10(%rbp), %rdi
callq 0x17ba0
movsbl (%rax), %eax
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5860
movl -0x54(%rbp), %edi
movq -0x50(%rbp), %rsi
movb $0x1, -0x21(%rbp)
callq 0x17b60
movb %al, -0x42(%rbp)
jmp 0x14dc6
movb -0x42(%rbp), %al
movb %al, -0x41(%rbp)
jmp 0x14dce
movb -0x41(%rbp), %al
movb %al, -0x55(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x14ddc
jmp 0x14de5
leaq -0x20(%rbp), %rdi
callq 0x55c0
movb -0x55(%rbp), %al
testb $0x1, %al
jne 0x14dee
jmp 0x14e1b
leaq -0x10(%rbp), %rdi
callq 0x17bc0
jmp 0x14d69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x14e10
jmp 0x14e19
leaq -0x20(%rbp), %rdi
callq 0x55c0
jmp 0x14e58
movq -0x8(%rbp), %rdi
callq 0x56a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x56(%rbp)
jne 0x14e4d
movq -0x8(%rbp), %rdi
callq 0x57c0
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x17be0
movb %al, -0x56(%rbp)
movb -0x56(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5730
nopw %cs:(%rax,%rax)
// File: havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: CExpressionParser::MatchingParetheses()
bool CExpressionParser::MatchingParetheses() {
    std::vector<std::string> inputs;

    // Check left and right parentheses are equal
    const size_t nLeft = std::count(m_strInput.begin(), m_strInput.end(), '(');
    const size_t nRight = std::count(m_strInput.begin(), m_strInput.end(), ')');

    return nLeft == nRight && !m_strInput.empty();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf110
movq -0x80(%rbp), %rdi
callq 0x53c0
movq -0x80(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x5260
movq %rax, -0x38(%rbp)
movb $0x28, -0x39(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq -0x39(%rbp), %rdx
callq 0x17c20
movq %rax, -0x78(%rbp)
jmp 0x14f15
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x53c0
movq -0x80(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x5260
movq %rax, -0x68(%rbp)
movb $0x29, -0x69(%rbp)
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
leaq -0x69(%rbp), %rdx
callq 0x17c20
movq %rax, -0x88(%rbp)
jmp 0x14f55
movq -0x88(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq -0x58(%rbp), %rcx
movb %al, -0x89(%rbp)
jne 0x14f83
movq -0x80(%rbp), %rdi
callq 0x56a0
xorb $-0x1, %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
movb %al, -0x8a(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf130
movb -0x8a(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xf130
movq -0x48(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5850
movq %rax, -0x28(%rbp)
cmpq $-0x1, %rax
je 0x162cb
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5620
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
callq 0x5140
movq -0x20(%rbp), %rdi
callq 0x5620
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x16270
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x36de
movq 0xb912(%rip), %rdi      # 0xefd8
leaq 0x6947(%rip), %rsi      # 0xa014
callq 0x3260
movl $0x1, -0x4(%rbp)
jmp 0x38ab
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x2c8(%rbp)
leaq -0x2a1(%rbp), %rdi
movq %rdi, -0x2c0(%rbp)
callq 0x3480
movq -0x2c8(%rbp), %rsi
movq -0x2c0(%rbp), %rdx
leaq -0x2a0(%rbp), %rdi
callq 0x38d0
jmp 0x371c
leaq -0x280(%rbp), %rdi
leaq -0x2a0(%rbp), %rsi
callq 0x3c20
jmp 0x3731
leaq -0x2a0(%rbp), %rdi
callq 0x31a0
leaq -0x2a1(%rbp), %rdi
callq 0x32e0
leaq -0x280(%rbp), %rdi
callq 0x45f0
movb %al, -0x2c9(%rbp)
jmp 0x375d
movb -0x2c9(%rbp), %al
testb $0x1, %al
jne 0x37f8
jmp 0x376d
callq 0x3680
movl %eax, -0x2d0(%rbp)
jmp 0x377a
movl -0x2d0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x2b8(%rbp)
jmp 0x389f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
jmp 0x37c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x31a0
leaq -0x2a1(%rbp), %rdi
callq 0x32e0
jmp 0x38b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x2b0(%rbp)
movl %eax, -0x2b4(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4280
jmp 0x38b7
leaq -0x280(%rbp), %rdi
callq 0x4610
jmp 0x3806
leaq -0x280(%rbp), %rdi
callq 0x4ac0
jmp 0x3814
leaq -0x280(%rbp), %rdi
callq 0x4be0
jmp 0x3822
leaq -0x280(%rbp), %rdi
callq 0x4f00
jmp 0x3830
leaq -0x280(%rbp), %rdi
callq 0x45f0
movb %al, -0x2d1(%rbp)
jmp 0x3844
movb -0x2d1(%rbp), %al
testb $0x1, %al
jne 0x3872
jmp 0x3850
callq 0x3680
movl %eax, -0x2d8(%rbp)
jmp 0x385d
movl -0x2d8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x2b8(%rbp)
jmp 0x389f
leaq -0x280(%rbp), %rdi
callq 0x5870
jmp 0x3880
leaq -0x280(%rbp), %rdi
callq 0x5990
jmp 0x388e
movl $0x0, -0x4(%rbp)
movl $0x1, -0x2b8(%rbp)
leaq -0x280(%rbp), %rdi
callq 0x4280
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq -0x2b0(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x3320
movq -0x30(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movq %rdi, -0x40(%rbp)
callq 0x5e80
movq -0x30(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
movq %rdi, -0x38(%rbp)
callq 0x5ea0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movb $0x0, 0x210(%rdi)
movl $0x8, %edx
callq 0x33b0
jmp 0x3c8b
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3030
movb %al, -0x49(%rbp)
jmp 0x3ca3
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x3cac
jmp 0x3d18
movq 0xb325(%rip), %rdi      # 0xefd8
leaq 0x63b6(%rip), %rsi      # 0xa070
callq 0x3260
movq %rax, -0x58(%rbp)
jmp 0x3cc5
movq -0x28(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x3250
movq %rax, -0x60(%rbp)
jmp 0x3cd8
movq -0x60(%rbp), %rdi
movq 0xb2e5(%rip), %rsi      # 0xefc8
callq 0x32c0
jmp 0x3cea
jmp 0x3d75
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5ec0
movq -0x40(%rbp), %rdi
callq 0x5ee0
movq -0x30(%rbp), %rdi
callq 0x30d0
jmp 0x3d7b
movq -0x48(%rbp), %rax
movb $0x1, 0x210(%rax)
movq -0x48(%rbp), %rdi
movl $0x0, 0x214(%rdi)
callq 0x3d90
movb %al, -0x61(%rbp)
jmp 0x3d3b
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3d44
jmp 0x3d51
movq -0x48(%rbp), %rax
movb $0x1, 0x210(%rax)
jmp 0x3d53
jmp 0x3d75
movq -0x48(%rbp), %rdi
callq 0x4170
movb %al, -0x62(%rbp)
jmp 0x3d61
movb -0x62(%rbp), %al
testb $0x1, %al
jne 0x3d75
jmp 0x3d6a
movq -0x48(%rbp), %rax
movb $0x0, 0x210(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3470
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x214(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3390
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x260(%rax)
cmpq $0x0, 0x260(%rax)
jne 0x41ba
movb $0x0, -0x1(%rbp)
jmp 0x4272
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x214(%rcx), %eax
jg 0x426e
movq -0x20(%rbp), %rax
movl 0x214(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x3390
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x260(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x214(%rcx), %eax
jg 0x4242
movq -0x20(%rbp), %rax
movq 0x260(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x420a
movq -0x20(%rbp), %rax
movq 0x260(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x425e
movb $0x0, -0x1(%rbp)
jmp 0x4272
jmp 0x4260
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41c1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x214(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x3390
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x268(%rax)
cmpq $0x0, 0x268(%rax)
jne 0x452a
movb $0x0, -0x1(%rbp)
jmp 0x45e2
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x214(%rcx), %eax
jg 0x45de
movq -0x20(%rbp), %rax
movl 0x214(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x3390
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x268(%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x214(%rcx), %eax
jg 0x45b2
movq -0x20(%rbp), %rax
movq 0x268(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x457a
movq -0x20(%rbp), %rax
movq 0x268(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x45ce
movb $0x0, -0x1(%rbp)
jmp 0x45e2
jmp 0x45d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4531
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)