LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::contains(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool contains(const E& key) const {
			// returns true if value(key) is in tree
			size_t i;

			for (i = 0; i < elements; i++) {
				if (keys[i] > key) // key isn't in this node
					break;
				else if (keys[i] == key) 
					return true;
			}

			if (leaf) // key isn't in tree
				return false;

			return children[i]->contains(key); // if node, check child for key
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
callq 0x31d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0xb8(%rcx), %rax
jae 0x7474
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x5aa0
testb $0x1, %al
jne 0x7438
jmp 0x743a
jmp 0x7474
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0x745c
jmp 0x7462
movb $0x1, -0x1(%rbp)
jmp 0x74a2
jmp 0x7464
jmp 0x7466
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7405
movq -0x28(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x7487
movb $0x0, -0x1(%rbp)
jmp 0x74a2
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x73d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::num_keys()
size_t num_keys() { // returns the num of keys in the leafs reachable from the current node (size of tree)
			if (leaf)
				return elements;
			
			size_t sum = 0;
			for (size_t i = 0; i < elements+1; i++)
				sum += children[i]->num_keys();

			return sum;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
callq 0x31d0
movq -0x30(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
testb $0x1, 0xc0(%rax)
je 0x74eb
movq -0x28(%rbp), %rax
movq 0xb8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7543
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0xb8(%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x753b
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x74b0
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x74fb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::min()
E& min() {
			if (leaf)
				return keys[0];
			else
				return children[0]->min();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
callq 0x31d0
movq -0x20(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0xc0(%rax)
je 0x7818
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x8(%rbp)
jmp 0x7829
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x77e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::max()
E& max() {
			if (leaf)
				return keys[elements-1];
			else
				return children[elements]->max();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
callq 0x31d0
movq -0x20(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0xc0(%rax)
je 0x79cd
movq -0x18(%rbp), %rcx
movq %rcx, %rax
addq $0x38, %rax
movq 0xb8(%rcx), %rcx
subq $0x1, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x79e6
movq -0x18(%rbp), %rax
movq 0xb8(%rax), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x7980
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: miniplane[P]mintree/./BpTree.h
// Function: BpTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 2ul>::Node::print(std::ostream&, int) const
std::ostream& print (std::ostream& o, int depth) const {
			for (int j = 0; j < depth; j++)
				o << "  ";

			if (leaf)
				o << "leaf : " << this << std::endl;
			else
				o << "inner: " << this << std::endl;
			for (size_t i = 0; i < elements; i++) {
				if (!leaf)
					children[i]->print(o, depth+1);
				for (int j = 0; j < depth; j++) {
					o << "  ";				// one space per depth
				}
				o << "  " << keys[i] << std::endl;
			}
			if (!leaf)
				children[elements]->print(o, depth+1); // calls print for children
			return o;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movl %edx, -0x34(%rbp)
callq 0x31d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl -0x34(%rbp), %edx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7a50
movq -0x10(%rbp), %rdi
leaq 0x1baf(%rip), %rsi      # 0x95ef
callq 0x3240
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7a2d
movq -0x30(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x7a8a
movq -0x10(%rbp), %rdi
leaq 0x1b8a(%rip), %rsi      # 0x95f2
callq 0x3240
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
movq 0x452d(%rip), %rsi      # 0xbfb0
callq 0x3280
jmp 0x7ab5
movq -0x10(%rbp), %rdi
leaq 0x1b65(%rip), %rsi      # 0x95fa
callq 0x3240
movq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
movq 0x4500(%rip), %rsi      # 0xbfb0
callq 0x3280
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0xb8(%rcx), %rax
jae 0x7b70
movq -0x30(%rbp), %rax
testb $0x1, 0xc0(%rax)
jne 0x7afb
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x79f0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7b25
movq -0x10(%rbp), %rdi
leaq 0x1ada(%rip), %rsi      # 0x95ef
callq 0x3240
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7b02
movq -0x10(%rbp), %rdi
leaq 0x1abf(%rip), %rsi      # 0x95ef
callq 0x3240
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rsi
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x3210
movq %rax, %rdi
movq 0x4456(%rip), %rsi      # 0xbfb0
callq 0x3280
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7abd
movq -0x30(%rbp), %rax
testb $0x1, 0xc0(%rax)
jne 0x7b9c
movq -0x30(%rbp), %rax
movq 0xb8(%rax), %rcx
movq 0x8(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x79f0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/graph_traverse.cpp
// Function: DFS_trim(int, int, int, int)
void DFS_trim(int source, int thisnode, int thislvl, int toplvl){


//    if(nodestatus[thisnode]==source){
//        if(longestpath.size()<thispath.size()){
//            longestcontig=thiscontig;
//            longestpath=thispath;
//        }
//        return;
//    }

    if(nodestatus[thisnode]==source){
        nothit++;
    }

    if(nodestatus[thisnode]==source || thislvl>=toplvl){
        if(thislvl>maxlvl)
            maxlvl=thislvl;
        return;
    }

    nodestatus[thisnode]=source;

    for(int nextnode: graphf[thisnode]){

        DFS_trim(source,nextnode,thislvl+1,toplvl);

    }

    if(thislvl>maxlvl)
            maxlvl=thislvl;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0x11a31(%rip), %rdi     # 0x14290
callq 0x54f0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x287a
movl 0x11a3b(%rip), %eax     # 0x142ac
addl $0x1, %eax
movl %eax, 0x11a32(%rip)     # 0x142ac
movslq -0x8(%rbp), %rsi
leaq 0x11a0b(%rip), %rdi     # 0x14290
callq 0x54f0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x2899
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x28b2
movl -0xc(%rbp), %eax
cmpl 0x11a0e(%rip), %eax     # 0x142b0
jle 0x28ad
movl -0xc(%rbp), %eax
movl %eax, 0x11a03(%rip)     # 0x142b0
jmp 0x294f
movl -0x4(%rbp), %eax
movl %eax, -0x30(%rbp)
movslq -0x8(%rbp), %rsi
leaq 0x119cd(%rip), %rdi     # 0x14290
callq 0x54f0
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
movslq -0x8(%rbp), %rsi
leaq 0x118f0(%rip), %rdi     # 0x141c8
callq 0x57f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5810
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5840
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5870
testb $0x1, %al
jne 0x290e
jmp 0x293b
leaq -0x20(%rbp), %rdi
callq 0x58b0
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movl -0x2c(%rbp), %esi
movl -0xc(%rbp), %edx
addl $0x1, %edx
movl -0x10(%rbp), %ecx
callq 0x2840
leaq -0x20(%rbp), %rdi
callq 0x58d0
jmp 0x28fb
movl -0xc(%rbp), %eax
cmpl 0x1196c(%rip), %eax     # 0x142b0
jle 0x294f
movl -0xc(%rbp), %eax
movl %eax, 0x11961(%rip)     # 0x142b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kingufl[P]Rmapper/graph_traverse.cpp
// Function: parseArgs(int, char* const*, Args&)
void parseArgs(int argc, char *const argv[], Args &arg)
{
  int c;
  extern char *optarg;
  extern int optind;

  std::string usage("usage: " + std::string(argv[0]) + " indir\n\n" +
                    "Traverse the bi-labelled de Bruijn graph in the directory [indir].\n");

  // the only input parameter is the directory name
  if (argc == 2)
  {
    arg.dirname.assign(argv[1]);
  }
  else
  {
    cerr << "Invalid number of arguments\n" << usage;
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x22f0
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x2230
jmp 0x29b3
leaq 0xa65e(%rip), %rsi      # 0xd018
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0x5940
jmp 0x29cc
leaq 0xa64d(%rip), %rdx      # 0xd020
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x58f0
jmp 0x29e2
leaq 0xa640(%rip), %rdx      # 0xd029
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x58f0
jmp 0x29f8
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x80(%rbp), %rdi
callq 0x2130
leaq -0xa0(%rbp), %rdi
callq 0x2130
leaq -0xa1(%rbp), %rdi
callq 0x21f0
cmpl $0x2, -0x4(%rbp)
jne 0x2adb
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2320
jmp 0x2a3f
jmp 0x2b13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2ab0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2aa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
jmp 0x2a9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x80(%rbp), %rdi
callq 0x2130
leaq -0xa0(%rbp), %rdi
callq 0x2130
leaq -0xa1(%rbp), %rdi
callq 0x21f0
jmp 0x2b25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2130
jmp 0x2b25
movq 0x1150e(%rip), %rdi     # 0x13ff0
leaq 0xa584(%rip), %rsi      # 0xd06d
callq 0x21b0
movq %rax, -0xd0(%rbp)
jmp 0x2af7
movq -0xd0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2190
jmp 0x2b09
movl $0x1, %edi
callq 0x2200
leaq -0x40(%rbp), %rdi
callq 0x2130
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)
// File: Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::~World()
Ecs::World::~World() {
  for (auto *it: _systems)
    delete it;
  for (auto *it: _entities)
    delete it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9ec0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9890
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x91c0
testb $0x1, %al
jne 0xb199
jmp 0xb1ce
leaq -0x18(%rbp), %rdi
callq 0x93e0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xb1c1
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xb1c3
leaq -0x18(%rbp), %rdi
callq 0x9d00
jmp 0xb186
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9710
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x96a0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x93b0
testb $0x1, %al
jne 0xb203
jmp 0xb245
leaq -0x38(%rbp), %rdi
callq 0x9800
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xb238
movq -0x60(%rbp), %rdi
callq 0x9c30
movq -0x60(%rbp), %rdi
movl $0x18, %esi
callq 0x98f0
jmp 0xb23a
leaq -0x38(%rbp), %rdi
callq 0x9ee0
jmp 0xb1f0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
callq 0x99c0
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x9180
movq -0x50(%rbp), %rdi
callq 0xa0e0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::update()
void Ecs::World::update() {
  std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();

  for (auto *it: _systems)
    it->update(*this);
  _time = std::chrono::steady_clock::now() - start;
  std::this_thread::sleep_for(_sleepDuration - _time);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x9b80
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x10(%rbp)
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9ec0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9890
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x91c0
testb $0x1, %al
jne 0xb309
jmp 0xb332
leaq -0x20(%rbp), %rdi
callq 0x93e0
movq -0x50(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x20(%rbp), %rdi
callq 0x9d00
jmp 0xb2f6
callq 0x9b80
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9a10
movq -0x50(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, 0xb0(%rsi)
movq %rsi, %rdi
addq $0xb8, %rdi
addq $0xb0, %rsi
callq 0x9ef0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x96f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Emeraude[P]ECS/src/World.cpp
// Function: Ecs::World::add(Ecs::Entity*)
unsigned int Ecs::World::add(Ecs::Entity *e) {
  if (_garbage.empty()) {
    _entities.push_back(e);
    return _entities.size() - 1;
  }
  else {
    unsigned int const id = _garbage.front();
    delete _entities[id];
    _entities[id] = e;
    _garbage.pop();
    return id;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x30, %rdi
callq 0x9bd0
testb $0x1, %al
jne 0xb477
jmp 0xb496
movq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9290
movq -0x28(%rbp), %rdi
callq 0x9d60
subq $0x1, %rax
movl %eax, -0x4(%rbp)
jmp 0xb50a
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x9310
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x96e0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xb4da
movq -0x30(%rbp), %rdi
callq 0x9c30
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x98f0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x96e0
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rdi
movq %rcx, (%rax)
addq $0x30, %rdi
callq 0x9490
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	tommy_hashlin h;
	tommy_hashlin_init(&h);
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t key;
		intcell_t *p;
		x = hash32(x);
		key = get_key(n, x);
		p = tommy_hashlin_search(&h, compare, &key, hash_fn(key));
		if (!p) {
			p = malloc(sizeof(intcell_t));
			p->key = key, p->cnt = 1;
			tommy_hashlin_insert(&h, &p->node, p, hash_fn(key));
			++z;
		} else z += ++p->cnt;
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", tommy_hashlin_count(&h), z);
	x = tommy_hashlin_count(&h);
	tommy_hashlin_done(&h);
	return x;
}

// Assembly:
subq $0x168, %rsp            # imm = 0x168
movl %edi, 0x164(%rsp)
movl %esi, 0x160(%rsp)
movl $0x0, 0x154(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5280
movl $0x0, 0x15c(%rsp)
movl 0x160(%rsp), %eax
movl %eax, 0x158(%rsp)
movl 0x15c(%rsp), %eax
cmpl 0x164(%rsp), %eax
jae 0x1703
movl 0x158(%rsp), %edi
callq 0x1250
movl %eax, 0x158(%rsp)
movl 0x164(%rsp), %edi
movl 0x158(%rsp), %esi
callq 0x12c0
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %edi
callq 0x1830
movl %eax, %ecx
leaq 0x30(%rsp), %rdi
leaq 0x128(%rip), %rsi       # 0x1770
leaq 0x2c(%rsp), %rdx
callq 0x17a0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x16cf
movl $0x28, %edi
callq 0x1090
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl $0x1, 0x4(%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %edi
callq 0x1830
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %eax, %ecx
leaq 0x30(%rsp), %rdi
callq 0x5410
movl 0x154(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x154(%rsp)
jmp 0x16eb
movq 0x20(%rsp), %rcx
movl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x4(%rcx)
addl 0x154(%rsp), %eax
movl %eax, 0x154(%rsp)
jmp 0x16ed
movl 0x15c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x15c(%rsp)
jmp 0x15f3
movq 0x88ee(%rip), %rax      # 0x9ff8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1840
movq 0x8(%rsp), %rdi
movl %eax, %edx
movl 0x154(%rsp), %ecx
leaq 0x5944(%rip), %rsi      # 0x7075
movb $0x0, %al
callq 0x1080
leaq 0x30(%rsp), %rdi
callq 0x1840
movl %eax, 0x158(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x53a0
movl 0x158(%rsp), %eax
addq $0x168, %rsp            # imm = 0x168
retq
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/tommyds/./tommyhashlin.h
// Function: tommy_hashlin_search
tommy_inline void* tommy_hashlin_search(tommy_hashlin* hashlin, tommy_search_func* cmp, const void* cmp_arg, tommy_hash_t hash)
{
	tommy_hashlin_node* i = tommy_hashlin_bucket(hashlin, hash);

	while (i) {
		/* we first check if the hash matches, as in the same bucket we may have multiples hash values */
		if (i->key == hash && cmp(cmp_arg, i->data) == 0)
			return i->data;
		i = i->next;
	}
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1860
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1819
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x180a
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x180a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x1822
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x17ca
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: xdsopl[P]FEC/tables_generator.cc
// Function: main
int main()
{
	std::cout << "/* generated by generator.cc */" << std::endl << std::endl;
	std::cout << "template <int M, int POLY, typename TYPE>" << std::endl;
	std::cout << "struct Tables {};" << std::endl << std::endl;

	// BBC WHP031 RS(15, 11) T=2
	GENERATOR(4, 0b10011, uint8_t);

	// DVB-T RS(255, 239) T=8
	GENERATOR(8, 0b100011101, uint8_t);

	// FUN RS(65535, 65471) T=32
	GENERATOR(16, 0b10001000000001011, uint16_t);

	// DVB-S2 FULL BCH(65535, 65343) T=12
	GENERATOR(16, 0b10000000000101101, uint16_t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x3dfd(%rip), %rdi      # 0x4fd8
leaq 0x1e22(%rip), %rsi      # 0x3004
callq 0x1050
movq %rax, %rdi
movq 0x3dd7(%rip), %rsi      # 0x4fc8
callq 0x1060
movq %rax, %rdi
movq 0x3dc8(%rip), %rsi      # 0x4fc8
callq 0x1060
movq 0x3dcc(%rip), %rdi      # 0x4fd8
leaq 0x1e11(%rip), %rsi      # 0x3024
callq 0x1050
movq %rax, %rdi
movq 0x3da6(%rip), %rsi      # 0x4fc8
callq 0x1060
movq 0x3daa(%rip), %rdi      # 0x4fd8
leaq 0x1e19(%rip), %rsi      # 0x304e
callq 0x1050
movq %rax, %rdi
movq 0x3d84(%rip), %rsi      # 0x4fc8
callq 0x1060
movq %rax, %rdi
movq 0x3d75(%rip), %rsi      # 0x4fc8
callq 0x1060
leaq 0x1e01(%rip), %rdi      # 0x3060
callq 0x1290
leaq 0x1df5(%rip), %rdi      # 0x3060
callq 0x14e0
leaq 0x1df1(%rip), %rdi      # 0x3068
callq 0x17c0
leaq 0x1de5(%rip), %rdi      # 0x3068
callq 0x1ab0
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: xdsopl[P]FEC/tables_generator.cc
// Function: TablesGenerator<4, 19, unsigned char>::print(unsigned char*, char const*, char const*, int)
static void print(TYPE *table, const char *name, const char *type, int size)
	{
		std::cout << "\tstatic " << type << " " << name << "(" << type << " a)\n\t{\n\t\t";
		std::cout << "static const " << type << " table[" << size << "] = {";
		for (int i = 0; i < size; ++i) {
			std::cout << " " << (int)table[i];
			if (i < size - 1)
				std::cout << ",";
		}
		std::cout << " };" << std::endl;
		std::cout << "\t\treturn table[a];\n\t}\n";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq 0x31da(%rip), %rdi      # 0x4fd8
leaq 0x135b(%rip), %rsi      # 0x3160
callq 0x1050
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x1319(%rip), %rsi      # 0x3139
callq 0x1050
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x132e(%rip), %rsi      # 0x3169
callq 0x1050
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x1315(%rip), %rsi      # 0x316b
callq 0x1050
movq 0x3176(%rip), %rdi      # 0x4fd8
leaq 0x130c(%rip), %rsi      # 0x3175
callq 0x1050
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movq %rax, %rdi
leaq 0x12ff(%rip), %rsi      # 0x3183
callq 0x1050
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0x12ed(%rip), %rsi      # 0x318b
callq 0x1050
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1f06
movq 0x311f(%rip), %rdi      # 0x4fd8
leaq 0x1279(%rip), %rsi      # 0x3139
callq 0x1050
movq %rax, %rdi
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x1080
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1ef9
movq 0x30eb(%rip), %rdi      # 0x4fd8
leaq 0x129d(%rip), %rsi      # 0x3191
callq 0x1050
jmp 0x1efb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1eaa
movq 0x30cb(%rip), %rdi      # 0x4fd8
leaq 0x127f(%rip), %rsi      # 0x3193
callq 0x1050
movq %rax, %rdi
movq 0x30a5(%rip), %rsi      # 0x4fc8
callq 0x1060
movq 0x30a9(%rip), %rdi      # 0x4fd8
leaq 0x1261(%rip), %rsi      # 0x3197
callq 0x1050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: onai[P]npio/./npio.h
// Function: npio::Array::Array(char const*, unsigned long)
Array(const char* filename, size_t max_dim = NPIO_DEFAULT_MAX_DIM)
    {
      npio_init_array(&array);
      #ifdef NPIO_CXX_ENABLE_EXCEPTIONS
        if (int err = npio_load3(filename, &array, max_dim))
          throw std::system_error(err, std::system_category());
      #else
        err = npio_load3(filename, &array, max_dim);
      #endif
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2490
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
callq 0x2580
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x3917
movl $0x20, %edi
callq 0x2090
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
callq 0x20b0
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq %rax, %rdx
callq 0x3a20
jmp 0x38e9
movq -0x50(%rbp), %rdi
movq 0x269c(%rip), %rsi      # 0x5f90
movq 0x26b5(%rip), %rdx      # 0x5fb0
callq 0x2190
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x20d0
jmp 0x391d
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x21a0
nopw %cs:(%rax,%rax)
// File: cpottamus[P]btree_lab/deletedisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<2) { 
    usage();
    exit(-1);
  }

  remove((string(argv[1])+".data").c_str());
  remove((string(argv[1])+".bitmap").c_str());
  remove((string(argv[1])+".config").c_str());

  cerr << "Done.\n";

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x237e
callq 0x2330
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2140
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x21a0
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x2640
jmp 0x23b6
leaq 0xc63(%rip), %rdx       # 0x3020
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x25f0
jmp 0x23cc
leaq -0x30(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x2060
movq %rax, %rdi
callq 0x21c0
movq -0x120(%rbp), %rdi
callq 0x2090
leaq -0x50(%rbp), %rdi
callq 0x2090
leaq -0x51(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0xa9(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x21a0
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
callq 0x2640
jmp 0x2440
leaq 0xbdf(%rip), %rdx       # 0x3026
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x25f0
jmp 0x245c
leaq -0x88(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x2060
movq %rax, %rdi
callq 0x21c0
movq -0x138(%rbp), %rdi
callq 0x2090
leaq -0xa8(%rbp), %rdi
callq 0x2090
leaq -0xa9(%rbp), %rdi
callq 0x2110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x130(%rbp)
leaq -0xf1(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x21a0
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
leaq -0xf0(%rbp), %rdi
callq 0x2640
jmp 0x24d9
leaq 0xb4e(%rip), %rdx       # 0x302e
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x25f0
jmp 0x24f5
leaq -0xd0(%rbp), %rdi
callq 0x2060
movq %rax, %rdi
callq 0x21c0
leaq -0xd0(%rbp), %rdi
callq 0x2090
leaq -0xf0(%rbp), %rdi
callq 0x2090
leaq -0xf1(%rbp), %rdi
callq 0x2110
movq 0x2abc(%rip), %rdi      # 0x4ff0
leaq 0xafb(%rip), %rsi       # 0x3036
callq 0x20f0
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x256e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2090
leaq -0x51(%rbp), %rdi
callq 0x2110
jmp 0x25df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x259f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2090
leaq -0xa9(%rbp), %rdi
callq 0x2110
jmp 0x25df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x2090
leaq -0xf1(%rbp), %rdi
callq 0x2110
movq -0x60(%rbp), %rdi
callq 0x2190
nopl (%rax,%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: SkeletonDecoder::SkeletonDecoder(unsigned int)
SkeletonDecoder::SkeletonDecoder(ogg_uint32_t serial) :
  Decoder(serial),
  mGotAllHeaders(0),
  mVersionMajor(0),
  mVersionMinor(0),
  mVersion(0)
{
  for (ogg_uint32_t i=0; i<mPackets.size(); i++) {
    delete[] mPackets[i]->packet;
    mPackets[i]->packet = 0;
    delete mPackets[i];
  }
  ClearKeyframeIndex(mIndex);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl 0x4c(%rsp), %esi
callq 0x5ba0
movq 0x30(%rsp), %rdi
leaq 0x21e44(%rip), %rax     # 0x27ae0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x1b8, %rdi            # imm = 0x1B8
movq %rdi, 0x18(%rsp)
callq 0x6950
movq 0x30(%rsp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq %rdi, 0x20(%rsp)
callq 0x6960
movq 0x30(%rsp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq %rdi, 0x28(%rsp)
callq 0x6970
movq 0x30(%rsp), %rax
movb $0x0, 0x218(%rax)
movw $0x0, 0x21a(%rax)
movw $0x0, 0x21c(%rax)
movl $0x0, 0x220(%rax)
movl $0x0, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movl 0x48(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x6980
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5dd2
movq 0x30(%rsp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x69a0
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5d6d
movq 0x8(%rsp), %rdi
callq 0x5540
movq 0x30(%rsp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x69a0
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq $0x0, (%rax)
addq $0x1d0, %rdi            # imm = 0x1D0
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x69a0
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5dc0
movq (%rsp), %rdi
movl $0x30, %esi
callq 0x5400
jmp 0x5dc2
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x5d10
movq 0x30(%rsp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x5e30
jmp 0x5de5
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x69c0
movq 0x20(%rsp), %rdi
callq 0x69d0
movq 0x18(%rsp), %rdi
callq 0x6a30
movq 0x30(%rsp), %rdi
callq 0x5c30
movq 0x40(%rsp), %rdi
callq 0x57d0
nopw (%rax,%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: ClearKeyframeIndex(std::map<unsigned int, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, std::vector<KeyFrameInfo, std::allocator<KeyFrameInfo>>*>>>&)
void ClearKeyframeIndex(KeyFrameIndex& index) {
  KeyFrameIndex::iterator itr = index.begin();
  while (itr != index.end()) {
    vector<KeyFrameInfo>* v = itr->second;
    delete v;
    itr++;
  }
  index.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x6f00
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x6f50
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6f30
testb $0x1, %al
jne 0x5e6c
jmp 0x5ebb
leaq 0x28(%rsp), %rdi
callq 0x6f80
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5ea8
movq 0x8(%rsp), %rdi
callq 0x6a30
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x5400
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x6fa0
movq %rax, 0x10(%rsp)
jmp 0x5e48
movq 0x30(%rsp), %rdi
callq 0x6fe0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: IsSkeletonPacket(ogg_packet*)
static bool
IsSkeletonPacket(ogg_packet* packet)
{
  return (packet->e_o_s && packet->bytes == 0) ||
         (packet->bytes > 8 &&
           (memcmp(packet->packet, "fishead", 8) == 0 ||
            memcmp(packet->packet, "fisbone", 8) == 0)) ||
         IsIndexPacket(packet);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x66e7
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpq $0x0, 0x8(%rcx)
movb %al, 0xf(%rsp)
je 0x6753
movq 0x10(%rsp), %rax
cmpq $0x8, 0x8(%rax)
jle 0x6745
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movabsq $0x64616568736966, %rcx # imm = 0x64616568736966
subq %rcx, %rax
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x6753
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movabsq $0x656e6f62736966, %rcx # imm = 0x656E6F62736966
subq %rcx, %rax
setne %al
movzbl %al, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x6753
movq 0x10(%rsp), %rdi
callq 0x15ec0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: Decoder::Create(ogg_page*)
Decoder* Decoder::Create(ogg_page* page)
{
  assert(ogg_page_bos(page));
  ogg_uint32_t serialno = ogg_page_serialno(page);
  if (page->body_len > 8 &&
      strncmp("theora", (const char*)page->body+1, 6) == 0)
  {
    return new TheoraDecoder(serialno);
  } else if (page->body_len > 8 &&
             strncmp("vorbis", (const char*)page->body+1, 6) == 0)
  {
    return new VorbisDecoder(serialno);
#ifdef HAVE_KATE
  } else if (page->body_len > 8 &&
             memcmp("kate\0\0\0", (const char*)page->body+1, 7) == 0)
  {
    return new KateDecoder(serialno);
#endif
  } else if (page->body_len > 8 &&
             strncmp("fishead", (const char*)page->body, 8) == 0)
  {
    return new SkeletonDecoder(serialno);
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x57f0
cmpl $0x0, %eax
je 0x677a
jmp 0x6799
leaq 0x16a0c(%rip), %rdi     # 0x1d18d
leaq 0x16885(%rip), %rsi     # 0x1d00d
movl $0x3ed, %edx            # imm = 0x3ED
leaq 0x16a0c(%rip), %rcx     # 0x1d1a0
callq 0x5280
movq 0x38(%rsp), %rdi
callq 0x5350
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x8, 0x18(%rax)
jle 0x6827
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
addq $0x1, %rsi
leaq 0x16f10(%rip), %rdi     # 0x1d6d7
movl $0x6, %edx
callq 0x51e0
cmpl $0x0, %eax
jne 0x6827
movl $0x290, %edi            # imm = 0x290
callq 0x53e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x34(%rsp), %esi
callq 0x6ac0
jmp 0x67f6
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x692a
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x290, %esi            # imm = 0x290
callq 0x5400
jmp 0x6934
movq 0x38(%rsp), %rax
cmpq $0x8, 0x18(%rax)
jle 0x68a7
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
addq $0x1, %rsi
leaq 0x16fd4(%rip), %rdi     # 0x1d81b
movl $0x6, %edx
callq 0x51e0
cmpl $0x0, %eax
jne 0x68a7
movl $0x388, %edi            # imm = 0x388
callq 0x53e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0x34(%rsp), %esi
callq 0x6be0
jmp 0x6876
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x692a
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x388, %esi            # imm = 0x388
callq 0x5400
jmp 0x6934
movq 0x38(%rsp), %rax
cmpq $0x8, 0x18(%rax)
jle 0x691d
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x16909(%rip), %rdi     # 0x1d1cc
movl $0x8, %edx
callq 0x51e0
cmpl $0x0, %eax
jne 0x691d
movl $0x228, %edi            # imm = 0x228
callq 0x53e0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %esi
callq 0x5c70
jmp 0x68f2
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x692a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x228, %esi            # imm = 0x228
callq 0x5400
jmp 0x6934
jmp 0x691f
jmp 0x6921
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x57d0
nop
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.fps_numerator;
    f.mGranDenom = mInfo.fps_denominator;
    f.mPreroll = 0;
    f.mGranuleShift = mInfo.keyframe_granule_shift;
    f.mRadix = 0;
    f.mContentType = "video/theora";
    f.mRole = "video/main";
    f.mName = "video_1";
    return f;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaeb0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x1d4(%rax), %ecx
movq %rcx, (%rdi)
movl 0x1d8(%rax), %ecx
movq %rcx, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl 0x1f4(%rax), %eax
movl %eax, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x14d03(%rip), %rsi     # 0x1d6d1
callq 0x5580
jmp 0x89d5
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
leaq 0x14cf9(%rip), %rsi     # 0x1d6de
callq 0x5580
jmp 0x89ec
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
leaq 0x14ced(%rip), %rsi     # 0x1d6e9
callq 0x5580
jmp 0x8a03
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x8a35
jmp 0x8a2b
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xaf10
jmp 0x8a3f
movq 0x18(%rsp), %rdi
callq 0xaf10
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x57d0
nopl (%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::TheoraHeaderType(ogg_packet*)
const char* TheoraHeaderType(ogg_packet* packet) {
    switch (packet->packet[0]) {
      case 0x80: return "Ident";
      case 0x81: return "Comment";
      case 0x82: return "Setup";
      default: return "UNKNOWN";
    }
  }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rsp)
subl $0x80, %eax
je 0x8f6c
jmp 0x8f52
movl -0x1c(%rsp), %eax
subl $0x81, %eax
je 0x8f7a
jmp 0x8f5f
movl -0x1c(%rsp), %eax
subl $0x82, %eax
je 0x8f88
jmp 0x8f96
leaq 0x14636(%rip), %rax     # 0x1d5a9
movq %rax, -0x8(%rsp)
jmp 0x8fa2
leaq 0x1462e(%rip), %rax     # 0x1d5af
movq %rax, -0x8(%rsp)
jmp 0x8fa2
leaq 0x14628(%rip), %rax     # 0x1d5b7
movq %rax, -0x8(%rsp)
jmp 0x8fa2
leaq 0x14620(%rip), %rax     # 0x1d5bd
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: TheoraDecoder::DumpPacket(TheoraDecoder::Frame&)
void DumpPacket(Frame& f) {
    if (gOptions.GetDumpPackets() ||
        (f.is_keyframe && gOptions.GetDumpKeyPackets()))
    {
      cout << "[T] " << (f.is_keyframe ? "keyframe" : "frame")
           << " time_ms=[" << StartTime(f.granulepos) << ","
           << EndTime(f.granulepos) << "] granulepos=" << f.granulepos
           << " packetno=" << f.packetno
           << (f.e_o_s ? " eos" : "")
           << endl;
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x1f2d1(%rip), %rdi     # 0x284e0
callq 0x10970
testb $0x1, %al
jne 0x923c
movq 0x18(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x934d
leaq 0x1f2b2(%rip), %rdi     # 0x284e0
callq 0xa360
testb $0x1, %al
jne 0x923c
jmp 0x934d
movq 0x1ed8d(%rip), %rdi     # 0x27fd0
leaq 0x1437b(%rip), %rsi     # 0x1d5c5
callq 0x53d0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movb 0x10(%rax), %cl
leaq 0x1436c(%rip), %rsi     # 0x1d5cd
leaq 0x14362(%rip), %rax     # 0x1d5ca
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x53d0
movq %rax, %rdi
leaq 0x1453e(%rip), %rsi     # 0x1d7bc
callq 0x53d0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x90d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x5810
movq %rax, %rdi
leaq 0x14e10(%rip), %rsi     # 0x1e0c0
callq 0x53d0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x9150
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5810
movq %rax, %rdi
leaq 0x142ef(%rip), %rsi     # 0x1d5d3
callq 0x53d0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x5810
movq %rax, %rdi
leaq 0x142dd(%rip), %rsi     # 0x1d5e1
callq 0x53d0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x5810
movq %rax, %rdi
movq 0x18(%rsp), %rax
movb 0x11(%rax), %cl
leaq 0x150a1(%rip), %rsi     # 0x1e3cc
leaq 0x140b7(%rip), %rax     # 0x1d3e9
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x53d0
movq %rax, %rdi
movq 0x1ec78(%rip), %rsi     # 0x27fc0
callq 0x5430
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: VorbisDecoder::GetFisboneInfo()
virtual FisboneInfo GetFisboneInfo() {
    FisboneInfo f;
    f.mGranNumer = mInfo.rate;
    f.mGranDenom = 1;
    f.mPreroll = 2;
    f.mGranuleShift = 0;
    f.mRadix = 0;
    f.mContentType = "audio/vorbis";
    f.mRole = "audio/main";
    f.mName = "audio_1";
    return f;
  }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xaeb0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x1e8(%rax), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
movl $0x2, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
movl $0x0, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x1207a(%rip), %rsi     # 0x1d815
callq 0x5580
jmp 0xb7a2
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
leaq 0x12070(%rip), %rsi     # 0x1d822
callq 0x5580
jmp 0xb7b9
movq 0x18(%rsp), %rdi
addq $0x60, %rdi
leaq 0x12064(%rip), %rsi     # 0x1d82d
callq 0x5580
jmp 0xb7d0
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0xb802
jmp 0xb7f8
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0xaf10
jmp 0xb80c
movq 0x18(%rsp), %rdi
callq 0xaf10
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x57d0
nopw %cs:(%rax,%rax)
// File: cpearce[P]OggIndex/src/Decoder.cpp
// Function: VorbisDecoder::VorbisHeaderType(ogg_packet*)
const char* VorbisHeaderType(ogg_packet* packet) {
    switch (packet->packet[0]) {
      case 0x1: return "Ident";
      case 0x3: return "Comment";
      case 0x5: return "Setup";
      default: return "UNKNOWN";
    }
  }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x1c(%rsp)
subl $0x1, %eax
je 0xb856
jmp 0xb840
movl -0x1c(%rsp), %eax
subl $0x3, %eax
je 0xb864
jmp 0xb84b
movl -0x1c(%rsp), %eax
subl $0x5, %eax
je 0xb872
jmp 0xb880
leaq 0x11d4c(%rip), %rax     # 0x1d5a9
movq %rax, -0x8(%rsp)
jmp 0xb88c
leaq 0x11d44(%rip), %rax     # 0x1d5af
movq %rax, -0x8(%rsp)
jmp 0xb88c
leaq 0x11d3e(%rip), %rax     # 0x1d5b7
movq %rax, -0x8(%rsp)
jmp 0xb88c
leaq 0x11d36(%rip), %rax     # 0x1d5bd
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: cpearce[P]OggIndex/src/Options.cpp
// Function: Options::Parse(int, char**)
bool Options::Parse(int argc, char** argv) {
  const char* error = 0;
  if (!DoParse(argc, argv, &error)) {
    PrintHelp();
    cout << error << endl;
    return false;
  }
  cout << "Writing output to '" << mOutputFilename.c_str() << "'" << endl;
  return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x10cb0
testb $0x1, %al
jne 0x10c4d
movq 0x8(%rsp), %rdi
callq 0x10990
movq 0x10(%rsp), %rsi
movq 0x1739e(%rip), %rdi     # 0x27fd0
callq 0x53d0
movq %rax, %rdi
movq 0x1737f(%rip), %rsi     # 0x27fc0
callq 0x5430
movb $0x0, 0x37(%rsp)
jmp 0x10ca1
movq 0x1737c(%rip), %rdi     # 0x27fd0
leaq 0xd1de(%rip), %rsi      # 0x1de39
callq 0x53d0
movq 0x8(%rsp), %rdi
movq %rax, (%rsp)
addq $0x28, %rdi
callq 0x5180
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x53d0
movq %rax, %rdi
leaq 0xd1c3(%rip), %rsi      # 0x1de4b
callq 0x53d0
movq %rax, %rdi
movq 0x17329(%rip), %rsi     # 0x27fc0
callq 0x5430
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: cpearce[P]OggIndex/src/Options.cpp
// Function: IsArgument(char const*)
static bool
IsArgument(const char* s) {
  return strcmp(s, "-v") == 0 ||
         strcmp(s, "-d") == 0 ||
         strcmp(s, "-k") == 0 ||
         strcmp(s, "-p") == 0 ||
         strcmp(s, "-o") == 0 ||
         strcmp(s, "-m") == 0 ||
         strcmp(s, "-i") == 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xcd28(%rip), %rsi      # 0x1de4d
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xcd09(%rip), %rsi      # 0x1de50
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xcd1b(%rip), %rsi      # 0x1de84
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xcd00(%rip), %rsi      # 0x1de87
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xcce8(%rip), %rsi      # 0x1de8d
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xccc7(%rip), %rsi      # 0x1de8a
callq 0x55c0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
je 0x111f0
movq 0x10(%rsp), %rdi
leaq 0xcced(%rip), %rsi      # 0x1dece
callq 0x55c0
cmpl $0x0, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: cpearce[P]OggIndex/src/Options.cpp
// Function: OutputFilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static string
OutputFilename(string input) {
  size_t dotIndex = input.rfind(".");
  if (dotIndex == string::npos) {
    // No extension? Just append ".indexed".
    return input.append(".indexed");
  }
  return input.insert(dotIndex, ".indexed");
}

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0xc8ee(%rip), %rsi      # 0x1db4d
movq $-0x1, %rdx
callq 0x5750
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0x11298
movq 0x8(%rsp), %rdi
leaq 0xcd45(%rip), %rsi      # 0x1dfc9
callq 0x5870
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5190
jmp 0x112bb
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0xcd20(%rip), %rdx      # 0x1dfc9
callq 0x50d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5190
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop