LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::erase(int)
void TodoList::erase(int num) {
  if (tasks.count(num)) {
    std::cout << "Erased #" << num << ": " << tasks[num] << std::endl;
    tasks.erase(num);
    write();
  } else {
    std::cerr << "There is no task #" << num << "." << std::endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x5ad0
cmpq $0x0, %rax
je 0x5617
movq 0x7a23(%rip), %rdi      # 0xcfd0
leaq 0x3c27(%rip), %rsi      # 0x91db
callq 0x3240
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33f0
movq %rax, %rdi
leaq 0x3c0a(%rip), %rsi      # 0x91d8
callq 0x3240
movq -0x18(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0xc(%rbp), %rsi
callq 0x5b30
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x3230
movq %rax, %rdi
movq 0x79c6(%rip), %rsi      # 0xcfc0
callq 0x3290
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x5c10
movq -0x18(%rbp), %rdi
callq 0x5400
jmp 0x5653
movq 0x79d2(%rip), %rdi      # 0xcff0
leaq 0x3bbf(%rip), %rsi      # 0x91e4
callq 0x3240
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x33f0
movq %rax, %rdi
leaq 0x3a77(%rip), %rsi      # 0x90b6
callq 0x3240
movq %rax, %rdi
movq 0x7972(%rip), %rsi      # 0xcfc0
callq 0x3290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::get[abi:cxx11](int)
std::string TodoList::get(int num) {
  std::ostringstream oss;
  oss << num;
  oss << ". ";
  oss << tasks[num];
  return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x190(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x3340
movq -0x1a8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x33f0
jmp 0x56b6
leaq 0x3a9c(%rip), %rsi      # 0x9159
leaq -0x190(%rbp), %rdi
callq 0x3240
jmp 0x56cb
movq -0x1b0(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x5b30
movq %rax, -0x1c8(%rbp)
jmp 0x56e4
movq -0x1c8(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x3230
jmp 0x56f9
movq -0x1c0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x3270
jmp 0x570e
leaq -0x190(%rbp), %rdi
callq 0x30a0
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x198(%rbp)
movl %eax, -0x19c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x30a0
movq -0x198(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: wandernauta[P]ttasks/TodoList.cpp
// Function: TodoList::reorder()
void TodoList::reorder() {
  int i = 1;
  tmap tnew;
  tmap::iterator it;

  for (it = tasks.begin(); it != tasks.end(); ++it) {
    tnew[i] = it->second;
    i++;
  }

  tasks = tnew;
  write();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x1, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x59c0
leaq -0x48(%rbp), %rdi
callq 0x5c40
movq -0x70(%rbp), %rdi
callq 0x5c60
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x70(%rbp), %rdi
callq 0x5cc0
movq %rax, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5c90
testb $0x1, %al
jne 0x58b5
jmp 0x5913
leaq -0x48(%rbp), %rdi
callq 0x5cf0
addq $0x8, %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x5b30
movq %rax, -0x78(%rbp)
jmp 0x58d9
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x3040
jmp 0x58e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x5d10
jmp 0x5895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ed0
jmp 0x593f
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5d60
jmp 0x5922
movq -0x70(%rbp), %rdi
callq 0x5400
jmp 0x592d
leaq -0x40(%rbp), %rdi
callq 0x3ed0
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3400
nopl (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/util.cpp
// Function: XConfigureWindowValueMaskToString[abi:cxx11](unsigned long)
std::string XConfigureWindowValueMaskToString(unsigned long value_mask)
{
    std::vector<std::string> masks;
    if (value_mask & CWX) {
        masks.emplace_back("X");
    }
    if (value_mask & CWY) {
        masks.emplace_back("Y");
    }
    if (value_mask & CWWidth) {
        masks.emplace_back("Width");
    }
    if (value_mask & CWHeight) {
        masks.emplace_back("Height");
    }
    if (value_mask & CWBorderWidth) {
        masks.emplace_back("BorderWidth");
    }
    if (value_mask & CWSibling) {
        masks.emplace_back("Sibling");
    }
    if (value_mask & CWStackMode) {
        masks.emplace_back("StackMode");
    }
    return Join(masks, "|");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6aa0
movq -0x10(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5b1a
leaq 0x117ab(%rip), %rsi     # 0x172a7
leaq -0x28(%rbp), %rdi
callq 0x6ac0
jmp 0x5b07
jmp 0x5b1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5c70
movq -0x10(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x5b3c
leaq 0x1177a(%rip), %rsi     # 0x172a9
leaq -0x28(%rbp), %rdi
callq 0x6ac0
jmp 0x5b3a
jmp 0x5b3c
movq -0x10(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x5b5e
leaq 0x11767(%rip), %rsi     # 0x172b8
leaq -0x28(%rbp), %rdi
callq 0x6b40
jmp 0x5b5c
jmp 0x5b5e
movq -0x10(%rbp), %rax
andq $0x8, %rax
cmpq $0x0, %rax
je 0x5b80
leaq 0x11738(%rip), %rsi     # 0x172ab
leaq -0x28(%rbp), %rdi
callq 0x6bc0
jmp 0x5b7e
jmp 0x5b80
movq -0x10(%rbp), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x5ba2
leaq 0x1171d(%rip), %rsi     # 0x172b2
leaq -0x28(%rbp), %rdi
callq 0x6c40
jmp 0x5ba0
jmp 0x5ba2
movq -0x10(%rbp), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x5bc4
leaq 0x11707(%rip), %rsi     # 0x172be
leaq -0x28(%rbp), %rdi
callq 0x6cc0
jmp 0x5bc2
jmp 0x5bc4
movq -0x10(%rbp), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x5be6
leaq 0x116ed(%rip), %rsi     # 0x172c6
leaq -0x28(%rbp), %rdi
callq 0x6d40
jmp 0x5be4
jmp 0x5be6
leaq -0x59(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x44c0
movq -0x78(%rbp), %rdx
leaq 0x116d2(%rip), %rsi     # 0x172d0
leaq -0x58(%rbp), %rdi
callq 0x6990
jmp 0x5c09
movq -0x70(%rbp), %rdi
leaq -0x28(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x6dc0
jmp 0x5c1c
leaq -0x58(%rbp), %rdi
callq 0x4150
leaq -0x59(%rbp), %rdi
callq 0x42c0
leaq -0x28(%rbp), %rdi
callq 0x6f00
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5c67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4150
leaq -0x59(%rbp), %rdi
callq 0x42c0
leaq -0x28(%rbp), %rdi
callq 0x6f00
movq -0x30(%rbp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/./util.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Join<std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>, ToString(_XEvent const&)::$_0>(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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&, ToString(_XEvent const&)::$_0)
::std::string Join(
    const Container& container,
    const ::std::string& delimiter,
    Converter converter)
{
    ::std::vector<::std::string> converted_container(container.size());
    ::std::transform(
        container.cbegin(),
        container.cend(),
        converted_container.begin(),
        converter);
    return Join(converted_container, delimiter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x78f0
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9b40
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x9b60
jmp 0x5ceb
leaq -0x39(%rbp), %rdi
callq 0x9bd0
movq -0x18(%rbp), %rdi
callq 0x9bf0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9c20
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9c50
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x5e40
movq %rax, -0xa0(%rbp)
jmp 0x5d35
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rsi
callq 0x6dc0
jmp 0x5d56
leaq -0x38(%rbp), %rdi
callq 0x6f00
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x9bd0
jmp 0x5d9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6f00
movq -0x48(%rbp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/./util.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Join<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
::std::string Join(const Container& container, const ::std::string& delimiter)
{
    ::std::ostringstream out;
    for (auto i = container.cbegin(); i != container.cend(); ++i) {
        if (i != container.cbegin()) {
            out << delimiter;
        }
        out << *i;
    }
    return out.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x43a0
movq -0x10(%rbp), %rdi
callq 0xbd70
movq %rax, -0x198(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbde0
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xbda0
testb $0x1, %al
jne 0x6e30
jmp 0x6ebd
movq -0x10(%rbp), %rdi
callq 0xbd70
movq %rax, -0x1a8(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xbda0
testb $0x1, %al
jne 0x6e59
jmp 0x6e8d
movq -0x18(%rbp), %rsi
leaq -0x190(%rbp), %rdi
callq 0x4220
jmp 0x6e6b
jmp 0x6e8d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x4060
jmp 0x6eee
leaq -0x198(%rbp), %rdi
callq 0xbe10
movq %rax, %rsi
leaq -0x190(%rbp), %rdi
callq 0x4220
jmp 0x6eaa
jmp 0x6eac
leaq -0x198(%rbp), %rdi
callq 0xbe30
jmp 0x6e04
movq -0x1c8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x4280
jmp 0x6ed2
leaq -0x190(%rbp), %rdi
callq 0x4060
movq -0x1c0(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x44b0
nopw (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::init_root(unsigned long, int, int, int, int)
std::tuple<Node*, Node*> BSP::init_root(Window w, int width, int height, int x, int y)
{
    root = new Node();
    root->set_window(w);
    root->set_dimensions(width, height, x, y);
    return std::make_tuple(nullptr, root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x28, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
callq 0xbe80
jmp 0xc310
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xbee0
movq -0x60(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
movl -0x24(%rbp), %ecx
movl 0x10(%rbp), %r8d
callq 0xbea0
movq -0x60(%rbp), %rdx
movq $0x0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xcb40
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xcb80
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x28, %esi
callq 0x4270
movq -0x30(%rbp), %rdi
callq 0x44b0
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::find_node_util(unsigned long, Node*)
Node* BSP::find_node_util(Window w, Node* current)
{
    /* if (current->get_window() == w && current->is_leaf()) { */
    /*     return current; */
    /* } */
    if (current->is_leaf()) {
        return current;
    }

    if (current->get_right_child()->is_leaf() == false) {
        return find_node_util(w, current->get_right_child());
    } else {
        return current->get_right_child();
    }

    if (current->get_left_child()->is_leaf() == false) {
        return find_node_util(w, current->get_left_child());
    } else {
        return current->get_left_child();
    }

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfd0
testb $0x1, %al
jne 0xc3cb
jmp 0xc3d5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc424
movq -0x20(%rbp), %rdi
callq 0xbfb0
movq %rax, %rdi
callq 0xbfd0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc417
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbfb0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0xc3a0
movq %rax, -0x8(%rbp)
jmp 0xc424
movq -0x20(%rbp), %rdi
callq 0xbfb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::find_node(unsigned long)
Node* BSP::find_node(Window w)
{
    if (root == nullptr) {
        std::cout << "No root window present\n";
    }
    Node* res = find_node_util(w, root);
    if (res == nullptr) {
        std::cout << "Window not found\n";
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0xc461
movq 0x16b7b(%rip), %rdi     # 0x22fd0
leaq 0xb567(%rip), %rsi      # 0x179c3
callq 0x4240
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rdx
callq 0xc3a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc48f
movq 0x16b4d(%rip), %rdi     # 0x22fd0
leaq 0xb5b1(%rip), %rsi      # 0x17a3b
callq 0x4240
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::create_node(unsigned long)
std::tuple<Node*, Node*> BSP::create_node(Window w)
{
    Node* current = find_node(w);
    if (current == nullptr) {
        std::cout << "Cannot create new window\n";
        return std::make_tuple(nullptr, nullptr);
    } else {
        return current->split_node(w);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xc430
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc51a
movq 0x16af2(%rip), %rdi     # 0x22fd0
leaq 0xb4f6(%rip), %rsi      # 0x179db
callq 0x4240
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0xcbb0
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xcbf0
jmp 0xc52b
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xc0c0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/bsp.cpp
// Function: BSP::display_tree_util(Node*)
void BSP::display_tree_util(Node* current)
{
    if (current->get_left_child() != nullptr) {
        display_tree_util(current->get_left_child());
    }
    if (current->get_right_child() != nullptr) {
        display_tree_util(current->get_right_child());
    }
    current->print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf90
cmpq $0x0, %rax
je 0xca5c
movq -0x10(%rbp), %rdi
callq 0xbf90
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xca20
movq -0x10(%rbp), %rdi
callq 0xbfb0
cmpq $0x0, %rax
je 0xca80
movq -0x10(%rbp), %rdi
callq 0xbfb0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0xca20
movq -0x10(%rbp), %rdi
callq 0xc010
addq $0x20, %rsp
popq %rbp
retq
nop
// File: nishalkulkarni[P]fluid-wm/master_stack.cpp
// Function: MasterStack::erase(unsigned long)
void MasterStack::erase(Window w)
{
    std::vector<Window>::iterator pos = find(stack.begin(), stack.end(), w);
    if (pos == stack.end()) {
        std::cout << "Error: Window not found\n";
        return;
    }
    stack.erase(pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xdbf0
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xdc20
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xdba0
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xdc20
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xdc50
testb $0x1, %al
jne 0xd8d3
jmp 0xd8e8
movq 0x156f6(%rip), %rdi     # 0x22fd0
leaq 0xa153(%rip), %rsi      # 0x17a34
callq 0x4240
jmp 0xd906
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xdd00
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xdc90
movq %rax, -0x40(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: nishalkulkarni[P]fluid-wm/master_stack.cpp
// Function: MasterStack::swapMaster(unsigned long)
void MasterStack::swapMaster(Window stack_window)
{
    std::vector<Window>::iterator posCurrent = find(stack.begin(), stack.end(), stack[0]);
    std::vector<Window>::iterator posStack = find(stack.begin(), stack.end(), stack_window);
    if (posCurrent == stack.end() || posStack == stack.end()) {
        std::cout << "Error: Window not found\n";
        return;
    }
    std::swap(*posCurrent, *posStack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xdbf0
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xdc20
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xdd40
movq %rax, %rdx
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xdba0
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0xdbf0
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0xdc20
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xdba0
movq -0x60(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xdc20
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xdc50
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0xd9d1
movq -0x60(%rbp), %rdi
callq 0xdc20
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xdc50
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xd9da
jmp 0xd9ef
movq 0x155ef(%rip), %rdi     # 0x22fd0
leaq 0xa04c(%rip), %rsi      # 0x17a34
callq 0x4240
jmp 0xda11
leaq -0x18(%rbp), %rdi
callq 0xdda0
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xdda0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0xdd60
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::heapify_down(int)
void PriorityQueue::heapify_down(int i)
{
    int left = LEFT(i);
    int right = RIGHT(i);

    int smallest = i;

    if (left < queueSize() && window[left].first < window[i].first)
        smallest = left;

    if (right < queueSize() && window[right].first < window[smallest].first)
        smallest = right;

    if (smallest != i) {
        std::swap(window[i], window[smallest]);
        heapify_down(smallest);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
callq 0xecf0
movq -0x28(%rbp), %rdi
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
callq 0xed10
movq -0x28(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0xee40
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0xedae
movq -0x28(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0xf280
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xf280
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl (%rcx), %eax
jge 0xedae
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
callq 0xee40
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jge 0xedf5
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xf280
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x18(%rbp), %rsi
callq 0xf280
movq %rax, %rcx
movl -0x34(%rbp), %eax
cmpl (%rcx), %eax
jge 0xedf5
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0xee33
movq -0x28(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xf280
movq -0x28(%rbp), %rdi
movq %rax, -0x40(%rbp)
movslq -0x18(%rbp), %rsi
callq 0xf280
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xf2a0
movq -0x28(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xed30
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::insert(unsigned long)
void PriorityQueue::insert(Window w)
{
    numWindows += 1;
    priority[w] = numWindows;
    window.push_back({ numWindows, w });

    int index = queueSize() - 1;
    heapify_up(index);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0x50(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x50(%rdi)
movl 0x50(%rdi), %eax
movl %eax, -0x34(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0xf330
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rsi
movl %ecx, (%rax)
addq $0x50, %rsi
leaq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rdx
callq 0xf390
movq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xf360
movq -0x30(%rbp), %rdi
callq 0xee40
movq -0x30(%rbp), %rdi
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0xee60
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::pop()
void PriorityQueue::pop()
{
    if (empty()) {
        std::cout << "No windows open (Heap underflow)" << std::endl;
        return;
    }

    window[0] = window.back();
    window.pop_back();

    heapify_down(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0xef50
testb $0x1, %al
jne 0xf01f
jmp 0xf043
movq 0x13faa(%rip), %rdi     # 0x22fd0
leaq 0x8a27(%rip), %rsi      # 0x17a54
callq 0x4240
movq %rax, %rdi
movq 0x13f84(%rip), %rsi     # 0x22fc0
callq 0x4290
jmp 0xf07d
movq -0x10(%rbp), %rdi
callq 0xf3c0
movq -0x10(%rbp), %rdi
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0xf280
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0xf400
movq -0x10(%rbp), %rdi
callq 0xf430
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xed30
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::getMaster()
Window PriorityQueue::getMaster()
{
    if (empty()) {
        std::cout << "No windows open (Heap underflow)" << std::endl;
        return -1;
    }

    return window.at(0).second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xef50
testb $0x1, %al
jne 0xf0af
jmp 0xf0db
movq 0x13f1a(%rip), %rdi     # 0x22fd0
leaq 0x8997(%rip), %rsi      # 0x17a54
callq 0x4240
movq %rax, %rdi
movq 0x13ef4(%rip), %rsi     # 0x22fc0
callq 0x4290
movq $-0x1, -0x8(%rbp)
jmp 0xf0f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xf460
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/priority_queue.cpp
// Function: PriorityQueue::swapPriority(unsigned long, unsigned long)
void PriorityQueue::swapPriority(Window a,Window b){
    if(!priority.count(a) || !priority.count(b)){
        std::cout << "Swap window not found" << std::endl;
        return;
    }

    int temp = priority[a];
    priority[a] = priority[b];
    priority[b] = temp;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0xf4a0
cmpq $0x0, %rax
je 0xf146
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xf4a0
cmpq $0x0, %rax
jne 0xf16a
movq 0x13e83(%rip), %rdi     # 0x22fd0
leaq 0x8921(%rip), %rsi      # 0x17a75
callq 0x4240
movq %rax, %rdi
movq 0x13e5d(%rip), %rsi     # 0x22fc0
callq 0x4290
jmp 0xf1c8
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0xf330
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xf330
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
addq $0x18, %rdi
leaq -0x10(%rbp), %rsi
callq 0xf330
movl -0x30(%rbp), %ecx
movq -0x28(%rbp), %rdi
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x18, %rdi
leaq -0x18(%rbp), %rsi
callq 0xf330
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::Create()
std::unique_ptr<WindowManager> WindowManager::Create()
{
    Display* display = XOpenDisplay(nullptr);
    if (display == nullptr) {
        std::cout << "Failed to open X display " << XDisplayName(nullptr) << std::endl;
        return nullptr;
    }
    std::unique_ptr<WindowManager> wmInstance(new WindowManager(display));
    return wmInstance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x43b0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11765
movq 0x118ae(%rip), %rdi     # 0x22fd0
leaq 0x6417(%rip), %rsi      # 0x17b40
callq 0x4240
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x4450
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4240
movq %rax, %rdi
movq 0x1186f(%rip), %rsi     # 0x22fc0
callq 0x4290
movq -0x38(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x130f0
jmp 0x117c8
movb $0x0, -0x11(%rbp)
movl $0x78, %edi
callq 0x4250
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0x117e0
jmp 0x11788
movq -0x48(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x13130
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x117c6
jmp 0x117bd
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x78, %esi
callq 0x4270
jmp 0x117d2
movq -0x38(%rbp), %rdi
callq 0x13160
jmp 0x117c8
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44b0
nopl (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnXError(_XDisplay*, XErrorEvent*)
int WindowManager::OnXError(Display* display, XErrorEvent* e)
{
    const int MAX_ERROR_TEXT_LENGTH = 1024;
    char error_text[MAX_ERROR_TEXT_LENGTH];
    XGetErrorText(display, e->error_code, error_text, sizeof(error_text));

    std::cout << "Received X error:\n"
              << "    Request: " << int(e->request_code)
              << " - " << XRequestCodeToString(e->request_code) << "\n"
              << "    Error code: " << int(e->error_code)
              << " - " << error_text << "\n"
              << "    Resource ID: " << e->resourceid << "\n";
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4b0, %rsp            # imm = 0x4B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x400, -0x14(%rbp)     # imm = 0x400
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %esi
leaq -0x420(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x43e0
movq 0x111f2(%rip), %rdi     # 0x22fd0
leaq 0x626f(%rip), %rsi      # 0x18054
callq 0x4240
movq %rax, %rdi
leaq 0x6273(%rip), %rsi      # 0x18067
callq 0x4240
movq %rax, %rdi
movq -0x10(%rbp), %rax
movzbl 0x21(%rax), %esi
callq 0x4490
movq %rax, %rdi
leaq 0x6262(%rip), %rsi      # 0x18075
callq 0x4240
movq %rax, -0x468(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x21(%rax), %esi
leaq -0x440(%rbp), %rdi
movq %rdi, -0x460(%rbp)
callq 0x5db0
movq -0x468(%rbp), %rdi
movq -0x460(%rbp), %rsi
callq 0x4220
movq %rax, -0x458(%rbp)
jmp 0x11e56
movq -0x458(%rbp), %rdi
leaq 0x60df(%rip), %rsi      # 0x17f43
callq 0x4240
movq %rax, -0x470(%rbp)
jmp 0x11e72
movq -0x470(%rbp), %rdi
leaq 0x61f9(%rip), %rsi      # 0x18079
callq 0x4240
movq %rax, -0x478(%rbp)
jmp 0x11e8e
movq -0x478(%rbp), %rdi
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %esi
callq 0x4490
movq %rax, -0x480(%rbp)
jmp 0x11eab
movq -0x480(%rbp), %rdi
leaq 0x61bc(%rip), %rsi      # 0x18075
callq 0x4240
movq %rax, -0x488(%rbp)
jmp 0x11ec7
movq -0x488(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x4240
movq %rax, -0x490(%rbp)
jmp 0x11ee3
movq -0x490(%rbp), %rdi
leaq 0x6052(%rip), %rsi      # 0x17f43
callq 0x4240
movq %rax, -0x498(%rbp)
jmp 0x11eff
movq -0x498(%rbp), %rdi
leaq 0x617d(%rip), %rsi      # 0x1808a
callq 0x4240
movq %rax, -0x4a0(%rbp)
jmp 0x11f1b
movq -0x4a0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4050
movq %rax, -0x4a8(%rbp)
jmp 0x11f38
movq -0x4a8(%rbp), %rdi
leaq 0x5ffd(%rip), %rsi      # 0x17f43
callq 0x4240
jmp 0x11f4d
leaq -0x440(%rbp), %rdi
callq 0x4150
xorl %eax, %eax
addq $0x4b0, %rsp            # imm = 0x4B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x448(%rbp)
movl %eax, -0x44c(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x4150
movq -0x448(%rbp), %rdi
callq 0x44b0
nop
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnUnmapNotify(XUnmapEvent const&)
void WindowManager::OnUnmapNotify(const XUnmapEvent& e)
{
    if (!clients_.count(e.window)) {
        std::cout << "Ignore UnmapNotify for non-client window " << e.window;
        return;
    }

    if (e.event == root_) {
        std::cout << "Ignore UnmapNotify for reparented pre-existing window "
                  << e.window;
        return;
    }

    Unframe(e.window);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x13200
cmpq $0x0, %rax
jne 0x12734
movq 0x108ba(%rip), %rdi     # 0x22fd0
leaq 0x569f(%rip), %rsi      # 0x17dbc
callq 0x4240
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4050
jmp 0x1277c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x8(%rcx), %rax
jne 0x1276b
movq 0x10883(%rip), %rdi     # 0x22fd0
leaq 0x5692(%rip), %rsi      # 0x17de6
callq 0x4240
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4050
jmp 0x1277c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x12fd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnConfigureRequest(XConfigureRequestEvent const&)
void WindowManager::OnConfigureRequest(const XConfigureRequestEvent& e)
{
    XWindowChanges changes;
    // Copy fields from e to changes.
    changes.x = e.x;
    changes.y = e.y;
    changes.width = e.width;
    changes.height = e.height;
    changes.border_width = e.border_width;
    changes.sibling = e.above;
    changes.stack_mode = e.detail;
    if (clients_.count(e.window)) {
        const Window frame = clients_[e.window];
        XConfigureWindow(display_, frame, e.value_mask, &changes);
        std::cout << "Resize [" << frame << "] to " << Size<int>(e.width, e.height);
    }
    XConfigureWindow(display_, e.window, e.value_mask, &changes);
    std::cout << "Resize " << e.window << " to " << Size<int>(e.width, e.height);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x18(%rbp)
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x13200
cmpq $0x0, %rax
je 0x128fe
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x13310
movq %rax, %rcx
movq -0x58(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x40(%rbp)
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
leaq -0x38(%rbp), %rcx
callq 0x42b0
movq 0x10721(%rip), %rdi     # 0x22fd0
leaq 0x5567(%rip), %rsi      # 0x17e1d
callq 0x4240
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x4050
movq %rax, %rdi
leaq 0x5555(%rip), %rsi      # 0x17e26
callq 0x4240
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
leaq -0x48(%rbp), %rdi
callq 0x6120
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13460
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movl %eax, %edx
leaq -0x38(%rbp), %rcx
callq 0x42b0
movq 0x106a9(%rip), %rdi     # 0x22fd0
leaq 0x54fe(%rip), %rsi      # 0x17e2c
callq 0x4240
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4050
movq %rax, %rdi
leaq 0x54da(%rip), %rsi      # 0x17e27
callq 0x4240
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %edx
leaq -0x50(%rbp), %rdi
callq 0x6120
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x13460
addq $0x70, %rsp
popq %rbp
retq
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::OnButtonPress(XButtonEvent const&)
void WindowManager::OnButtonPress(const XButtonEvent& e)
{
    assert(clients_.count(e.window));
    const Window frame = clients_[e.window];

    drag_start_pos_ = Position<int>(e.x_root, e.y_root);

    Window returned_root;
    int x, y;
    unsigned width, height, border_width, depth;
    assert(XGetGeometry(
        display_,
        frame,
        &returned_root,
        &x, &y,
        &width, &height,
        &border_width,
        &depth));
    drag_start_frame_pos_ = Position<int>(x, y);
    drag_start_frame_size_ = Size<int>(width, height);

    XRaiseWindow(display_, frame);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x13200
cmpq $0x0, %rax
je 0x129b1
jmp 0x129d0
leaq 0x547c(%rip), %rdi      # 0x17e34
leaq 0x5250(%rip), %rsi      # 0x17c0f
movl $0x13b, %edx            # imm = 0x13B
leaq 0x5482(%rip), %rcx      # 0x17e4d
callq 0x4170
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x13310
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x48(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %edx
leaq -0x20(%rbp), %rdi
callq 0x62b0
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x34(%rbp), %r9
leaq -0x38(%rbp), %r11
leaq -0x3c(%rbp), %r10
leaq -0x40(%rbp), %rax
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x4410
cmpl $0x0, %eax
je 0x12a4c
jmp 0x12a6b
leaq 0x5432(%rip), %rdi      # 0x17e85
leaq 0x51b5(%rip), %rsi      # 0x17c0f
movl $0x14a, %edx            # imm = 0x14A
leaq 0x53e7(%rip), %rcx      # 0x17e4d
callq 0x4170
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x62b0
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x58(%rax)
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x6120
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4310
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/fluid_wm.cpp
// Function: WindowManager::Unframe(unsigned long)
void WindowManager::Unframe(Window w)
{
    assert(clients_.count(w));

    const Window frame = clients_[w];
    XUnmapWindow(display_, frame);
    XReparentWindow(
        display_,
        w,
        root_,
        0, 0);
    XRemoveFromSaveSet(display_, w);
    XDestroyWindow(display_, frame);

    clients_.erase(w);

    std::cout << "Unframed window " << w << " [" << frame << "]";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x13200
cmpq $0x0, %rax
je 0x12ffd
jmp 0x1301c
leaq 0x4c69(%rip), %rdi      # 0x17c6d
leaq 0x4c04(%rip), %rsi      # 0x17c0f
movl $0xf4, %edx
leaq 0x4d6e(%rip), %rcx      # 0x17d85
callq 0x4170
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x13310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4420
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0x8(%rax), %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x4030
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x44f0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4460
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x13430
movq 0xff37(%rip), %rdi      # 0x22fd0
leaq 0x4d09(%rip), %rsi      # 0x17da9
callq 0x4240
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4050
movq %rax, %rdi
leaq 0x4d68(%rip), %rsi      # 0x17e23
callq 0x4240
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4050
movq %rax, %rdi
leaq 0x4ce4(%rip), %rsi      # 0x17dba
callq 0x4240
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: nishalkulkarni[P]fluid-wm/main.cpp
// Function: main
int main(int argc, char** argv)
{

    /* std::unique_ptr<WindowManager> window_manager = std::make_unique<WindowManager>(WindowManager::Create()); */
    std::unique_ptr<WindowManager> window_manager(WindowManager::Create());
    if (!window_manager) {
        std::cout << "Failed to initialize window manager.";
        return EXIT_FAILURE;
    }
    std::cout<<"Window manager running"<<std::endl;
    window_manager->Run();

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x116f0
leaq -0x18(%rbp), %rdi
callq 0x15fa0
testb $0x1, %al
jne 0x15f38
movq 0xd0cd(%rip), %rdi      # 0x22fd0
leaq 0x2192(%rip), %rsi      # 0x1809c
callq 0x4240
jmp 0x15f11
movl $0x1, -0x4(%rbp)
movl $0x1, -0x28(%rbp)
jmp 0x15f84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13160
jmp 0x15f96
movq 0xd091(%rip), %rdi      # 0x22fd0
leaq 0x217b(%rip), %rsi      # 0x180c1
callq 0x4240
movq %rax, -0x30(%rbp)
jmp 0x15f51
movq -0x30(%rbp), %rdi
movq 0xd064(%rip), %rsi      # 0x22fc0
callq 0x4290
jmp 0x15f63
leaq -0x18(%rbp), %rdi
callq 0x15fd0
movq %rax, %rdi
callq 0x11940
jmp 0x15f76
movl $0x0, -0x4(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x13160
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x44b0
nop
// File: havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getValue[abi:cxx11](int, int) const
std::string CTable::getValue(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  returnValue = it->second->getValueAsString();
    }

    return returnValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x55b0
movq -0x80(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x78(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9200
movq %rax, -0x70(%rbp)
jmp 0x8d3a
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x9710
movq %rax, -0x98(%rbp)
jmp 0x8d58
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x9770
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9740
testb $0x1, %al
jne 0x8d87
jmp 0x8dd8
leaq -0x28(%rbp), %rdi
callq 0x97a0
movq 0x8(%rax), %rsi
movq (%rsi), %rax
movq 0x28(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x8da3
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5510
leaq -0x68(%rbp), %rdi
callq 0x52a0
jmp 0x8dd8
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x52a0
jmp 0x8dfe
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8dee
movq -0x90(%rbp), %rdi
callq 0x52a0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getCell(int, int) const
CCell * CTable::getCell(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  return it->second;
    } else {
	  throw std::logic_error("ERR: empty cell");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55b0
movq -0x70(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x68(%rbp)
leaq -0xc(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9200
movq %rax, -0x60(%rbp)
jmp 0x8e55
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x9710
movq %rax, -0x78(%rbp)
jmp 0x8e70
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
callq 0x9770
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x9740
testb $0x1, %al
jne 0x8e9c
jmp 0x8ed1
leaq -0x38(%rbp), %rdi
callq 0x97a0
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52a0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8f2a
movl $0x10, %edi
callq 0x5200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq 0x13584(%rip), %rsi     # 0x1c473
callq 0x55d0
jmp 0x8ef6
movq -0x88(%rbp), %rdi
movq 0x1f0d4(%rip), %rsi     # 0x27fd8
movq 0x1f0b5(%rip), %rdx     # 0x27fc0
callq 0x56f0
jmp 0x8f3c
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x5310
leaq -0x30(%rbp), %rdi
callq 0x52a0
movq -0x48(%rbp), %rdi
callq 0x5730
nopl (%rax)
// File: havluj[P]spreadsheet/src/CTable.cpp
// Function: CTable::getExpression[abi:cxx11](int, int) const
std::string CTable::getExpression(int row, int col) const {
    std::string returnValue;

    auto it = m_database.find(std::make_pair(row, col));
    if (it != m_database.end()) {
	  returnValue = it->second->getExpression();
    }

    return returnValue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x55b0
movq -0x80(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x78(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9200
movq %rax, -0x70(%rbp)
jmp 0x8f9a
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x9710
movq %rax, -0x98(%rbp)
jmp 0x8fb8
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x9770
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9740
testb $0x1, %al
jne 0x8fe7
jmp 0x9038
leaq -0x28(%rbp), %rdi
callq 0x97a0
movq 0x8(%rax), %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x9003
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5510
leaq -0x68(%rbp), %rdi
callq 0x52a0
jmp 0x9038
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x52a0
jmp 0x905e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x904e
movq -0x90(%rbp), %rdi
callq 0x52a0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5730
nopw (%rax,%rax)
// File: havluj[P]spreadsheet/src/CEquation.cpp
// Function: CEquation::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::set<std::pair<int, int>> CEquation::update(std::string exp) {
    m_error = false;

    m_affectedBy.clear();
    m_expression = exp;

    compute();

    return m_affectedBy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movb $0x0, 0x58(%rdi)
addq $0x88, %rdi
callq 0xf190
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x5040
movq -0x30(%rbp), %rdi
callq 0xd410
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
addq $0x88, %rsi
callq 0xa200
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)