LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Ahhgust[P]STRaitRazor/trie.cpp
// Function: Trie::~Trie()
Trie::~Trie() {
  unsigned i;
  TrieNode *n = root;
  for (i=0; i < numNodes; ++i, ++n) {
    if ((*n).id != NULL) {
      delete((*n).id);
      delete((*n).type);
    }
  }

  delete [] root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jae 0x11d59
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x11d3d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x11d12
movq -0x28(%rbp), %rdi
callq 0x8c60
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x32c0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x11d3b
movq -0x30(%rbp), %rdi
callq 0x9010
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x32c0
jmp 0x11d3d
jmp 0x11d3f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
jmp 0x11cd2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x11d73
movq -0x38(%rbp), %rdi
callq 0x3350
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tomsmeding[P]MarioLANG/mariolang.cpp
// Function: getch()
char getch(){char b=0;struct termios o={};fflush(stdout);if(tcgetattr(0,&o)<0)
perror("tcsetattr()");o.c_lflag&=~ICANON;o.c_lflag&=~ECHO;o.c_cc[VMIN]=1;o.c_cc[
VTIME]=0;if(tcsetattr(0,TCSANOW,&o)<0)perror("tcsetattr ICANON");if(read(0,&b,1)
<0)perror("read()");o.c_lflag|=ICANON;o.c_lflag|=ECHO;if(tcsetattr(0,TCSADRAIN,&
o)<0)perror("tcsetattr ~ICANON");return b;}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb $0x0, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x3c, %edx
callq 0x20f0
movq 0x8b55(%rip), %rax      # 0xafb8
movq (%rax), %rdi
callq 0x21c0
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jge 0x2487
leaq 0x4d06(%rip), %rdi      # 0x7188
callq 0x2150
movl -0x34(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
andl $-0x9, %eax
movl %eax, -0x34(%rbp)
movb $0x1, -0x29(%rbp)
movb $0x0, -0x2a(%rbp)
xorl %esi, %esi
leaq -0x40(%rbp), %rdx
movl %esi, %edi
callq 0x21f0
cmpl $0x0, %eax
jge 0x24bf
leaq 0x4cda(%rip), %rdi      # 0x7194
callq 0x2150
xorl %edi, %edi
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x2260
cmpq $0x0, %rax
jge 0x24e1
leaq 0x4cc9(%rip), %rdi      # 0x71a5
callq 0x2150
movl -0x34(%rbp), %eax
orl $0x2, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x34(%rbp)
xorl %edi, %edi
movl $0x1, %esi
leaq -0x40(%rbp), %rdx
callq 0x21f0
cmpl $0x0, %eax
jge 0x2514
leaq 0x4c9d(%rip), %rdi      # 0x71ac
callq 0x2150
movb -0x1(%rbp), %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: tomsmeding[P]MarioLANG/mariolang.cpp
// Function: signalhandler(int)
void signalhandler(int sig){
	switch(sig){
	case SIGINT:
		if(animate)moveto(L->getoutputx(),L->getoutputy());
		exit(2);
	case SIGUSR1:
		animatedelay+=100000; //100ms extra
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x2, %eax
je 0x25b2
jmp 0x25a8
movl -0x8(%rbp), %eax
subl $0xa, %eax
je 0x25ea
jmp 0x25fb
testb $0x1, 0x8bfb(%rip)      # 0xb1b4
je 0x25e0
movq 0x8bf6(%rip), %rdi      # 0xb1b8
callq 0x2a80
movl %eax, -0xc(%rbp)
movq 0x8be7(%rip), %rdi      # 0xb1b8
callq 0x2aa0
movl -0xc(%rbp), %edi
movl %eax, %esi
callq 0x2520
movl $0x2, %edi
callq 0x21e0
movl 0x8bc0(%rip), %eax      # 0xb1b0
addl $0x186a0, %eax          # imm = 0x186A0
movl %eax, 0x8bb5(%rip)      # 0xb1b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: tomsmeding[P]MarioLANG/mariolang.cpp
// Function: Level::Level(std::basic_ifstream<char, std::char_traits<char>>&)
Level(ifstream &cf){
		code.resize(10); //some nice starting amount
		int i,maxlen=0;
		for(i=0;cf.good();i++){
			if(i+1>(int)code.size())code.resize(code.size()*2);
			getline(cf,code[i]);
			if((int)code[i].size()>maxlen)maxlen=code[i].size();
		}
		if(&cf!=&cin)cf.close();
		code.resize(i);
		for(i=0;i<(int)code.size();i++)code[i].resize(maxlen,' ');
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2ea0
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2ed0
movq -0x30(%rbp), %rdi
movl $0xa, %esi
callq 0x3520
jmp 0x2b85
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x22d0
movb %al, -0x41(%rbp)
jmp 0x2bab
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x2bb7
jmp 0x2c8f
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
addq $0x30, %rdi
callq 0x35b0
movq %rax, %rcx
movl -0x48(%rbp), %eax
cmpl %ecx, %eax
jle 0x2c1e
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x50(%rbp)
callq 0x35b0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x3520
jmp 0x2bf9
jmp 0x2c1e
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2ef0
movq -0x38(%rbp), %rdi
callq 0x2f50
jmp 0x2d17
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
movslq -0x20(%rbp), %rsi
callq 0x35d0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x2040
jmp 0x2c45
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x20(%rbp), %rsi
callq 0x35d0
movq %rax, %rdi
callq 0x2130
cmpl -0x24(%rbp), %eax
jle 0x2c7f
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x20(%rbp), %rsi
callq 0x35d0
movq %rax, %rdi
callq 0x2130
movl %eax, -0x24(%rbp)
jmp 0x2c81
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b93
movq 0x834a(%rip), %rax      # 0xafe0
cmpq %rax, -0x10(%rbp)
je 0x2ca9
movq -0x10(%rbp), %rdi
callq 0x2050
jmp 0x2ca7
jmp 0x2ca9
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3520
jmp 0x2cbc
movl $0x0, -0x20(%rbp)
movq -0x40(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x5c(%rbp)
addq $0x30, %rdi
callq 0x35b0
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl %ecx, %eax
jge 0x2d11
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
movslq -0x20(%rbp), %rsi
callq 0x35d0
movq %rax, %rdi
movslq -0x24(%rbp), %rsi
movl $0x20, %edx
callq 0x2080
jmp 0x2d04
jmp 0x2d06
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2cc3
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22e0
// File: tomsmeding[P]MarioLANG/mariolang.cpp
// Function: Level::play()
void play(void){
		mario *m=new mario;
		memory.resizepos(300);
		memory.resizeneg(300);
		m->ipx=0; m->ipy=0;
		m->dir=DIRRIGHT;
		m->walking=true;
		m->skip=false;
		m->memp=0;
		if(animate){
			printf("\x1B[1J");
			moveto(0,0);
			print();
			inputy=code.size(); //input comes first line under the code in animation mode
			outputx=0;
			outputy=inputy+2; //output comes under the input line, under "Output:"
			tapex=code[0].size()+1; //tape comes to the right of the code
			moveto(0,outputy-1);
			printf("\x1B[34;1mOutput:\x1B[0m"); fflush(stdout);
			moveto(outputx,outputy);
		}
		while(execcommandStep(m));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x14, %edi
callq 0x2170
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
movl $0x12c, %esi            # imm = 0x12C
xorl %edx, %edx
callq 0x3f40
movq -0x18(%rbp), %rdi
movl $0x12c, %esi            # imm = 0x12C
xorl %edx, %edx
callq 0x3f70
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
testb $0x1, 0x8410(%rip)      # 0xb1b4
je 0x2e4a
leaq 0x46ce(%rip), %rdi      # 0x747f
movb $0x0, %al
callq 0x2030
xorl %esi, %esi
movl %esi, %edi
callq 0x2520
movq -0x18(%rbp), %rdi
callq 0x3fa0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x35b0
movq -0x18(%rbp), %rdi
movl %eax, 0x50(%rdi)
movl $0x0, 0x48(%rdi)
movl 0x50(%rdi), %eax
addl $0x2, %eax
movl %eax, 0x4c(%rdi)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x35d0
movq %rax, %rdi
callq 0x2130
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq $0x1, %rcx
movl %ecx, 0x54(%rax)
movl 0x4c(%rax), %esi
subl $0x1, %esi
xorl %edi, %edi
callq 0x2520
leaq 0x465f(%rip), %rdi      # 0x7484
movb $0x0, %al
callq 0x2030
movq 0x8185(%rip), %rax      # 0xafb8
movq (%rax), %rdi
callq 0x21c0
movq -0x18(%rbp), %rax
movl 0x48(%rax), %edi
movl 0x4c(%rax), %esi
callq 0x2520
jmp 0x2e4c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4040
testb $0x1, %al
jne 0x2e5f
jmp 0x2e61
jmp 0x2e4c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: tomsmeding[P]MarioLANG/mariolang.cpp
// Function: Level::animationFrameEnd(mario*, int, int, char)
void animationFrameEnd(mario *m,int x,int y,char c){
		usleep(animatedelay);
		moveto(x,y);
		printf("%c",c); fflush(stdout);
		moveto(outputx,outputy);
		if(animateShowTape)drawTape(m);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x4846(%rip), %edi      # 0xb1b0
callq 0x2240
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x2520
movsbl -0x19(%rbp), %esi
leaq 0xd02(%rip), %rdi       # 0x7687
movb $0x0, %al
callq 0x2030
movq 0x4625(%rip), %rax      # 0xafb8
movq (%rax), %rdi
callq 0x21c0
movq -0x28(%rbp), %rax
movl 0x48(%rax), %edi
movl 0x4c(%rax), %esi
callq 0x2520
testb $0x1, 0x4804(%rip)      # 0xb1b5
je 0x69c0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x69d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: SkipList::SkipList(int, int)
SkipList::SkipList(int prob, int maxl) {
  probability = prob;
  max_level = maxl;
  if (max_level == 0) max_level = 1;
  if (max_level > MAX_LEVEL) max_level = MAX_LEVEL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0xc(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl -0x10(%rsp), %ecx
movl %ecx, 0x14(%rax)
cmpl $0x0, 0x14(%rax)
jne 0x1277
movq -0x18(%rsp), %rax
movl $0x1, 0x14(%rax)
movq -0x18(%rsp), %rax
cmpl $0xd, 0x14(%rax)
jle 0x128e
movq -0x18(%rsp), %rax
movl $0xd, 0x14(%rax)
retq
nop
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: SkipList::lookup(int)
int SkipList::lookup(int key) {
  if (fastFindNode(key) >= 0) {
	return 1;
  } else {
	return 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x1350
cmpl $0x0, %eax
jl 0x133a
movl $0x1, 0x14(%rsp)
jmp 0x1342
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: SkipList::fastFindNode(int)
int SkipList::fastFindNode(int key) {
  node* pred = head;
  int lFound = -1;
  for (int level = pred->topLevel-1; level >= 0; level--) {
	node* curr;
	curr = pred->nexts[level][FANOUT-1].nxt;
	inc();
	while (key > pred->nexts[level][FANOUT-1].prefix) {
	  pred = curr;
	  curr = pred->nexts[level][FANOUT-1].nxt;
	  inc();
	}
	if (lFound == -1 && key == pred->nexts[level][FANOUT-1].prefix) {
	  return level;
	}

	// pred.key is less than key, curr.key is greater than key.
	int k = 0;
	while (key > pred->nexts[level][k].prefix) {
	  k++;
	}
	//assert(k < FANOUT);
	if (k != 0) {
	  if (lFound == -1 && key == pred->nexts[level][k-1].prefix) {
		return level;
	  }
	  pred = pred->nexts[level][k-1].nxt;
	  inc();
	}
  }
  return lFound;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0x20(%rsp)
cmpl $0x0, 0x20(%rsp)
jl 0x150c
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x2b10
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x30(%rcx), %eax
jle 0x140b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x38(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x2b10
jmp 0x13b9
cmpl $-0x1, 0x24(%rsp)
jne 0x143d
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
cmpl 0x30(%rcx), %eax
jne 0x143d
movl 0x20(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x1514
movl $0x0, 0x14(%rsp)
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jle 0x147b
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x1445
cmpl $0x0, 0x14(%rsp)
je 0x14fa
cmpl $-0x1, 0x24(%rsp)
jne 0x14c1
movl 0x34(%rsp), %eax
movq 0x28(%rsp), %rcx
addq $0x8, %rcx
movslq 0x20(%rsp), %rdx
shlq $0x6, %rdx
addq %rdx, %rcx
movl 0x14(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl (%rcx), %eax
jne 0x14c1
movl 0x20(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x1514
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
addq $0x8, %rax
movslq 0x20(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x2b10
jmp 0x14fc
movl 0x20(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1386
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: insert_test(SkipList*)
int insert_test(SkipList* sk) {
  assert (sk->lookup(99) <= 0);
  assert (sk->insert(99) > 0);
  assert (sk->lookup(99) > 0);
  assert (sk->insert(99) <= 0);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x63, %esi
callq 0x1310
cmpl $0x0, %eax
jg 0x23ea
jmp 0x2409
leaq 0xc1f(%rip), %rdi       # 0x3010
leaq 0xc2c(%rip), %rsi       # 0x3024
movl $0x115, %edx            # imm = 0x115
leaq 0xc33(%rip), %rcx       # 0x3037
callq 0x1070
movq (%rsp), %rdi
movl $0x63, %esi
callq 0x1790
cmpl $0x0, %eax
jle 0x241e
jmp 0x243d
leaq 0xc2e(%rip), %rdi       # 0x3053
leaq 0xbf8(%rip), %rsi       # 0x3024
movl $0x116, %edx            # imm = 0x116
leaq 0xbff(%rip), %rcx       # 0x3037
callq 0x1070
movq (%rsp), %rdi
movl $0x63, %esi
callq 0x1310
cmpl $0x0, %eax
jle 0x2452
jmp 0x2471
leaq 0xc0d(%rip), %rdi       # 0x3066
leaq 0xbc4(%rip), %rsi       # 0x3024
movl $0x117, %edx            # imm = 0x117
leaq 0xbcb(%rip), %rcx       # 0x3037
callq 0x1070
movq (%rsp), %rdi
movl $0x63, %esi
callq 0x1790
cmpl $0x0, %eax
jg 0x2486
jmp 0x24a5
leaq 0xbec(%rip), %rdi       # 0x3079
leaq 0xb90(%rip), %rsi       # 0x3024
movl $0x118, %edx            # imm = 0x118
leaq 0xb97(%rip), %rcx       # 0x3037
callq 0x1070
ud2
nopw (%rax,%rax)
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: basic_test(SkipList*)
int basic_test(SkipList* sk) {
  for (int i = 0; i < 16; i++) {
	assert (sk->lookup(i) > 0);
  }
  assert (sk->lookup(99) <= 0);
  printf("PASSED\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
jge 0x250b
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x1310
cmpl $0x0, %eax
jle 0x24dd
jmp 0x24fc
leaq 0xba9(%rip), %rdi       # 0x308d
leaq 0xb39(%rip), %rsi       # 0x3024
movl $0x11d, %edx            # imm = 0x11D
leaq 0xba8(%rip), %rcx       # 0x309f
callq 0x1070
jmp 0x24fe
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x24c1
movq 0x10(%rsp), %rdi
movl $0x63, %esi
callq 0x1310
cmpl $0x0, %eax
jg 0x2521
jmp 0x2540
leaq 0xae8(%rip), %rdi       # 0x3010
leaq 0xaf5(%rip), %rsi       # 0x3024
movl $0x11f, %edx            # imm = 0x11F
leaq 0xb64(%rip), %rcx       # 0x309f
callq 0x1070
leaq 0xb73(%rip), %rdi       # 0x30ba
movb $0x0, %al
callq 0x1040
ud2
// File: narula[P]skiplists/skiplist-fanout.cc
// Function: SkipList::printlist()
void SkipList::printlist() {
  node* ptr = head;
  while (ptr != tail) {
	printf("[K:%02d ", ptr->key);
	printf("N: %02d ", ptr->nexts[0][0].nxt->key);
	for (int j = 1; j < ptr->topLevel; j++) {
	  printf("N: ");
	  for (int k = 0; k < FANOUT; k++) {
		printf("%02d ", ptr->nexts[j][k].nxt->key);
	  }
	}
	printf("]\n");
	ptr = ptr->nexts[0][0].nxt;
  }
  printf("]\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
cmpq 0x8(%rcx), %rax
je 0x2652
movq 0x18(%rsp), %rax
movl (%rax), %esi
leaq 0xb35(%rip), %rdi       # 0x30c2
movb $0x0, %al
callq 0x1040
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl (%rax), %esi
leaq 0xb25(%rip), %rdi       # 0x30cb
movb $0x0, %al
callq 0x1040
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2631
leaq 0xb0a(%rip), %rdi       # 0x30d4
movb $0x0, %al
callq 0x1040
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x2622
movq 0x18(%rsp), %rax
addq $0x8, %rax
movslq 0x14(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
leaq 0xac0(%rip), %rdi       # 0x30ce
movb $0x0, %al
callq 0x1040
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x25d9
jmp 0x2624
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x25b5
leaq 0xaa0(%rip), %rdi       # 0x30d8
movb $0x0, %al
callq 0x1040
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x256b
leaq 0xa7f(%rip), %rdi       # 0x30d8
movb $0x0, %al
callq 0x1040
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: leobru[P]ACPUfont/averager.cc
// Function: Picture::divide()
Picture divide() {
	Picture ret = *this;
	for (int i = 0; i < height; ++i)
            for (int j = 0; j < width; ++j)
		ret.p(i,j) = (ret.p(i,j) + (weight+1)/2)/weight;
        ret.weight = 1;
	return ret;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x2430
movl $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rcx
movl 0x30(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x292e
movl $0x0, 0x2c(%rsp)
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x291c
movq 0x10(%rsp), %rdi
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x43a0
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movq 0x20(%rsp), %rax
cvtsi2sdl (%rcx), %xmm0
movsd 0xa73e(%rip), %xmm1     # 0xd018
addsd 0x18(%rax), %xmm1
movsd 0xa729(%rip), %xmm2     # 0xd010
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
divsd 0x18(%rax), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rsp)
movl 0x30(%rsp), %esi
movl 0x2c(%rsp), %edx
callq 0x43a0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x28a1
jmp 0x291e
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x2887
movq 0x10(%rsp), %rax
movsd 0xa6dd(%rip), %xmm0     # 0xd018
movsd %xmm0, 0x18(%rax)
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x2956
movq 0x10(%rsp), %rdi
callq 0x2840
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
// File: leobru[P]ACPUfont/averager.cc
// Function: Picture::dump(_IO_FILE*) const
void dump(FILE * f) const {
	fprintf(f, "P5\n%d %d\n255\n", width, height);
	for (int i = 0; i < height; ++i) {
            for (int j = 0; j < width; ++j)
                putc(255-(p(i,j)+weight/2)/weight, f);
	}
        fclose(f);
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x20(%rax), %edx
movl 0x24(%rax), %ecx
leaq 0xa89c(%rip), %rsi      # 0xd226
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x2a31
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x2a1f
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x4360
movl %eax, %ecx
movq 0x8(%rsp), %rax
cvtsi2sd %ecx, %xmm1
movsd 0x18(%rax), %xmm0
movsd 0xa625(%rip), %xmm2     # 0xd010
divsd %xmm2, %xmm0
addsd %xmm0, %xmm1
divsd 0x18(%rax), %xmm1
movsd 0xa608(%rip), %xmm0     # 0xd008
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %edi
movq 0x18(%rsp), %rsi
callq 0x11d0
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x29b3
jmp 0x2a21
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2999
movq 0x18(%rsp), %rdi
callq 0x10d0
addq $0x28, %rsp
retq
// File: leobru[P]ACPUfont/averager.cc
// Function: Picture::contrast(int, int)
Picture contrast(int pivot, int power) {
        Picture ret = *this;
        if (weight == 0.0) return ret;
        double knee = pivot/255.0;
        for (int i = 0; i < height; ++i)
            for (int j = 0; j < width; ++j) {
                double v = p(i,j)/(weight*255.0);
                if (v <= knee) {
                    v = pow(v/knee/2, power)/pow(0.5, power-1);
                } else {
                    v = 1-pow((1-v)/(1-knee)/2, power)/pow(0.5, power-1);
                }
                ret.p(i,j) = lround(v*255*weight);
            }
        return ret;
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq %rsi, 0x28(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x2430
movq 0x28(%rsp), %rax
movsd 0x18(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2dfe
jp 0x2dfe
movb $0x1, 0x4f(%rsp)
movl $0x1, 0x48(%rsp)
jmp 0x2fc0
cvtsi2sdl 0x54(%rsp), %xmm0
movsd 0xa1fc(%rip), %xmm1     # 0xd008
divsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x28(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x24(%rcx), %eax
jge 0x2fb3
movl $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rcx
movl 0x38(%rsp), %eax
cmpl 0x20(%rcx), %eax
jge 0x2fa1
movq 0x28(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x43a0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cvtsi2sdl (%rcx), %xmm0
movsd 0xa198(%rip), %xmm1     # 0xd008
mulsd 0x18(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x2ee7
movsd 0x30(%rsp), %xmm0
divsd 0x40(%rsp), %xmm0
movsd 0xa16b(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
cvtsi2sdl 0x50(%rsp), %xmm1
callq 0x11a0
movsd %xmm0, 0x10(%rsp)
movl 0x50(%rsp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xa153(%rip), %xmm0     # 0xd020
callq 0x11a0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x2f58
movsd 0xa129(%rip), %xmm0     # 0xd018
subsd 0x30(%rsp), %xmm0
movsd 0xa11b(%rip), %xmm1     # 0xd018
subsd 0x40(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0xa101(%rip), %xmm1     # 0xd010
divsd %xmm1, %xmm0
cvtsi2sdl 0x50(%rsp), %xmm1
callq 0x11a0
movsd %xmm0, 0x8(%rsp)
movl 0x50(%rsp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
movsd 0xa0e9(%rip), %xmm0     # 0xd020
callq 0x11a0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0xa0ca(%rip), %xmm0     # 0xd018
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x28(%rsp), %rax
movsd 0xa0a3(%rip), %xmm0     # 0xd008
mulsd 0x30(%rsp), %xmm0
mulsd 0x18(%rax), %xmm0
callq 0x1030
movq 0x18(%rsp), %rdi
movl %eax, 0x4(%rsp)
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %edx
callq 0x43a0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x2e38
jmp 0x2fa3
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2e1e
movb $0x1, 0x4f(%rsp)
movl $0x1, 0x48(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x2fd1
movq 0x18(%rsp), %rdi
callq 0x2840
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: leobru[P]ACPUfont/averager.cc
// Function: Picture::mse(Picture const&, int, int) const
double mse(const Picture & other, int voff, int hoff) const {
	unsigned totpix = 0;
	double sum = 0.0;
	for (int i = max(0, voff); i < min(height, height+voff); ++i) {
            for (int j = std::max(0, hoff); j < min(width, width+hoff); ++j) {
                double diff=p(i,j)/weight - other.p(i-voff,j-hoff)/other.weight;
                sum += diff*diff;
                ++totpix;
            }
        }
	return sum / pow(totpix, msepower);
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x4c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movl $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x54(%rsp), %rsi
callq 0x42e0
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
movq 0x18(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, 0x14(%rsp)
movq %rax, %rdi
addq $0x24, %rdi
movl 0x24(%rax), %eax
addl 0x54(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0x34(%rsp), %rsi
callq 0x4320
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x3248
movl $0x0, 0x2c(%rsp)
leaq 0x2c(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x42e0
movl (%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movl 0x30(%rsp), %ecx
movl %ecx, 0x10(%rsp)
movq %rax, %rdi
addq $0x20, %rdi
movl 0x20(%rax), %eax
addl 0x50(%rsp), %eax
movl %eax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x4320
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl (%rcx), %eax
jge 0x3236
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0x30(%rsp), %edx
callq 0x4360
movl %eax, %ecx
movq 0x18(%rsp), %rax
cvtsi2sd %ecx, %xmm0
divsd 0x18(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rsp), %rdi
movl 0x3c(%rsp), %esi
subl 0x54(%rsp), %esi
movl 0x30(%rsp), %edx
subl 0x50(%rsp), %edx
callq 0x4360
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
movq 0x58(%rsp), %rax
divsd 0x18(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x3163
jmp 0x3238
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x310e
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x4c(%rsp), %eax
cvtsi2sd %rax, %xmm0
movsd 0xeea4(%rip), %xmm1     # 0x12108
callq 0x11a0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: leobru[P]ACPUfont/averager.cc
// Function: Picture::best_offset(Picture const&, int&, int&) const
double best_offset(const Picture & other, int & voff, int & hoff) const {
	// Compute average distances for all offsets up to size/3
	double minmse = 10e38;
	for (int i = -height/3; i <= height/3; ++i) 
	for (int j = -width/3; j <= width/3; ++j) {
		double curmse = mse(other, i, j);
		if (curmse < minmse) {
			// fprintf(stderr, "MSE = %.3f voff=%d hoff=%d\n", curmse, i, j);
			minmse = curmse;
			voff = i;
			hoff = j;
		}
	}
	// fprintf(stderr, "Best offsets are %d %d\n", voff, hoff);
        return minmse;
    }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movsd 0x9c8e(%rip), %xmm0     # 0xd028
movsd %xmm0, 0x20(%rsp)
xorl %eax, %eax
subl 0x24(%rcx), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, 0x4(%rsp)
movl 0x24(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jg 0x347f
movq 0x8(%rsp), %rcx
xorl %eax, %eax
subl 0x20(%rcx), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rsp), %ecx
movl %ecx, (%rsp)
movl 0x20(%rax), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jg 0x346d
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
callq 0x30c0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x345e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movl 0x18(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
jmp 0x3460
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x33ed
jmp 0x346f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x33b1
movsd 0x20(%rsp), %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<unsigned long>::execute_path(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&, unsigned long&, long)
bool CuckooHash<Key_t>::execute_path(vector<pair<size_t,Key_t>>& path, Key_t& key, Value_t value) {
  for (int i = path.size()-1; i > 0; --i) {
	  memcpy(&table[path[i].first], &table[path[i-1].first], sizeof(Pair<Key_t>));
    //table[path[i].first] = table[path[i-1].first];
  }
  memcpy(&table[path[0].first].key, &key, sizeof(Key_t));
  memcpy(&table[path[0].first].value, &value, sizeof(Value_t));
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e9d0
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1ee80
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x1e9f0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x1e9f0
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1ee00
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1e9f0
movq -0x58(%rbp), %rcx
movq %rax, %rdx
movq -0x30(%rbp), %rax
movq (%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq 0x38(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1e9f0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
// File: chahk0129[P]hash_bench/./index/cuckoo_hash.h
// Function: CuckooHash<unsigned long>::execute_path(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>>&)
bool CuckooHash<Key_t>::execute_path(vector<pair<size_t,Key_t>>& path) {
  auto i = 0;
  auto j = (i+1)%2;

  for (auto p: path) {
	  memcpy(&pushed[j], &table[p.first], sizeof(Pair<Key_t>));
	  memcpy(&table[p.first], &pushed[i], sizeof(Pair<Key_t>));
    //pushed[j] = table[p.first];
    //table[p.first] = pushed[i];
    i = (i+1)%2;
    j = (i+1)%2;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ea30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ea60
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ea90
testb $0x1, %al
jne 0x22b88
jmp 0x22c2f
leaq -0x28(%rbp), %rdi
callq 0x1ead0
movq -0x48(%rbp), %rcx
movq (%rax), %rdx
movq %rdx, -0x40(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq %rcx, %rax
addq $0x40, %rax
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq 0x38(%rcx), %rdx
movq -0x40(%rbp), %rsi
shlq $0x4, %rsi
addq %rsi, %rdx
movq (%rdx), %rsi
movq %rsi, (%rax)
movq 0x8(%rdx), %rdx
movq %rdx, 0x8(%rax)
movq 0x38(%rcx), %rax
movq -0x40(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq $0x40, %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1eb20
jmp 0x22b72
movb $0x1, %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: davidgfnet[P]tadns/tadns-server.cc
// Function: resolved_cb(dns_cb_data*)
void resolved_cb(struct dns_cb_data *cbdata) {
    // Return whatever we found
    struct dns_response *dresp = (struct dns_response*)cbdata->context;

    unsigned numans = 0;
    for (const auto &e: cbdata->replies)
        if (e.resptype == RESPONSE_ANSWER)
            numans++;

    switch (cbdata->error) {
    case DNS_OK:
        dresp->pkt.answers = cbdata->replies;
        dresp->pkt.header.flags = 0x8180;
        dresp->pkt.header.nanswers = numans;
        break;
    case DNS_DOES_NOT_EXIST:
        dresp->pkt.header.flags = 0x8180;
        break;
    case DNS_TIMEOUT:
    case DNS_ERROR:
    case DNS_NET_ERROR:
        dresp->pkt.header.flags = 0x8182;
        break;
    };

    // Blocking send, automatic rate limiting?
    uint8_t tmp[2048];
    unsigned towrite = serialize_udp_packet(&dresp->pkt, tmp);
    sendto(listenfd, tmp, towrite, 0, (struct sockaddr*)&dresp->addrstorage, dresp->addrlen);

    delete dresp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3cf0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3d20
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3d50
testb $0x1, %al
jne 0x37da
jmp 0x3807
leaq -0x28(%rbp), %rdi
callq 0x3d90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x37fa
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x37fc
leaq -0x28(%rbp), %rdi
callq 0x3db0
jmp 0x37c7
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x848(%rbp)
testl %eax, %eax
je 0x3837
jmp 0x381a
movl -0x848(%rbp), %eax
subl $0x1, %eax
je 0x3866
jmp 0x3827
movl -0x848(%rbp), %eax
addl $-0x2, %eax
subl $0x3, %eax
jb 0x3872
jmp 0x387c
movq -0x8(%rbp), %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3dd0
movq -0x10(%rbp), %rax
movw $0x8180, 0x2(%rax)      # imm = 0x8180
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x6(%rax)
jmp 0x387c
movq -0x10(%rbp), %rax
movw $0x8180, 0x2(%rax)      # imm = 0x8180
jmp 0x387c
movq -0x10(%rbp), %rax
movw $0x8182, 0x2(%rax)      # imm = 0x8182
movq -0x10(%rbp), %rdi
leaq -0x840(%rbp), %rsi
callq 0x17df0
movl %eax, -0x844(%rbp)
movl 0x22a88(%rip), %edi     # 0x26320
leaq -0x840(%rbp), %rsi
movl -0x844(%rbp), %eax
movl %eax, %edx
movq -0x10(%rbp), %r8
addq $0x40, %r8
movq -0x10(%rbp), %rax
movl 0xc0(%rax), %r9d
xorl %ecx, %ecx
callq 0x3080
movq -0x10(%rbp), %rax
movq %rax, -0x850(%rbp)
cmpq $0x0, %rax
je 0x38ef
movq -0x850(%rbp), %rdi
callq 0x4020
movq -0x850(%rbp), %rdi
movl $0xc8, %esi
callq 0x3360
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: parseAddr(char const*, sockaddr_storage*)
bool parseAddr(const char *ipaddr, struct sockaddr_storage *addrout) {
    unsigned ok = 0;
    union {
        struct sockaddr_storage addrst;
        struct sockaddr_in6 ipv6addr;
        struct sockaddr_in ipv4addr;
    } addrunion;
    if (strchr(ipaddr, '.') == NULL) {
        addrunion.ipv6addr.sin6_family = AF_INET6;
        addrunion.ipv6addr.sin6_port = htons(53);
        addrunion.ipv6addr.sin6_flowinfo = 0;
        addrunion.ipv6addr.sin6_scope_id = 0;
        ok |= inet_pton(AF_INET6, ipaddr, &addrunion.ipv6addr.sin6_addr);
    } else {
        addrunion.ipv4addr.sin_family = AF_INET;
        addrunion.ipv4addr.sin_port = htons(53);
        ok |= inet_pton(AF_INET, ipaddr, &addrunion.ipv4addr.sin_addr);
    }
    *addrout = addrunion.addrst;
    return (ok == 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x3130
cmpq $0x0, %rax
jne 0x5eda
movw $0xa, -0x98(%rbp)
movl $0x35, %edi
callq 0x3070
movw %ax, -0x96(%rbp)
movl $0x0, -0x94(%rbp)
movl $0x0, -0x80(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdx
addq $0x8, %rdx
movl $0xa, %edi
callq 0x3590
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x5f13
movw $0x2, -0x98(%rbp)
movl $0x35, %edi
callq 0x3070
movw %ax, -0x96(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdx
addq $0x4, %rdx
movl $0x2, %edi
callq 0x3590
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x98(%rbp), %rsi
movl $0x80, %edx
callq 0x32c0
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: createResolver(char const**, unsigned int)
DNSResolverIface * createResolver(const char **dns_servers, unsigned atimeout) {
#ifdef _WIN32
    { WSADATA data; WSAStartup(MAKEWORD(2,2), &data); }
#endif /* _WIN32 */

    std::list<struct sockaddr_storage> serverbundle;

    if (!dns_servers) {
        #ifdef TADNS_DONT_USE_OS_DNS_SERVERS
            return (NULL);
        #else
        serverbundle = getdnsip();
        if (!serverbundle.size())
            return (NULL);
        #endif
    }
    else {
        while (*dns_servers != NULL) {
            struct sockaddr_storage addr;
            if (parseAddr(*dns_servers++, &addr))
                serverbundle.push_back(addr);
        }
    }

    DNSResolver *dns = new DNSResolver(serverbundle, atimeout);

    return (dns);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x95d0
cmpq $0x0, -0x10(%rbp)
jne 0x5fb9
leaq -0x48(%rbp), %rdi
callq 0x60f0
jmp 0x5f6d
leaq -0x30(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x95f0
leaq -0x48(%rbp), %rdi
callq 0x9620
leaq -0x30(%rbp), %rdi
callq 0x9640
cmpq $0x0, %rax
jne 0x5fb7
movq $0x0, -0x8(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x60be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x60d4
jmp 0x6001
jmp 0x5fbb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5fff
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x5e60
testb $0x1, %al
jne 0x5fe9
jmp 0x5ffd
leaq -0x30(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x9670
jmp 0x5ffb
jmp 0x5ffd
jmp 0x5fbb
jmp 0x6001
movl $0xd8, %edi
callq 0x3350
movq %rax, -0x108(%rbp)
jmp 0x6014
movb $0x1, -0xf9(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x96b0
jmp 0x602d
movq -0x108(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0xf8(%rbp), %rsi
callq 0x9770
jmp 0x6045
movb $0x0, -0xf9(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x9620
movq -0x108(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x60be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x60a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x9620
testb $0x1, -0xf9(%rbp)
jne 0x60ab
jmp 0x60bc
movq -0x108(%rbp), %rdi
movl $0xd8, %esi
callq 0x3360
jmp 0x60d4
leaq -0x30(%rbp), %rdi
callq 0x9620
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x9620
movq -0x50(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: getdnsip[abi:cxx11]()
static std::list<struct sockaddr_storage> getdnsip() {
    std::list<struct sockaddr_storage> ret;

#ifdef _WIN32
    LONG err;
    HKEY hKey, hSub;
    char subkey[512], dhcpns[512], ns[512], value[128], *key =
    "SYSTEM\\ControlSet001\\Services\\Tcpip\\Parameters\\Interfaces";

    if ((err = RegOpenKey(HKEY_LOCAL_MACHINE,
        key, &hKey)) != ERROR_SUCCESS) {
        fprintf(stderr, "cannot open reg key %s: %d\n", key, err);
        return ret;
    } else {
        for (int i = 0; RegEnumKey(hKey, i, subkey,
            sizeof(subkey)) == ERROR_SUCCESS; i++) {
            DWORD type, len = sizeof(value);
            if (RegOpenKey(hKey, subkey, &hSub) == ERROR_SUCCESS &&
                (RegQueryValueEx(hSub, "NameServer", 0,
                &type, value, &len) == ERROR_SUCCESS ||
                RegQueryValueEx(hSub, "DhcpNameServer", 0,
                &type, value, &len) == ERROR_SUCCESS)) {

                struct sockaddr_storage addr;
                if (parseAddr(value, &addr))
                    ret.push_back(addr);
                RegCloseKey(hSub);
            }
        }
        RegCloseKey(hKey);
    }
#else
    FILE *fp;
    char line[512];
    char ipaddr[512];

    if ((fp = fopen("/etc/resolv.conf", "r")) != NULL) {
        /* Try to figure out what DNS server to use */
        while (fgets(line, sizeof(line), fp) != NULL) {
            if (sscanf(line, "nameserver%*[ \t]%s", ipaddr) == 1) {
                struct sockaddr_storage addr;
                if (parseAddr(ipaddr, &addr))
                    ret.push_back(addr);
            }
        }
        (void) fclose(fp);
    }
#endif /* _WIN32 */

    return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x4d0, %rsp            # imm = 0x4D0
movq %rdi, -0x4c8(%rbp)
movq %rdi, %rax
movq %rax, -0x4c0(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x95d0
leaq 0x1315a(%rip), %rdi     # 0x1927a
leaq 0x13164(%rip), %rsi     # 0x1928b
callq 0x3400
movq %rax, -0x4b8(%rbp)
jmp 0x6135
movq -0x4b8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x61fc
jmp 0x614c
movq -0x18(%rbp), %rdx
leaq -0x220(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x3500
movq %rax, -0x4d0(%rbp)
jmp 0x616a
movq -0x4d0(%rbp), %rax
cmpq $0x0, %rax
je 0x61ef
leaq -0x220(%rbp), %rdi
leaq -0x420(%rbp), %rdx
leaq 0x13101(%rip), %rsi     # 0x1928d
movb $0x0, %al
callq 0x3320
cmpl $0x1, %eax
jne 0x61ea
leaq -0x420(%rbp), %rdi
leaq -0x4b0(%rbp), %rsi
callq 0x5e60
testb $0x1, %al
jne 0x61b1
jmp 0x61e8
movq -0x4c8(%rbp), %rdi
leaq -0x4b0(%rbp), %rsi
callq 0x9670
jmp 0x61c6
jmp 0x61e8
movq -0x4c8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x428(%rbp)
movl %eax, -0x42c(%rbp)
callq 0x9620
jmp 0x6222
jmp 0x61ea
jmp 0x614c
movq -0x18(%rbp), %rdi
callq 0x3340
jmp 0x61fa
jmp 0x61fc
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x6212
movq -0x4c8(%rbp), %rdi
callq 0x9620
movq -0x4c0(%rbp), %rax
addq $0x4d0, %rsp            # imm = 0x4D0
popq %rbp
retq
movq -0x428(%rbp), %rdi
callq 0x3530
nop
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::find_cached_query(dns_record_type, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
cache_entry* DNSResolver::find_cached_query(enum dns_record_type qtype, std::string name) {
    time_t now = time(NULL);
    auto entry = std::make_pair(name, qtype);
    if (cached.find(entry) != cached.end()) {
        auto r = &(cached.at(entry));
        r->hits++;
        if (r->expire > now)
            return r;
    }
    return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x3310
movq -0xf0(%rbp), %rsi
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
leaq -0x14(%rbp), %rdx
callq 0x99a0
movq -0xe8(%rbp), %rax
movq -0xe0(%rbp), %rsi
addq $0xa0, %rax
movq %rax, -0xd8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9a40
jmp 0x6316
movq -0xd8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x9a10
movq %rax, -0xf8(%rbp)
jmp 0x632f
movq -0xe8(%rbp), %rdi
movq -0xf8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0xa0, %rdi
callq 0x9a80
movq %rax, -0x98(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x99e0
movb %al, -0xf9(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9ab0
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x6382
jmp 0x6469
movq -0xe8(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x108(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x9a40
jmp 0x63a8
movq -0x108(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x9ad0
movq %rax, -0x110(%rbp)
jmp 0x63c4
leaq -0xc8(%rbp), %rdi
callq 0x9ab0
movq -0x110(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x28(%rbp), %rax
jle 0x6467
movq -0xa0(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xcc(%rbp)
jmp 0x647b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x6491
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9ab0
jmp 0x6491
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x9ab0
jmp 0x6491
jmp 0x6469
movq $0x0, -0x8(%rbp)
movl $0x1, -0xcc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9b70
movq -0x8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x9b70
movq -0x88(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: davidgfnet[P]tadns/tadns.cc
// Function: DNSResolver::cancel(void const*)
void DNSResolver::cancel(const void *context) {
    for (auto it: active) {
        if (it.second->ctx == context) {
            ongoing.erase(std::make_pair(it.second->name, it.second->qtype));
            delete it.second;
            active.erase(it.first);
            assert(active.size() == ongoing.size());
            return;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
addq $0x38, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9b90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9bc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9bf0
testb $0x1, %al
jne 0x6503
jmp 0x662c
leaq -0x20(%rbp), %rdi
callq 0x9c20
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x661c
movq -0x78(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rdx
movq %rdx, %rsi
addq $0x10, %rsi
addq $0xc, %rdx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x9c80
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x9c50
jmp 0x656a
leaq -0x60(%rbp), %rdi
callq 0x9ab0
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x65a1
movq -0x90(%rbp), %rdi
callq 0x9cc0
movq -0x90(%rbp), %rdi
movl $0x78, %esi
callq 0x3360
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
leaq -0x38(%rbp), %rsi
callq 0x9e10
movq -0x78(%rbp), %rdi
addq $0x38, %rdi
callq 0x9e40
movq -0x78(%rbp), %rdi
movq %rax, -0x98(%rbp)
addq $0x70, %rdi
callq 0x9e60
movq %rax, %rcx
movq -0x98(%rbp), %rax
cmpq %rcx, %rax
jne 0x65e4
jmp 0x661a
leaq 0x12a9d(%rip), %rdi     # 0x19088
leaq 0x12ab6(%rip), %rsi     # 0x190a8
movl $0x124, %edx            # imm = 0x124
leaq 0x12ab3(%rip), %rcx     # 0x190b1
callq 0x3210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9ab0
jmp 0x6635
jmp 0x662c
jmp 0x661e
leaq -0x20(%rbp), %rdi
callq 0x9e80
jmp 0x64ed
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3530
nop