LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: migueeelvargas[P]Auto-Complete/DictionaryTrie.cpp
// Function: DictionaryTrie::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool DictionaryTrie::find(std::string word) const {
  // If TST is empty, exit.
  if (root == NULL)
    return false;

  // Traverse the tree, looking for word.
  auto retVal = traverse(word);

  // Check if return value is valid & is a word.
  return word[word.length()-1] == retVal.first->symbol
          && retVal.second == word.length()-1 
          && retVal.first->isAWord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x948f
movb $0x0, -0x1(%rbp)
jmp 0x9575
movq -0x78(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x30f0
movq -0x70(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x9590
movl %edx, -0x84(%rbp)
movq %rax, -0x80(%rbp)
jmp 0x94bf
movl -0x84(%rbp), %eax
movq -0x80(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movl %eax, -0x60(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
movq -0x78(%rbp), %rdi
callq 0x3360
movq -0x78(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x3430
movsbl (%rax), %ecx
movq -0x28(%rbp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x91(%rbp)
jne 0x9551
movq -0x78(%rbp), %rdi
movl -0x20(%rbp), %eax
movq %rax, -0xa0(%rbp)
callq 0x3360
movq -0xa0(%rbp), %rcx
movq %rax, %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x91(%rbp)
jne 0x9551
movq -0x28(%rbp), %rax
movb 0x20(%rax), %al
movb %al, -0x91(%rbp)
movb -0x91(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x9575
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3170
jmp 0x9583
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: migueeelvargas[P]Auto-Complete/DictionaryBST.cpp
// Function: DictionaryBST::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DictionaryBST::insert(std::string word){
	// Checks if word is already in the dictionary
	if(find(word))
		return false;

	dictionary.insert(word);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x30f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xaea0
movb %al, -0x59(%rbp)
jmp 0xae3e
leaq -0x38(%rbp), %rdi
callq 0x3170
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xae50
jmp 0xae6d
movb $0x0, -0x1(%rbp)
jmp 0xae85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0xae93
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0xaf40
movq %rax, -0x58(%rbp)
movb %dl, -0x50(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: migueeelvargas[P]Auto-Complete/DictionaryHashtable.cpp
// Function: DictionaryHashtable::insert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool DictionaryHashtable::insert(std::string word) {
	// Checks if word is already in the dictionary
	if(find(word))
		return false;

	dictionary.insert(word);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x30f0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xbf60
movb %al, -0x59(%rbp)
jmp 0xbefe
leaq -0x38(%rbp), %rdi
callq 0x3170
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0xbf10
jmp 0xbf2d
movb $0x0, -0x1(%rbp)
jmp 0xbf45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3170
jmp 0xbf53
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0xc000
movq %rax, -0x58(%rbp)
movb %dl, -0x50(%rbp)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x33c0
nopl (%rax)
// File: daklqw[P]beepmania/core.cpp
// Function: gamecore::configui()
void gamecore::configui() {
	ui.bindtimer(&ti);
	ui.bindscore(&sb);
	ui.setFPS(coord(1, tv.size() * tv[0].getwidth() + 1));
	ui.setStatusPos(coord(tv[0].getdown().p2.x + 1, 3));
	for (int i = 0; i != (int)tv.size(); ++i)
		ui.pushtrack(&tv[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq %rsi, %rdi
addq $0x510, %rdi            # imm = 0x510
addq $0x38, %rsi
callq 0x9900
movq -0x40(%rbp), %rsi
movq %rsi, %rdi
addq $0x510, %rdi            # imm = 0x510
callq 0x9920
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x48(%rbp)
addq $0x4c8, %rdi            # imm = 0x4C8
callq 0x3ff0
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x4c8, %rdi            # imm = 0x4C8
xorl %eax, %eax
movl %eax, %esi
callq 0x3e00
movq %rax, %rdi
callq 0xf100
movl %eax, %ecx
movq -0x50(%rbp), %rax
movslq %ecx, %rcx
imulq %rcx, %rax
addq $0x1, %rax
movl %eax, %edx
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x102c0
movq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9940
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x38(%rbp)
addq $0x4c8, %rdi            # imm = 0x4C8
xorl %eax, %eax
movl %eax, %esi
callq 0x3e00
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0xf070
movl -0x20(%rbp), %esi
addl $0x1, %esi
leaq -0x18(%rbp), %rdi
movl $0x3, %edx
callq 0x102c0
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9960
movl $0x0, -0x2c(%rbp)
movq -0x40(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
addq $0x4c8, %rdi            # imm = 0x4C8
callq 0x3ff0
movq %rax, %rcx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
je 0x34e2
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x510, %rax            # imm = 0x510
movq %rax, -0x60(%rbp)
addq $0x4c8, %rdi            # imm = 0x4C8
movslq -0x2c(%rbp), %rsi
callq 0x3e00
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0xa100
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x348a
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: daklqw[P]beepmania/core.cpp
// Function: gamecore::getclick(int)
void gamecore::getclick(int ch) {
	bool light = true;
	if (ch < 0) light = false, ch = -ch;
	if (binder.count(ch)) {
		track & tar = tv[binder[ch]];
		if (light) {
			int cur = ti.current();
			tar.checkhit(cur);
		}
		tar.setlight(light);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0xd(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x351d
movb $0x0, -0xd(%rbp)
xorl %eax, %eax
subl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rdi
addq $0x4e0, %rdi            # imm = 0x4E0
leaq -0xc(%rbp), %rsi
callq 0x4020
cmpq $0x0, %rax
je 0x359c
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x4c8, %rax            # imm = 0x4C8
movq %rax, -0x30(%rbp)
addq $0x4e0, %rdi            # imm = 0x4E0
leaq -0xc(%rbp), %rsi
callq 0x3ee0
movq -0x30(%rbp), %rdi
movslq (%rax), %rsi
callq 0x3e00
movq %rax, -0x18(%rbp)
testb $0x1, -0xd(%rbp)
je 0x358b
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0xe830
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xee70
movq -0x18(%rbp), %rdi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xee30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daklqw[P]beepmania/core.cpp
// Function: gamecore::start()
void gamecore::start() {
	configtimer();
	int lst = ti.current();
	while (true) {
		while (int t = kb.getNextKey()) getclick(t);
		for (auto & i : tv) i.checkmiss(ti.current());
		if (ti.interval(lst) * fpslimit >= 1) {
			lst = ti.current();
			ui.update(lst);
			ui.flush();
		}
		if (!sd.empty() && ti.current() > sd.front())
			sd.playnext();
		usleep(10);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2b60
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xe830
movl %eax, -0xc(%rbp)
jmp 0x35db
movq -0x38(%rbp), %rdi
addq $0x4a8, %rdi            # imm = 0x4A8
callq 0xc670
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x3602
movq -0x38(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x34f0
jmp 0x35db
movq -0x38(%rbp), %rax
addq $0x4c8, %rax            # imm = 0x4C8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4080
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x40b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x40e0
testb $0x1, %al
jne 0x363d
jmp 0x3676
leaq -0x20(%rbp), %rdi
callq 0x4120
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x38, %rdi
callq 0xe830
movq -0x40(%rbp), %rdi
movslq %eax, %rsi
callq 0xefc0
leaq -0x20(%rbp), %rdi
callq 0x4140
jmp 0x362a
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0xe880
movq -0x38(%rbp), %rax
cvtsi2sdl 0x5a8(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0xd96a(%rip), %xmm1     # 0x11008
ucomisd %xmm1, %xmm0
jb 0x36d8
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xe830
movq -0x38(%rbp), %rdi
movl %eax, -0xc(%rbp)
addq $0x510, %rdi            # imm = 0x510
movslq -0xc(%rbp), %rsi
callq 0x9a70
movq -0x38(%rbp), %rdi
addq $0x510, %rdi            # imm = 0x510
callq 0xa030
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0xd040
testb $0x1, %al
jne 0x371c
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
callq 0xe830
movq -0x38(%rbp), %rdi
movl %eax, -0x44(%rbp)
addq $0x40, %rdi
callq 0xd010
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jle 0x371c
movq -0x38(%rbp), %rdi
addq $0x40, %rdi
callq 0xd070
movl $0xa, %edi
callq 0x2240
jmp 0x35d9
nopl (%rax,%rax)
// File: daklqw[P]beepmania/cui.cpp
// Function: UI::UI()
UI::UI() {
	initscr();
	start_color();
	FPSset = false;
	init_pair(1, COLOR_BLACK, COLOR_RED);
	init_pair(2, COLOR_BLACK, COLOR_BLUE);
	init_pair(3, COLOR_WHITE, COLOR_BLACK);
	init_pair(4, COLOR_WHITE, COLOR_MAGENTA);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0xa140
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x20(%rbp)
callq 0xa160
jmp 0x97f3
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x102a0
jmp 0x9802
movq -0x30(%rbp), %rdi
addq $0x78, %rdi
callq 0x102a0
jmp 0x9811
movq -0x30(%rbp), %rdi
subq $-0x80, %rdi
callq 0x102a0
jmp 0x9820
callq 0x2280
jmp 0x9827
callq 0x2060
jmp 0x982e
movq -0x30(%rbp), %rax
movb $0x0, 0x88(%rax)
xorl %esi, %esi
movl $0x1, %edx
movl %edx, %edi
callq 0x2030
jmp 0x9849
movl $0x2, %edi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2030
jmp 0x985c
movl $0x3, %edi
movl $0x7, %esi
xorl %edx, %edx
callq 0x2030
jmp 0x986f
movl $0x4, %edi
movl $0x7, %esi
movl $0x5, %edx
callq 0x2030
jmp 0x9885
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x98ae
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xa190
movq -0x28(%rbp), %rdi
callq 0xa1b0
movq -0x10(%rbp), %rdi
callq 0x2300
// File: daklqw[P]beepmania/cui.cpp
// Function: UI::flush()
void UI::flush() {
	while (!flevent.empty() && ti->interval(flevent.front()) > 1.0)
		flevent.pop();
	flevent.push(ti->current());
	if (FPSset) showFPS();
	showscore();
	refresh();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xa4f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0xa08f
movq -0x18(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0xa510
movq -0x28(%rbp), %rdi
movl (%rax), %esi
callq 0xe880
movsd 0x6f83(%rip), %xmm1     # 0x11008
ucomisd %xmm1, %xmm0
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa098
jmp 0xa0a7
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0xa530
jmp 0xa044
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdi
callq 0xe830
movq -0x30(%rbp), %rdi
movl %eax, -0xc(%rbp)
leaq -0xc(%rbp), %rsi
callq 0xa550
movq -0x18(%rbp), %rax
testb $0x1, 0x88(%rax)
je 0xa0e5
movq -0x18(%rbp), %rdi
callq 0x9d50
movq -0x18(%rbp), %rdi
callq 0x9db0
callq 0x22d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: daklqw[P]beepmania/keybdevent.cpp
// Function: keybd::getNextKey()
int keybd::getNextKey(){
	const size_t siz = sizeof ie;
	while (true) {
		int res = read(dev, &ie, siz);
		if (res == -1) return 0;
		if (ie.type == 1) {
			if (ie.value <= 1) {
				return ie.value ? (int) ie.code : -((int) ie.code);
			}
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x18, -0x18(%rbp)
movq -0x28(%rbp), %rsi
movl 0x18(%rsi), %edi
movl $0x18, %edx
callq 0x2250
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0xc6af
movl $0x0, -0x4(%rbp)
jmp 0xc6f8
movq -0x28(%rbp), %rax
movzwl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc6f6
movq -0x28(%rbp), %rax
cmpl $0x1, 0x14(%rax)
jg 0xc6f4
movq -0x28(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0xc6dd
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0xc6ec
movq -0x28(%rbp), %rax
movzwl 0x12(%rax), %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc6f8
jmp 0xc6f6
jmp 0xc68c
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daklqw[P]beepmania/score.cpp
// Function: score::reset()
void score::reset() {
	perfect = great = good = bad = 0;
	maxcombo = click = combo = totscore = 0;
	deltas = 0;
	lststatus = 0;
	lstdelta = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
movq $0x0, 0x18(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x24(%rax)
popq %rbp
retq
nopl (%rax)
// File: daklqw[P]beepmania/score.cpp
// Function: score::push(int)
void score::push(int x) {
	switch (x) {
		case TAG_PERFECT:
			++perfect, ++combo, totscore += combo * 12 + 300;
			break;
		case TAG_GREAT:
			++great, ++combo, totscore += combo * 4 + 100;
			break;
		case TAG_GOOD:
			++good, totscore += combo * 2 + 50;
			break;
		case TAG_BAD:
			++bad, combo = 0;
			break;
		default: break;
	}
	++click, lststatus = x;
	maxcombo = std::max(maxcombo, combo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0xce1e
movq -0x18(%rbp), %rax
leaq 0x4502(%rip), %rcx      # 0x11288
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
imull $0xc, 0x10(%rax), %ecx
addl $0x12c, %ecx            # imm = 0x12C
movslq %ecx, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0xce20
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rax), %ecx
shll $0x2, %ecx
addl $0x64, %ecx
movslq %ecx, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0xce20
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl 0x10(%rax), %ecx
shll %ecx
addl $0x32, %ecx
movslq %ecx, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0xce20
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x10(%rax)
jmp 0xce20
jmp 0xce20
movq -0x20(%rbp), %rsi
movl 0x2c(%rsi), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsi)
movl -0xc(%rbp), %eax
movl %eax, 0x28(%rsi)
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x10, %rsi
callq 0xcf00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daklqw[P]beepmania/sound.cpp
// Function: sound::beep(double, double)
void sound::beep(double hi, double ti) {
	if (enablesound) {
		// DEBUG MODE
		int tt = std::max((int) ceil(ti * 960), 1);
		ioctl(dev, KDMKTONE, (tt << 16)+(int) (1193180 / hi));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, (%rax)
je 0xd154
movsd 0x41a5(%rip), %xmm0     # 0x112a0
mulsd -0x18(%rbp), %xmm0
callq 0x2050
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0xcf00
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x58(%rax), %edi
movl -0x1c(%rbp), %edx
shll $0x10, %edx
movsd 0x415b(%rip), %xmm0     # 0x11298
divsd -0x10(%rbp), %xmm0
cvttsd2si %xmm0, %eax
addl %eax, %edx
movl $0x4b30, %esi           # imm = 0x4B30
movb $0x0, %al
callq 0x2230
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: daklqw[P]beepmania/track.cpp
// Function: track::getpos(note*, long)
rect track::getpos(note * nt, clock_t now) {
	double mid = (nt->tick - now) / 1000000.;
	rect ar;
	ar.p2.x = area.p1.x + (int) (area.p2.x - area.p1.x + 1) * (1 - mid / spn) - 1;
	ar.p1.x = ar.p2.x - nt->size + 1;
	ar.p1.y = area.p1.y;
	ar.p2.y = area.p2.y;
	return rect::areaand(area, ar);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movslq (%rax), %rax
subq -0x20(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0x24a5(%rip), %xmm1     # 0x11018
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x103d0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
cvtsi2sdl 0x2c(%rsi), %xmm1
movl 0x34(%rsi), %eax
subl 0x2c(%rsi), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
movsd -0x28(%rbp), %xmm3
divsd 0x8(%rsi), %xmm3
movsd 0x2457(%rip), %xmm2     # 0x11008
subsd %xmm3, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x2443(%rip), %xmm1     # 0x11008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq -0x18(%rbp), %rcx
subl 0x4(%rcx), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl 0x30(%rsi), %eax
movl %eax, -0x34(%rbp)
movl 0x38(%rsi), %eax
movl %eax, -0x2c(%rbp)
addq $0x2c, %rsi
leaq -0x38(%rbp), %rdx
callq 0x104a0
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: daklqw[P]beepmania/track.cpp
// Function: track::gettrack(long)
std::vector<rect> track::gettrack(clock_t now) {
	int _c = cur;
	std::vector<rect> res;
	while (_c < (int)notes.size()) {
		if (notes[_c].tick - now > spn * CLOCKS_PER_SEC) break;
		rect tmp = getpos(&notes[_c++], now);
		if (tmp.none()) continue;
		res.push_back(tmp);
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x58(%rax), %eax
movl %eax, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
callq 0xf1e0
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x40, %rdi
callq 0x8950
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0xed15
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xf200
movq %rax, %rcx
movq -0x48(%rbp), %rax
movslq (%rcx), %rcx
subq -0x18(%rbp), %rcx
cvtsi2sd %rcx, %xmm0
movsd 0x2385(%rip), %xmm1     # 0x11018
mulsd 0x8(%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xeca0
jmp 0xed15
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movslq -0x1c(%rbp), %rsi
movl %esi, %eax
incl %eax
movl %eax, -0x1c(%rbp)
callq 0xf200
movq -0x48(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0xeb30
jmp 0xecce
leaq -0x30(%rbp), %rdi
callq 0x10510
movb %al, -0x5d(%rbp)
jmp 0xecdc
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0xece5
jmp 0xed01
jmp 0xec46
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xa3b0
jmp 0xed32
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf220
jmp 0xed10
jmp 0xec46
movb $0x1, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0xed28
movq -0x58(%rbp), %rdi
callq 0xa3b0
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: daklqw[P]beepmania/track.cpp
// Function: track::checkhit(long)
bool track::checkhit(clock_t now) {
	if (cur == (int)notes.size()) return false;
	int delta = notes[cur].tick - (now - checkdelta);
	int res = match(delta);
	if (res == -1) return false;
	++cur;
	sb->push(res);
	if (res != TAG_BAD) sb->pushdelta(delta);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl 0x58(%rdi), %eax
movl %eax, -0x24(%rbp)
addq $0x40, %rdi
callq 0x8950
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jne 0xeea7
movb $0x0, -0x1(%rbp)
jmp 0xef1d
movq -0x30(%rbp), %rax
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x58(%rax), %rsi
callq 0xf200
movq -0x30(%rbp), %rdi
movslq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x20(%rdi), %rdx
subq %rdx, %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0xef30
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0xeeea
movb $0x0, -0x1(%rbp)
jmp 0xef1d
movq -0x30(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq 0x60(%rax), %rdi
movl -0x20(%rbp), %esi
callq 0xcd50
cmpl $0x4, -0x20(%rbp)
je 0xef19
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0xce60
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: daklqw[P]beepmania/track.cpp
// Function: track::match(int)
int track::match(int dta) {
	if (std::abs(dta) <= perfect) return TAG_PERFECT;
	if (std::abs(dta) <= great) return TAG_GREAT;
	if (std::abs(dta) <= good) return TAG_GOOD;
	if (std::abs(dta) <= bad) return TAG_BAD;
	return TAG_MISS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
cmpl 0x10(%rcx), %eax
jg 0xef5b
movl $0x1, -0x4(%rbp)
jmp 0xefb6
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
cmpl 0x14(%rcx), %eax
jg 0xef77
movl $0x2, -0x4(%rbp)
jmp 0xefb6
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
cmpl 0x18(%rcx), %eax
jg 0xef93
movl $0x3, -0x4(%rbp)
jmp 0xefb6
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movl %eax, %edx
negl %edx
cmovnsl %edx, %eax
cmpl 0x1c(%rcx), %eax
jg 0xefaf
movl $0x4, -0x4(%rbp)
jmp 0xefb6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: daklqw[P]beepmania/track.cpp
// Function: track::checkmiss(long)
bool track::checkmiss(clock_t now) {
	if (cur == (int)notes.size()) return false;
	int res = (now - checkdelta) - notes[cur].tick;
	if (res > bad) {
		++cur;
		sb->push(TAG_BAD);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl 0x58(%rdi), %eax
movl %eax, -0x20(%rbp)
addq $0x40, %rdi
callq 0x8950
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jne 0xeff7
movb $0x0, -0x1(%rbp)
jmp 0xf05b
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq 0x20(%rax), %rdx
subq %rdx, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rdi
addq $0x40, %rdi
movslq 0x58(%rax), %rsi
callq 0xf200
movq -0x28(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq (%rdx), %rdx
subq %rdx, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x1c(%rcx), %eax
jle 0xf057
movq -0x28(%rbp), %rax
movl 0x58(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x58(%rax)
movq 0x60(%rax), %rdi
movl $0x4, %esi
callq 0xcd50
movb $0x1, -0x1(%rbp)
jmp 0xf05b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomus.c
// Function: die
static void die (const char * fmt, ...) {
  va_list ap;
  fputs ("*** picomus: ", stdout);
  va_start (ap, fmt);
  vfprintf (stdout, fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
  exit (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2285
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x1fd1d(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
leaq 0x195a7(%rip), %rdi     # 0x1b864
callq 0x10d0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1fce3(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x11a0
leaq -0x20(%rbp), %rax
movq 0x1fcc8(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
movq 0x1fcb4(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
callq 0x1150
movl $0x1, %edi
callq 0x11c0
nop
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomus.c
// Function: warn
static void warn (const char * fmt, ...) {
  va_list ap;
  if (verbose < 0) return;
  fputs ("c [picomus] WARNING: ", stdout);
  va_start (ap, fmt);
  vfprintf (stdout, fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2365
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x1fd8d(%rip)     # 0x22120
jge 0x2397
jmp 0x240f
movq 0x1fc32(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
leaq 0x194ca(%rip), %rdi     # 0x1b872
callq 0x10d0
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x1fbf8(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x11a0
leaq -0x20(%rbp), %rax
movq 0x1fbdd(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
movq 0x1fbc9(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
callq 0x1150
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomus.c
// Function: msg
static void msg (int level, const char * fmt, ...) {
  va_list ap;
  if (verbose < level) return;
  fputs ("c [picomus] ", stdout);
  va_start (ap, fmt);
  vfprintf (stdout, fmt, ap);
  va_end (ap);
  fputc ('\n', stdout);
  fflush (stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x27f8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1f8ff(%rip), %eax     # 0x22120
cmpl -0x4(%rbp), %eax
jge 0x2828
jmp 0x28a0
movq 0x1f7a1(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
leaq 0x19102(%rip), %rdi     # 0x1b93b
callq 0x10d0
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0x1f767(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x11a0
leaq -0x30(%rbp), %rax
movq 0x1f74c(%rip), %rax     # 0x21fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1100
movq 0x1f738(%rip), %rax     # 0x21fd0
movq (%rax), %rdi
callq 0x1150
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: biotomas[P]ipasir/sat/picosat961/picosat-961/picomus.c
// Function: callback
static void callback (void * dummy, const int * mus) {
  int remaining;
  const int * p;
  (void) dummy;
  if (verbose <= 0) return;
  remaining = 0;
  for (p = mus; *p; p++) remaining++;
  assert (remaining <= nclauses);
  reductions++;
  msg (1, "reduction %d to %d = %.0f%% out of %d after %.1f sec",
       reductions,
       remaining, percent (remaining, nclauses), nclauses,
       picosat_time_stamp () - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x1f809(%rip)     # 0x22120
jg 0x291e
jmp 0x29e9
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x294d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x292d
movl -0x14(%rbp), %eax
cmpl 0x1f7fa(%rip), %eax     # 0x22150
jg 0x295a
jmp 0x2979
leaq 0x18fe7(%rip), %rdi     # 0x1b948
leaq 0x187f3(%rip), %rsi     # 0x1b15b
movl $0x9d, %edx
leaq 0x18fea(%rip), %rcx     # 0x1b95e
callq 0x10c0
movl 0x1f801(%rip), %eax     # 0x22180
addl $0x1, %eax
movl %eax, 0x1f7f8(%rip)     # 0x22180
movl 0x1f7f2(%rip), %eax     # 0x22180
movl %eax, -0x34(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
cvtsi2sdl -0x14(%rbp), %xmm0
cvtsi2sdl 0x1f7ac(%rip), %xmm1 # 0x22150
callq 0x28b0
movsd %xmm0, -0x28(%rbp)
movl 0x1f79c(%rip), %eax     # 0x22150
movl %eax, -0x2c(%rbp)
callq 0xa1a0
movl -0x34(%rbp), %edx
movl -0x30(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
subsd 0x1f742(%rip), %xmm1    # 0x22118
movl $0x1, %edi
leaq 0x18f9f(%rip), %rsi     # 0x1b981
movb $0x2, %al
callq 0x27c0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x3, %rax
ja 0x24f4
movq -0x48(%rbp), %rax
leaq 0x1b80(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b80(%rip), %rsi      # 0x4014
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x249f
jmp 0x24f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x251e
leaq 0x1b5f(%rip), %rsi      # 0x401e
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24ca
jmp 0x24f4
leaq 0x1b53(%rip), %rsi      # 0x4026
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24de
jmp 0x24f4
leaq 0x1b44(%rip), %rsi      # 0x402b
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24f2
jmp 0x24f4
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2160
jmp 0x2503
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw (%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: Interpreter::expression()
long Interpreter::expression() {

    // set current token to the first token taken from the input
    _current_token = get_next_token();

    long result = term();
    while (_current_token.type == TOKENTYPE::PLUS ||
    _current_token.type == TOKENTYPE::MINUS) {
        Token token = _current_token;
        if (token.type == TOKENTYPE::PLUS) {
            eat(TOKENTYPE::PLUS);
            result = result + term();
        } else if (token.type == TOKENTYPE::MINUS) {
            eat(TOKENTYPE::MINUS);
            result = result - term();
        }
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2700
movq -0x38(%rbp), %rdi
movl %eax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x20(%rdi)
callq 0x29b0
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rcx
movb $0x1, %al
cmpl $0x2, 0x18(%rcx)
movb %al, -0x39(%rbp)
je 0x265a
movq -0x38(%rbp), %rax
cmpl $0x3, 0x18(%rax)
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x2666
jmp 0x26e9
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x2, -0x30(%rbp)
jne 0x26af
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x29f0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x29b0
movq %rax, %rcx
movq -0x48(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x26e4
cmpl $0x3, -0x30(%rbp)
jne 0x26e2
movq -0x38(%rbp), %rdi
movl $0x3, %esi
callq 0x29f0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x29b0
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x26e4
jmp 0x263d
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: Interpreter::eat(TOKENTYPE)
void Interpreter::eat(TOKENTYPE token_type) {
    if (_current_token.type == token_type) {
        _current_token = get_next_token();
    } else {
        ostringstream out;
        out << "Error parsing input. Wanted: " << token_type;
        throw(out.str().c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x2a46
movq -0x1d8(%rbp), %rdi
callq 0x2700
movl %eax, %ecx
movq -0x1d8(%rbp), %rax
movl %ecx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x2b53
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0x2220
movq -0x1e8(%rbp), %rdi
leaq 0x15d5(%rip), %rsi      # 0x403c
callq 0x2180
movq %rax, -0x1e0(%rbp)
jmp 0x2a75
movq -0x1e0(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x2450
jmp 0x2a87
movb $0x1, -0x1c9(%rbp)
movl $0x8, %edi
callq 0x20c0
movq %rax, -0x1f0(%rbp)
leaq -0x1c8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x2190
jmp 0x2ab4
leaq -0x1c8(%rbp), %rdi
callq 0x20a0
movq -0x1f0(%rbp), %rdi
movq %rax, (%rdi)
movb $0x0, -0x1c9(%rbp)
movq 0x34d8(%rip), %rsi      # 0x5fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x22a0
jmp 0x2b68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2b45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x2b2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0x20e0
testb $0x1, -0x1c9(%rbp)
jne 0x2b37
jmp 0x2b43
movq -0x1f0(%rbp), %rdi
callq 0x2120
jmp 0x2b45
leaq -0x198(%rbp), %rdi
callq 0x2070
jmp 0x2b5c
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1a0(%rbp), %rdi
callq 0x22b0
nopl (%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: Interpreter::advance()
void Interpreter::advance() {
    _pos++;
    if (_pos > _text.length() - 1) {
        _current_char = '\0';   // Indicates end of input
    } else {
        _current_char = _text[_pos];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
callq 0x2270
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x2bba
movq -0x18(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x2bd6
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x2300
movq %rax, %rcx
movq -0x18(%rbp), %rax
movb (%rcx), %cl
movb %cl, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: Interpreter::integer()
long Interpreter::integer() {
    string result("");

    while (_current_char != '\0' && isdigit(_current_char)) {
        result += _current_char;
        advance();
    }

    return stol(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22c0
movq -0x48(%rbp), %rdx
leaq 0x13ed(%rip), %rsi      # 0x4059
leaq -0x28(%rbp), %rdi
callq 0x2ee0
jmp 0x2c77
leaq -0x29(%rbp), %rdi
callq 0x21c0
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x51(%rbp)
je 0x2ca8
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %edi
callq 0x2170
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x2cb1
jmp 0x2cff
movq -0x50(%rbp), %rax
movsbl 0x10(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x20f0
jmp 0x2cc4
movq -0x50(%rbp), %rdi
callq 0x2b70
jmp 0x2ccf
jmp 0x2c80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x21c0
jmp 0x2d2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20e0
jmp 0x2d2a
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x2f90
movq %rax, -0x60(%rbp)
jmp 0x2d17
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc3.cc
// Function: main
int main() {
    string text;
    while(cin) {
        cout << "calc> ";
        getline(cin, text);

        try {
            Interpreter interpreter(text);
            long result = interpreter.expression();
            cout << result << endl;
        }
        catch(const char* error) {
            cerr << error << endl;
            break;
        }
    }

    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2240
movq 0x3276(%rip), %rdi      # 0x5fd8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2210
movb %al, -0x71(%rbp)
jmp 0x2d76
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x2d82
jmp 0x2e82
movq 0x3237(%rip), %rdi      # 0x5fc0
leaq 0x12e5(%rip), %rsi      # 0x4075
callq 0x2180
jmp 0x2d97
movq 0x323a(%rip), %rdi      # 0x5fd8
leaq -0x28(%rbp), %rsi
callq 0x2060
jmp 0x2da9
leaq -0x60(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x25a0
jmp 0x2db8
leaq -0x60(%rbp), %rdi
callq 0x2600
movq %rax, -0x80(%rbp)
jmp 0x2dc7
movq -0x80(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
movq 0x31e6(%rip), %rdi      # 0x5fc0
callq 0x22e0
movq %rax, -0x88(%rbp)
jmp 0x2de8
movq -0x88(%rbp), %rdi
movq 0x31b2(%rip), %rsi      # 0x5fa8
callq 0x21a0
jmp 0x2dfd
jmp 0x2e7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x2e9e
movq -0x30(%rbp), %rdi
callq 0x2090
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
movq 0x31b0(%rip), %rdi      # 0x5ff0
callq 0x2180
movq %rax, -0x90(%rbp)
jmp 0x2e4e
movq -0x90(%rbp), %rdi
movq 0x314c(%rip), %rsi      # 0x5fa8
callq 0x21a0
jmp 0x2e63
callq 0x2290
jmp 0x2e82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x2290
jmp 0x2e9e
jmp 0x2d5b
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20e0
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x22b0
// File: iZhangHui[P]CppPrimer/CH01_GettingStarted/examples/whilecount.cc
// Function: main
int main()
{
    int sum = 0, val = 1;
    // keep executing the while as long as val is less than or equal to 10
    while (val <= 10) {
        sum += val;  // assigns sum + val to sum
        ++val;       // add 1 to val
    }
    std::cout << "Sum of 1 to 10 inclusive is " 
              << sum << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jg 0x11f7
movl -0xc(%rbp), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11dd
movq 0x2dda(%rip), %rdi      # 0x3fd8
leaq 0xdff(%rip), %rsi       # 0x2004
callq 0x1040
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1070
movq %rax, %rdi
movq 0x2da9(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: riyadparvez[P]louvain-method/graph.cpp
// Function: Graph::display(int)
void
Graph::display(int type) {
  for (unsigned int i=0 ; i<links.size() ; i++) {
    for (unsigned int j=0 ; j<links[i].size() ; j++) {
      int dest   = links[i][j].first;
      float weight = links[i][j].second;
      if (type==WEIGHTED)
	cout << i << " " << dest << " " << weight << endl;
      else
	cout << i << " " << dest << endl;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movq %rax, -0x30(%rbp)
callq 0x36b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x328b
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x37b0
movq %rax, %rdi
callq 0x3c10
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x327b
movq -0x28(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x37b0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3c50
movq -0x28(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, %esi
callq 0x37b0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3c50
movss 0x4(%rax), %xmm0
movss %xmm0, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x3233
movl -0x10(%rbp), %esi
movq 0x10de9(%rip), %rdi     # 0x13fd0
callq 0x21d0
movq %rax, %rdi
leaq 0x9ec4(%rip), %rsi      # 0xd0ba
callq 0x2130
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x9eaa(%rip), %rsi      # 0xd0ba
callq 0x2130
movq %rax, %rdi
movss -0x1c(%rbp), %xmm0
callq 0x20f0
movq %rax, %rdi
movq 0x10d94(%rip), %rsi     # 0x13fc0
callq 0x2170
jmp 0x326b
movl -0x10(%rbp), %esi
movq 0x10d93(%rip), %rdi     # 0x13fd0
callq 0x21d0
movq %rax, %rdi
leaq 0x9e6e(%rip), %rsi      # 0xd0ba
callq 0x2130
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2250
movq %rax, %rdi
movq 0x10d5a(%rip), %rsi     # 0x13fc0
callq 0x2170
jmp 0x326d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3165
jmp 0x327d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x313e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: riyadparvez[P]louvain-method/main_convert.cpp
// Function: usage(char*, char const*)
void
usage(char *prog_name, const char *more) {
  cerr << more;
  cerr << "usage: " << prog_name << " -i input_file -o outfile [-r] [-w outfile_weight]" << endl << endl;
  cerr << "read the graph and convert it to binary format." << endl;
  cerr << "-r\tnodes are renumbered from 0 to nb_nodes-1 (the order is kept)." << endl;
  cerr << "-w filename\tread the graph as a weighted one and writes the weights in a separate file." << endl;
  cerr << "-h\tshow this usage message." << endl;
  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x8235(%rip), %rdi      # 0x13ff0
callq 0x2130
movq 0x8229(%rip), %rdi      # 0x13ff0
leaq 0x12e6(%rip), %rsi      # 0xd0b4
callq 0x2130
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x12d3(%rip), %rsi      # 0xd0bc
callq 0x2130
movq %rax, %rdi
movq 0x81c8(%rip), %rsi      # 0x13fc0
callq 0x2170
movq %rax, %rdi
movq 0x81b9(%rip), %rsi      # 0x13fc0
callq 0x2170
movq 0x81dd(%rip), %rdi      # 0x13ff0
leaq 0x12d5(%rip), %rsi      # 0xd0ef
callq 0x2130
movq %rax, %rdi
movq 0x8197(%rip), %rsi      # 0x13fc0
callq 0x2170
movq 0x81bb(%rip), %rdi      # 0x13ff0
leaq 0x12e3(%rip), %rsi      # 0xd11f
callq 0x2130
movq %rax, %rdi
movq 0x8175(%rip), %rsi      # 0x13fc0
callq 0x2170
movq 0x8199(%rip), %rdi      # 0x13ff0
leaq 0x1303(%rip), %rsi      # 0xd161
callq 0x2130
movq %rax, %rdi
movq 0x8153(%rip), %rsi      # 0x13fc0
callq 0x2170
movq 0x8177(%rip), %rdi      # 0x13ff0
leaq 0x1339(%rip), %rsi      # 0xd1b9
callq 0x2130
movq %rax, %rdi
movq 0x8131(%rip), %rsi      # 0x13fc0
callq 0x2170
xorl %edi, %edi
callq 0x21a0
nopl (%rax,%rax)