LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: readmapping[P]alfalfa/src/performanceUtils.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> printVector<int>(std::vector<int, std::allocator<int>>)
string printVector(vector<T> vec){
    stringstream ss;
    if(!vec.empty()){
        ss << vec[0];
        for(size_t i=1; i < vec.size(); i++)
            ss << "," << vec[i];
    }
    return ss.str();
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8260
movq 0x30(%rsp), %rdi
callq 0x709b0
testb $0x1, %al
jne 0x70d18
movq 0x30(%rsp), %rdi
leaq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1eb90
movq 0x18(%rsp), %rdi
movl (%rax), %esi
callq 0x8710
jmp 0x70c8b
movq $0x1, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x1f530
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x70d16
leaq 0x60(%rsp), %rdi
leaq 0xd02f(%rip), %rsi      # 0x7dcf0
callq 0x8360
movq %rax, 0x8(%rsp)
jmp 0x70ccd
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1eb90
movq 0x8(%rsp), %rdi
movl (%rax), %esi
callq 0x8710
jmp 0x70cea
jmp 0x70cec
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x70c94
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x8290
jmp 0x70d40
jmp 0x70d18
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x8350
jmp 0x70d29
leaq 0x50(%rsp), %rdi
callq 0x8290
movq 0x28(%rsp), %rax
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x48(%rsp), %rdi
callq 0x8730
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/qsufsort.c
// Function: select_sort_split
static void select_sort_split(int *p, int n) {
   int *pa, *pb, *pi, *pn;
   int f, v, tmp;

   pa=p;                        /* pa is start of group being picked out.*/
   pn=p+n-1;                    /* pn is last position of subarray.*/
   while (pa<pn) {
      for (pi=pb=pa+1, f=KEY(pa); pi<=pn; ++pi)
         if ((v=KEY(pi))<f) {
            f=v;                /* f is smallest key found.*/
            SWAP(pi, pa);       /* place smallest element at beginning.*/
            pb=pa+1;            /* pb is position for elements equal to f.*/
         } else if (v==f) {     /* if equal to smallest key.*/
            SWAP(pi, pb);       /* place next to other smallest elements.*/
            ++pb;
         }
      update_group(pa, pb-1);   /* update group values for new group.*/
      pa=pb;                    /* continue sorting rest of the subarray.*/
   }
   if (pa==pn) {                /* check if last part is single element.*/
      V[*pa]=pa-I;
      *pa=-1;                   /* sorted group.*/
   }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movslq 0x3c(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x73077
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq 0x24585(%rip), %rax     # 0x97500
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
addl 0x24588(%rip), %ecx     # 0x97510
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x73055
movq 0x24557(%rip), %rax     # 0x97500
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
addl 0x2455a(%rip), %ecx     # 0x97510
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x10(%rsp)
cmpl 0x14(%rsp), %eax
jge 0x73002
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x73040
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x7303e
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x73040
jmp 0x73042
movq 0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x20(%rsp)
jmp 0x72f92
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $-0x4, %rsi
callq 0x73980
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x72f51
movq 0x30(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x730b5
movq 0x30(%rsp), %rax
movq 0x24479(%rip), %rcx     # 0x97508
subq %rcx, %rax
sarq $0x2, %rax
movl %eax, %edx
movq 0x24461(%rip), %rax     # 0x97500
movq 0x30(%rsp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: readmapping[P]alfalfa/src/qsufsort.c
// Function: update_group
static void update_group(int *pl, int *pm)
{
   int g;

   g=pm-I;                      /* group number.*/
   V[*pl]=g;                    /* update group number of first position.*/
   if (pl==pm)
      *pl=-1;                   /* one element, sorted group.*/
   else
      do                        /* more than one element, unsorted group.*/
         V[*++pl]=g;            /* update group numbers.*/
      while (pl<pm);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x23b72(%rip), %rcx     # 0x97508
subq %rcx, %rax
sarq $0x2, %rax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %edx
movq 0x23b54(%rip), %rax     # 0x97500
movq -0x8(%rsp), %rcx
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
jne 0x739d0
movq -0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x73a03
jmp 0x739d2
movl -0x14(%rsp), %edx
movq 0x23b23(%rip), %rax     # 0x97500
movq -0x8(%rsp), %rcx
movq %rcx, %rsi
addq $0x4, %rsi
movq %rsi, -0x8(%rsp)
movslq 0x4(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
cmpq -0x10(%rsp), %rax
jb 0x739d2
jmp 0x73a03
retq
nopw %cs:(%rax,%rax)
nop
// File: readmapping[P]alfalfa/src/ksw.c
// Function: push_cigar
static inline uint32_t *push_cigar(int *n_cigar, int *m_cigar, uint32_t *cigar, int op, int len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf)) {
		if (*n_cigar == *m_cigar) {
			*m_cigar = *m_cigar? (*m_cigar)<<1 : 4;
			cigar = realloc(cigar, (*m_cigar) << 2);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
je 0x77b1a
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
je 0x77b9b
movq 0x20(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x77b75
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
je 0x77b43
movq 0x18(%rsp), %rax
movl (%rax), %eax
shll %eax
movl %eax, 0x4(%rsp)
jmp 0x77b4e
movl $0x4, %eax
movl %eax, 0x4(%rsp)
jmp 0x77b4e
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
shll $0x2, %eax
movslq %eax, %rsi
callq 0x86d0
movq %rax, 0x10(%rsp)
movl 0x8(%rsp), %edx
shll $0x4, %edx
orl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x77bba
movl 0x8(%rsp), %edx
shll $0x4, %edx
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/kthread.c
// Function: kt_for
void kt_for(int n_threads, int n, void (*func)(void*,int,int), void *data)
{
	int i;
	kt_for_t t;
	pthread_t *tid;
	t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
	t.w = (ktf_worker_t*)alloca(n_threads * sizeof(ktf_worker_t));
	tid = (pthread_t*)alloca(n_threads * sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i)
		t.w[i].t = &t, t.w[i].i = i;
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x38(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x78149
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
leaq -0x40(%rbp), %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7810b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x78191
movq -0x48(%rbp), %rdi
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x38(%rbp), %rcx
movslq -0x1c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x4f(%rip), %rdx        # 0x781d0
callq 0x8780
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x78150
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x781c0
movq -0x48(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8340
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x78198
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/kthread.c
// Function: ktf_worker
static void *ktf_worker(void *data)
{
	ktf_worker_t *w = (ktf_worker_t*)data;
	int i;
	for (;;) {
		i = __sync_fetch_and_add(&w->i, w->t->n_threads);
		if (i >= w->t->n) break;
		w->t->func(w->t->data, i, w - w->t->w);
	}
	while ((i = ktf_steal_work(w->t)) >= 0)
		w->t->func(w->t->data, i, w - w->t->w);
	pthread_exit(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq (%rcx), %rax
movl (%rax), %eax
lock
xaddl %eax, 0x8(%rcx)
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x4(%rcx), %eax
jl 0x78209
jmp 0x78243
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl %ecx, %edx
callq *%rax
jmp 0x781e3
jmp 0x78245
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x787d0
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jl 0x78295
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rdi
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl %ecx, %edx
callq *%rax
jmp 0x78245
xorl %eax, %eax
movl %eax, %edi
callq 0x8740
nop
// File: readmapping[P]alfalfa/src/kthread.c
// Function: kt_init
kthread_t *kt_init(int n_threads)
{
	kthread_t *t;
	int i;
	t = (kthread_t*)calloc(1, sizeof(kthread_t));
	t->n_threads = n_threads;
	t->w = (kts_worker_t*)calloc(t->n_threads, sizeof(kts_worker_t));
	pthread_mutex_init(&t->lock, 0);
	pthread_cond_init(&t->cv, 0);
	for (i = 0; i < t->n_threads; ++i) {
		t->w[i].i = i, t->w[i].t = t, t->w[i].pending = -1;
		pthread_create(&t->w[i].tid, 0, kts_worker, &t->w[i]);
	}
	return t;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x1, %edi
movl $0x6070, %esi           # imm = 0x6070
callq 0x8220
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rdi
movl $0x20, %esi
callq 0x8220
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x6018, %rdi           # imm = 0x6018
xorl %eax, %eax
movl %eax, %esi
callq 0x8620
movq 0x8(%rsp), %rdi
addq $0x6040, %rdi           # imm = 0x6040
xorl %eax, %eax
movl %eax, %esi
callq 0x8490
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x783c8
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movslq 0x4(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movslq 0x4(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x2d(%rip), %rdx        # 0x783e0
callq 0x8780
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x78318
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/kthread.c
// Function: kt_sync
void kt_sync(kthread_t *t)
{
	int i;
	pthread_mutex_lock(&t->lock);
	t->to_sync = 1;
	pthread_cond_broadcast(&t->cv);
	pthread_mutex_unlock(&t->lock);
	for (i = 0; i < t->n_threads; ++i)
		pthread_join(t->w[i].tid, 0);
	free(t->w); free(t);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x6018, %rdi           # imm = 0x6018
callq 0x85f0
movq 0x10(%rsp), %rax
movl $0x1, 0xc(%rax)
movq 0x10(%rsp), %rdi
addq $0x6040, %rdi           # imm = 0x6040
callq 0x8140
movq 0x10(%rsp), %rdi
addq $0x6018, %rdi           # imm = 0x6018
callq 0x82a0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x786cc
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8340
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x78690
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x8470
movq 0x10(%rsp), %rdi
callq 0x8470
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: readmapping[P]alfalfa/src/kthread.c
// Function: kt_spawn
int kt_spawn(kthread_t *t, int n, void (*func)(void*,int,int), void *data)
{
	kts_task_t *task;
	if (t->n_tasks >= KT_MAX_TASKS) return -1;
	pthread_mutex_lock(&t->lock);
	task = &t->tasks[t->n_tasks++];
	task->n = n, task->func = func, task->data = data;
	t->n_slots += n;
	pthread_cond_broadcast(&t->cv);
	pthread_mutex_unlock(&t->lock);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x400, 0x10(%rax)      # imm = 0x400
jl 0x78722
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x787bb
movq 0x28(%rsp), %rdi
addq $0x6018, %rdi           # imm = 0x6018
callq 0x85f0
movq 0x28(%rsp), %rax
addq $0x18, %rax
movq 0x28(%rsp), %rdx
movl 0x10(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10(%rdx)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq 0x28(%rsp), %rdi
addq $0x6040, %rdi           # imm = 0x6040
callq 0x8140
movq 0x28(%rsp), %rdi
addq $0x6018, %rdi           # imm = 0x6018
callq 0x82a0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: readmapping[P]alfalfa/src/kthread.c
// Function: ktf_steal_work
static inline int ktf_steal_work(kt_for_t *t)
{
	int i, k, min = 0x7fffffff, min_i = 0;
	for (i = 0; i < t->n_threads; ++i)
		if (min > t->w[i].i) min = t->w[i].i, min_i = i;
	k = __sync_fetch_and_add(&t->w[min_i].i, t->n_threads);
	return k >= t->n? -1 : k;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x7fffffff, -0x14(%rsp) # imm = 0x7FFFFFFF
movl $0x0, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x7884b
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq -0xc(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jle 0x7883c
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0x7883e
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x787ed
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq -0x18(%rsp), %rdx
shlq $0x4, %rdx
movl (%rax), %eax
lock
xaddl %eax, 0x8(%rcx,%rdx)
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x78882
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x1c(%rsp)
jmp 0x7888a
movl -0x10(%rsp), %eax
movl %eax, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
retq
nop
// File: readmapping[P]alfalfa/src/kthread.c
// Function: process_slot
static inline void process_slot(const kthread_t *t, int i, int tid)
{
	int j;
	for (j = 0;; ++j) {
		kts_task_t task = t->tasks[j];
		if (i < task.n) {
			task.func(task.data, i, tid);
			break;
		} else i -= task.n;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rax
addq $0x18, %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x788f8
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
callq *%rax
jmp 0x78915
movl 0x8(%rsp), %ecx
movl 0x2c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x2c(%rsp)
jmp 0x78908
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x788a9
addq $0x38, %rsp
retq
// File: ArashPartow[P]exprtk-extras/exprtk_binomial_coefficient.cpp
// Function: double ncr_println<double>(double, double, double)
inline T ncr_println(T n, T r, T ncr)
{
   printf("ncr(%2d,%2d) = %2llu\n",
          static_cast<int>(n),
          static_cast<int>(r),
          static_cast<unsigned long long>(ncr));

   return T(0);
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm2, (%rsp)
cvttsd2si 0x10(%rsp), %esi
cvttsd2si 0x8(%rsp), %edx
movsd (%rsp), %xmm0
movsd 0x341e3a(%rip), %xmm2   # 0x45e008
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rcx
movq %rcx, %rdi
sarq $0x3f, %rdi
andq %rdi, %rax
orq %rax, %rcx
leaq 0x34754e(%rip), %rdi    # 0x463741
movb $0x0, %al
callq 0x114080
xorps %xmm0, %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: white0dew[P]WebServer/timer/lst_timer.cpp
// Function: sort_timer_lst::add_timer(util_timer*, util_timer*)
void sort_timer_lst::add_timer(util_timer *timer, util_timer *lst_head)
{
    util_timer *prev = lst_head;
    util_timer *tmp = prev->next;
    //从双向链表中找到该定时器应该放置的位置
    //即遍历一遍双向链表找到对应的位置
    //时间复杂度太高O(n)
    //这里可以考虑使用C++11的优先队列实现定时器-----TODO
    while (tmp)
    {
        if (timer->expire < tmp->expire)
        {
            prev->next = timer;
            timer->next = tmp;
            tmp->prev = timer;
            timer->prev = prev;
            break;
        }
        prev = tmp;
        tmp = tmp->next;
    }

    //遍历完发现，目标定时器需要放到尾结点处
    if (!tmp)
    {
        prev->next = timer;
        timer->prev = prev;
        timer->next = NULL;
        tail = timer;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x439b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x4385
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x439b
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x433c
cmpq $0x0, -0x28(%rbp)
jne 0x43d2
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq %rdx, 0x20(%rcx)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq -0x10(%rbp), %rcx
movq $0x0, 0x20(%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: white0dew[P]WebServer/timer/lst_timer.cpp
// Function: cb_func(client_data*)
void cb_func(client_data *user_data)
{
    //删除非活动连接在socket上的注册事件
    epoll_ctl(Utils::u_epollfd, EPOLL_CTL_DEL, user_data->sockfd, 0);
    assert(user_data);
    //删除非活动连接在socket上的注册事件
    close(user_data->sockfd);
    //减少连接数
    http_conn::m_user_count--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0xfb4e(%rip), %edi      # 0x14480
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movl $0x2, %esi
xorl %eax, %eax
movl %eax, %ecx
callq 0x3600
cmpq $0x0, -0x8(%rbp)
je 0x4950
jmp 0x496f
leaq 0x9745(%rip), %rdi      # 0xe09c
leaq 0x96fd(%rip), %rsi      # 0xe05b
movl $0x10d, %edx            # imm = 0x10D
leaq 0x973c(%rip), %rcx      # 0xe0a6
callq 0x3300
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x37e0
leaq 0xfb66(%rip), %rax      # 0x144e8
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0xfb5a(%rip), %rax      # 0x144e8
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: white0dew[P]WebServer/http/http_conn.cpp
// Function: http_conn::add_response(char const*, ...)
bool http_conn::add_response(const char *format, ...)
{
    //如果写入内容超出m_write_buf大小则报错
    if (m_write_idx >= WRITE_BUFFER_SIZE)
        return false;
    //定义可变参数列表
    va_list arg_list;
    //将变量arg_list初始化为传入参数
    va_start(arg_list, format);
    //将数据format从可变参数列表写入缓冲区写，返回写入数据的长度
    int len = vsnprintf(m_write_buf + m_write_idx, WRITE_BUFFER_SIZE - 1 - m_write_idx, format, arg_list);
    //如果写入的数据长度超过缓冲区剩余空间，则报错
    if (len >= (WRITE_BUFFER_SIZE - 1 - m_write_idx))
    {
        va_end(arg_list);
        return false;
    }
    //更新m_write_idx位置
    m_write_idx += len;
    //清空可变参列表
    va_end(arg_list);

    LOG_INFO("request:%s", m_write_buf);

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x66eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf8(%rbp)
cmpl $0x400, 0xc34(%rax)     # imm = 0x400
jl 0x672f
movb $0x0, -0x1(%rbp)
jmp 0x680d
movq -0xf8(%rbp), %rcx
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rdx
movq %rdx, 0x10(%rax)
leaq 0x10(%rbp), %rdx
movq %rdx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq %rcx, %rdi
addq $0x834, %rdi            # imm = 0x834
movslq 0xc34(%rcx), %rax
addq %rax, %rdi
movl $0x3ff, %eax            # imm = 0x3FF
subl 0xc34(%rcx), %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x32d0
movq -0xf8(%rbp), %rdx
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl $0x3ff, %ecx            # imm = 0x3FF
subl 0xc34(%rdx), %ecx
cmpl %ecx, %eax
jl 0x67af
leaq -0x30(%rbp), %rax
movb $0x0, -0x1(%rbp)
jmp 0x680d
movq -0xf8(%rbp), %rcx
movl -0x34(%rbp), %eax
addl 0xc34(%rcx), %eax
movl %eax, 0xc34(%rcx)
leaq -0x30(%rbp), %rax
xorl %eax, %eax
cmpl 0xe34(%rcx), %eax
jne 0x6809
callq 0x6d70
movq -0xf8(%rbp), %rcx
movq %rax, %rdi
addq $0x834, %rcx            # imm = 0x834
movl $0x1, %esi
leaq 0x7b50(%rip), %rdx      # 0xe345
movb $0x0, %al
callq 0x9280
callq 0x6d70
movq %rax, %rdi
callq 0x97f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: white0dew[P]WebServer/webserver.cpp
// Function: WebServer::dealwithsignal(bool&, bool&)
bool WebServer::dealwithsignal(bool &timeout, bool &stop_server)
{
    int ret = 0;
    int sig;
    char signals[1024];
    //从管道读端读出信号值，成功返回字节数，失败返回-1
    //正常情况下，这里的ret返回值总是1，只有14和15两个ASCII码对应的字符
    ret = recv(m_pipefd[0], signals, sizeof(signals), 0);
    if (ret == -1)
    {
        // handle the error
        return false;
    }
    else if (ret == 0)
    {
        return false;
    }
    else
    {
        //处理信号值对应的逻辑
        for (int i = 0; i < ret; ++i)
        {
            
            //这里面明明是字符
            switch (signals[i])
            {
            //这里是整型
            case SIGALRM:
            {
                timeout = true;
                break;
            }
            //关闭服务器
            case SIGTERM:
            {
                stop_server = true;
                break;
            }
            }
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, -0x24(%rbp)
movl 0x1c(%rax), %edi
leaq -0x430(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x3130
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xc067
movb $0x0, -0x1(%rbp)
jmp 0xc0dc
cmpl $0x0, -0x24(%rbp)
jne 0xc073
movb $0x0, -0x1(%rbp)
jmp 0xc0dc
movl $0x0, -0x434(%rbp)
movl -0x434(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xc0d4
movslq -0x434(%rbp), %rax
movsbl -0x430(%rbp,%rax), %eax
movl %eax, -0x438(%rbp)
subl $0xe, %eax
je 0xc0b1
jmp 0xc0a4
movl -0x438(%rbp), %eax
subl $0xf, %eax
je 0xc0ba
jmp 0xc0c1
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
jmp 0xc0c1
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
jmp 0xc0c3
movl -0x434(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x434(%rbp)
jmp 0xc07d
jmp 0xc0d6
jmp 0xc0d8
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw (%rax,%rax)
// File: loadzero[P]geoloc/geoloc/geoloc.cpp
// Function: usage(char const*)
static void usage(const char* condition)
{
    if (condition)
    {
        fprintf(stderr, "%s\n", condition);
    }

    fprintf(stderr, "usage:");
    fprintf(stderr, "\tgeoloc -f file ... [--headers]\n");
    fprintf(stderr, "\tgeoloc -q ip ...\n");
    fprintf(stderr, "\n");
    fprintf(stderr, "This software includes GeoLite data created by MaxMind\n");
    fprintf(stderr, "available from http://www.maxmind.com\n");

    exit(1);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x58a8
movq 0x21745(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
movq (%rsp), %rdx
leaq 0x1680f(%rip), %rsi     # 0x1c0b0
movb $0x0, %al
callq 0x4430
movq 0x21729(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x1687b(%rip), %rsi     # 0x1c134
movb $0x0, %al
callq 0x4430
movq 0x21711(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x1686a(%rip), %rsi     # 0x1c13b
movb $0x0, %al
callq 0x4430
movq 0x216f9(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x16873(%rip), %rsi     # 0x1c15c
movb $0x0, %al
callq 0x4430
movq 0x216e1(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x1686c(%rip), %rsi     # 0x1c16d
movb $0x0, %al
callq 0x4430
movq 0x216c9(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x16856(%rip), %rsi     # 0x1c16f
movb $0x0, %al
callq 0x4430
movq 0x216b1(%rip), %rax     # 0x26fd8
movq (%rax), %rdi
leaq 0x16876(%rip), %rsi     # 0x1c1a7
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x4330
nopw %cs:(%rax,%rax)
// File: loadzero[P]geoloc/geoloc/geoloc.cpp
// Function: default_file[abi:cxx11]()
static std::string default_file()
{
    const char* home_env = getenv("HOME");
    std::string home_dir = home_env ? home_env : "";

    if (home_dir.empty())
    {
        FATAL_ERROR("could not get home dir");
    }

    return home_dir + "/var/db/geoloc/geodata.bin";
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
leaq 0x16861(%rip), %rdi     # 0x1c1ce
callq 0x4340
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x598b
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x5999
leaq 0x167dc(%rip), %rax     # 0x1c16e
movq %rax, 0x18(%rsp)
jmp 0x5999
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x44e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x43f0
jmp 0x59c8
leaq 0x47(%rsp), %rdi
callq 0x42d0
leaq 0x48(%rsp), %rdi
callq 0x44b0
movb %al, 0x7(%rsp)
jmp 0x59e2
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x59ec
jmp 0x5a3e
leaq 0x167e0(%rip), %rdi     # 0x1c1d3
leaq 0x167eb(%rip), %rdx     # 0x1c1e5
xorl %eax, %eax
movl $0x33, %esi
callq 0x1b800
jmp 0x5a08
jmp 0x5a3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x47(%rsp), %rdi
callq 0x42d0
jmp 0x5a6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x41a0
jmp 0x5a6a
movq 0x20(%rsp), %rdi
leaq 0x167b2(%rip), %rdx     # 0x1c1fc
leaq 0x48(%rsp), %rsi
callq 0x5ca0
jmp 0x5a56
leaq 0x48(%rsp), %rdi
callq 0x41a0
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
jmp 0x5a6c
movq 0x38(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nop
// File: loadzero[P]geoloc/geoloc/args.hpp
// Function: Args::pop()
const char* pop()
    {
        if (empty())
        {
            return 0;
        }

        const char* ret = argv_[idx_];
        idx_++;

        return ret;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5b60
testb $0x1, %al
jne 0x5bee
jmp 0x5bf9
movq $0x0, 0x20(%rsp)
jmp 0x5c22
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movslq 0x10(%rax), %rdx
movq (%rcx,%rdx,8), %rcx
movq %rcx, 0x10(%rsp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: loadzero[P]geoloc/geoloc/etl.hpp
// Function: etl(char const*, char const*, char const*, char const*)
inline void etl(const char* city_blocks,
                const char* city_locs,
                const char* geo_asns,
                const char* output)
{
    LOG_CONTEXT("etl blocks %s locs %s asns %s into file %s", 
                 city_blocks,
                 city_locs,
                 geo_asns,
                 output);

    BinaryFile file;
    bool ok = file.open(output);

    if (!ok)
    {
        FATAL_ERROR("could not open %s for writing", output);
    }

    char buf[32]; get_header(buf, sizeof(buf));

    file.save_bytes_raw(buf, sizeof(buf));
    build_geo_data(file, city_blocks, city_locs, geo_asns);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rcx
movq 0x88(%rsp), %r8
movq 0x80(%rsp), %r9
movq 0x78(%rsp), %rdx
movq %rsp, %rax
movq %rdx, (%rax)
leaq 0x162a9(%rip), %rdi     # 0x1c217
leaq 0x162b1(%rip), %rdx     # 0x1c226
xorl %eax, %eax
movl $0x6b, %esi
callq 0x1b650
leaq 0x58(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6250
movq 0x10(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0x6270
movb %al, 0x1f(%rsp)
jmp 0x5fa5
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x5ff3
movq 0x78(%rsp), %rcx
leaq 0x16255(%rip), %rdi     # 0x1c217
leaq 0x16288(%rip), %rdx     # 0x1c251
xorl %eax, %eax
movl $0x72, %esi
callq 0x1b800
jmp 0x5fd7
jmp 0x5ff3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x6450
jmp 0x6050
leaq 0x20(%rsp), %rdi
movl $0x20, %esi
callq 0x62b0
jmp 0x6004
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x20, %edx
callq 0x6390
jmp 0x601a
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
leaq 0x58(%rsp), %rdi
callq 0x6400
jmp 0x603e
leaq 0x58(%rsp), %rdi
callq 0x6450
addq $0x98, %rsp
retq
jmp 0x6052
movq 0x48(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nopw %cs:(%rax,%rax)
nop
// File: loadzero[P]geoloc/geoloc/query.hpp
// Function: query(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, bool)
inline void query(const char* data_file_name,
                  const std::vector<std::string> &data_sources,
                  bool show_headers)
{
    LOG_CONTEXT("query data %s with %zu sources", data_file_name, data_sources.size());

    GeoData data;
    data.open(data_file_name);

    if (show_headers)
    {
        IPResultEmitter::show_headers();
    }

    for (size_t i = 0; i < data_sources.size(); ++i)
    {
        query(data, data_sources[i]);
    }
}

// Assembly:
subq $0xf8, %rsp
movb %dl, %al
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
andb $0x1, %al
movb %al, 0xe7(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x16020
movq 0x20(%rsp), %rcx
movq %rax, %r8
leaq 0x164ed(%rip), %rdi     # 0x1c5a8
leaq 0x164f7(%rip), %rdx     # 0x1c5b9
xorl %eax, %eax
movl $0x1b3, %esi            # imm = 0x1B3
callq 0x1b650
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x16040
movq 0x28(%rsp), %rdi
movq 0xf0(%rsp), %rsi
callq 0x16140
jmp 0x60f1
testb $0x1, 0xe7(%rsp)
je 0x6121
callq 0x16290
jmp 0x6102
jmp 0x6121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x167d0
jmp 0x61a5
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xe8(%rsp), %rdi
callq 0x16020
movq %rax, 0x18(%rsp)
jmp 0x6148
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x6193
movq 0xe8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x167b0
movq %rax, 0x8(%rsp)
jmp 0x6170
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x162b0
jmp 0x6181
jmp 0x6183
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x612a
leaq 0x48(%rsp), %rdi
callq 0x167d0
addq $0xf8, %rsp
retq
jmp 0x61a7
movq 0x40(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nopl (%rax)
// File: loadzero[P]geoloc/geoloc/etl.hpp
// Function: get_header(char*, unsigned long)
inline void get_header(char* buf, size_t n)
{
    REL_ASSERT(n > 0);

    memset(buf, '-', n);

    int np = snprintf(buf, n, "geoloc loadzero v001 %s ", get_endian());

    REL_ASSERT(np >= 0);

    if (np > (int) (n-1))
    {
        np = n-1;
    }

    buf[np] = '-';
    buf[n-1] = '\n';
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
ja 0x62e0
leaq 0x15f4a(%rip), %rdi     # 0x1c217
movl $0x51, %esi
leaq 0x15f98(%rip), %rdx     # 0x1c271
movb $0x0, %al
callq 0x1b800
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl $0x2d, %esi
callq 0x4160
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x65a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rcx
leaq 0x15f68(%rip), %rdx     # 0x1c287
movb $0x0, %al
callq 0x4460
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x634b
leaq 0x15edf(%rip), %rdi     # 0x1c217
movl $0x57, %esi
leaq 0x15f5c(%rip), %rdx     # 0x1c2a0
movb $0x0, %al
callq 0x1b800
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
cmpl %ecx, %eax
jle 0x6369
movq 0x18(%rsp), %rax
subq $0x1, %rax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movb $0x2d, (%rax,%rcx)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movb $0xa, (%rax,%rcx)
addq $0x28, %rsp
retq
nop
// File: loadzero[P]geoloc/geoloc/etl.hpp
// Function: build_blocks(BinaryFile&, char const*)
inline void build_blocks(BinaryFile &file, const char* source)
{
    LOG_CONTEXT("build_blocks from %s", source);

    FileReader reader(source);
    BlockParser parser;

    std::vector<Block> blocks;
    Collector<Block> collector(blocks);

    reader | parser | collector;
    reader.produce();

    save_blocks(file, blocks);
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0xf8(%rsp), %rcx
leaq 0x15c21(%rip), %rdi     # 0x1c217
leaq 0x15d02(%rip), %rdx     # 0x1c2ff
xorl %eax, %eax
movl $0x27, %esi
callq 0x1b650
movq 0xf8(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xaf(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x44e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xb0(%rsp), %rdi
callq 0x43f0
jmp 0x6641
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x6c10
jmp 0x6658
leaq 0xb0(%rsp), %rdi
callq 0x41a0
jmp 0x6667
leaq 0xaf(%rsp), %rdi
callq 0x42d0
leaq 0x48(%rsp), %rdi
callq 0x6d30
jmp 0x6680
leaq 0x30(%rsp), %rdi
callq 0x6dc0
jmp 0x668c
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6dd0
jmp 0x669d
leaq 0xd0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6e10
movq %rax, (%rsp)
jmp 0x66b5
movq (%rsp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x18(%rsp), %rsi
callq *%rax
jmp 0x66c9
leaq 0xd0(%rsp), %rdi
callq 0x6e30
jmp 0x66d8
movq 0x100(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x6e70
jmp 0x66ec
leaq 0x30(%rsp), %rdi
callq 0x7260
jmp 0x66f8
leaq 0x48(%rsp), %rdi
callq 0x72e0
jmp 0x6704
leaq 0xd0(%rsp), %rdi
callq 0x7350
addq $0x108, %rsp            # imm = 0x108
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x6754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x41a0
jmp 0x6752
jmp 0x6754
leaq 0xaf(%rsp), %rdi
callq 0x42d0
jmp 0x67d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x67bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
jmp 0x67b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7260
jmp 0x67af
jmp 0x67b1
leaq 0x48(%rsp), %rdi
callq 0x72e0
jmp 0x67bd
jmp 0x67bf
leaq 0xd0(%rsp), %rdi
callq 0x7350
jmp 0x67ce
jmp 0x67d0
movq 0xa0(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nopw %cs:(%rax,%rax)
nop
// File: loadzero[P]geoloc/geoloc/etl.hpp
// Function: build_locations(BinaryFile&, char const*)
inline void build_locations(BinaryFile &file, const char* source)
{
    LOG_CONTEXT("build_locations from %s", source);

    FileReader reader(source);
    LocationParser parser;

    std::vector<Location> locations;
    Collector<Location> collector(locations);

    reader | parser | collector;
    reader.produce();

    save_locations(file, locations);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x118(%rsp), %rcx
leaq 0x15a01(%rip), %rdi     # 0x1c217
leaq 0x15c97(%rip), %rdx     # 0x1c4b4
xorl %eax, %eax
movl $0x17, %esi
callq 0x1b650
movq 0x118(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x44e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
callq 0x43f0
jmp 0x6861
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x6c10
jmp 0x6878
leaq 0xd0(%rsp), %rdi
callq 0x41a0
jmp 0x6887
leaq 0xcf(%rsp), %rdi
callq 0x42d0
leaq 0x48(%rsp), %rdi
callq 0xae40
jmp 0x68a0
leaq 0x30(%rsp), %rdi
callq 0xaf00
jmp 0x68ac
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xaf10
jmp 0x68bd
leaq 0xf0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6e10
movq %rax, %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x18(%rsp), %rsi
callq *%rax
jmp 0x68e2
leaq 0xf0(%rsp), %rdi
callq 0x6e30
jmp 0x68f1
movq 0x120(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xaf50
jmp 0x6905
leaq 0x30(%rsp), %rdi
callq 0xb3e0
jmp 0x6911
leaq 0x48(%rsp), %rdi
callq 0xb460
jmp 0x691d
leaq 0xf0(%rsp), %rdi
callq 0x7350
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x696d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x41a0
jmp 0x696b
jmp 0x696d
leaq 0xcf(%rsp), %rdi
callq 0x42d0
jmp 0x69e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x69d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x69ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xb3e0
jmp 0x69c8
jmp 0x69ca
leaq 0x48(%rsp), %rdi
callq 0xb460
jmp 0x69d6
jmp 0x69d8
leaq 0xf0(%rsp), %rdi
callq 0x7350
jmp 0x69e7
jmp 0x69e9
movq 0xc0(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nop
// File: loadzero[P]geoloc/geoloc/etl.hpp
// Function: build_asns(BinaryFile&, char const*)
inline void build_asns(BinaryFile &file, const char* source)
{
    LOG_CONTEXT("build_asns from %s", source);

    FileReader reader(source);
    ASNParser parser;

    std::vector<ASN> asns;
    Collector<ASN> collector(asns);

    reader | parser | collector;
    reader.produce();

    save_asns(file, asns);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x118(%rsp), %rcx
leaq 0x157f1(%rip), %rdi     # 0x1c217
leaq 0x15ab7(%rip), %rdx     # 0x1c4e4
xorl %eax, %eax
movl $0x37, %esi
callq 0x1b650
movq 0x118(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x44e0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
callq 0x43f0
jmp 0x6a71
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x6c10
jmp 0x6a88
leaq 0xd0(%rsp), %rdi
callq 0x41a0
jmp 0x6a97
leaq 0xcf(%rsp), %rdi
callq 0x42d0
leaq 0x48(%rsp), %rdi
callq 0x12060
jmp 0x6ab0
leaq 0x30(%rsp), %rdi
callq 0x12120
jmp 0x6abc
leaq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12130
jmp 0x6acd
leaq 0xf0(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6e10
movq %rax, %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq 0x18(%rsp), %rsi
callq *%rax
jmp 0x6af2
leaq 0xf0(%rsp), %rdi
callq 0x6e30
jmp 0x6b01
movq 0x120(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x12170
jmp 0x6b15
leaq 0x30(%rsp), %rdi
callq 0x12720
jmp 0x6b21
leaq 0x48(%rsp), %rdi
callq 0x127a0
jmp 0x6b2d
leaq 0xf0(%rsp), %rdi
callq 0x7350
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x6b7d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x41a0
jmp 0x6b7b
jmp 0x6b7d
leaq 0xcf(%rsp), %rdi
callq 0x42d0
jmp 0x6bf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x6be8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x6bda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12720
jmp 0x6bd8
jmp 0x6bda
leaq 0x48(%rsp), %rdi
callq 0x127a0
jmp 0x6be6
jmp 0x6be8
leaq 0xf0(%rsp), %rdi
callq 0x7350
jmp 0x6bf7
jmp 0x6bf9
movq 0xc0(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nop
// File: loadzero[P]geoloc/geoloc/pipeline.hpp
// Function: FileReader::FileReader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit FileReader(const std::string &fn)
        :
        buffer_(0),
        cap_(0),
        file_(0)
    {
        if (fn == "-")
        {
            file_ = stdin;
        }
        else
        {
            file_ = fopen(fn.c_str(), "r");
        }

        if (!file_)
        {
            FATAL_ERROR("could not open %s", fn.c_str());
        }

        if (file_ == 0)
        {
            fprintf(stderr, "file %s dne\n", fn.c_str());
            exit(1);
        }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x73c0
movq 0x10(%rsp), %rax
leaq 0x1fda7(%rip), %rcx     # 0x269e0
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
leaq 0x156b0(%rip), %rsi     # 0x1c314
callq 0x73f0
testb $0x1, %al
jne 0x6c6f
jmp 0x6c84
movq 0x10(%rsp), %rax
movq 0x20355(%rip), %rcx     # 0x26fd0
movq (%rcx), %rcx
movq %rcx, 0x20(%rax)
jmp 0x6ca9
movq 0x18(%rsp), %rdi
callq 0x4100
movq %rax, %rdi
leaq 0x15980(%rip), %rsi     # 0x1c618
callq 0x4310
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x6cdc
movq 0x18(%rsp), %rdi
callq 0x4100
movq %rax, %rcx
leaq 0x1564d(%rip), %rdi     # 0x1c316
movl $0x28, %esi
leaq 0x15655(%rip), %rdx     # 0x1c32a
movb $0x0, %al
callq 0x1b800
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x6d21
movq 0x202e9(%rip), %rax     # 0x26fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4100
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x1562c(%rip), %rsi     # 0x1c33c
movb $0x0, %al
callq 0x4430
movl $0x1, %edi
callq 0x4330
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: loadzero[P]geoloc/geoloc/pipeline.hpp
// Function: FileReader::~FileReader()
virtual ~FileReader()
    {
        if (file_ && file_ != stdin)
        {
            fclose(file_);
        }

        if (buffer_)
        {
            free(buffer_);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1f676(%rip), %rcx     # 0x269e0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x20(%rax)
je 0x739b
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x1fc48(%rip), %rcx     # 0x26fd0
cmpq (%rcx), %rax
je 0x739b
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x4290
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x73b5
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x4320
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: loadzero[P]geoloc/geoloc/blocks.hpp
// Function: BlockParser::consume(Buffer const&)
void consume(const Buffer &b)
    {
        line_++;
        if (line_ < 3) return;

        csv_split((const char*) b.data(), b.size(), scratch_, toks_);

        if (toks_.size() != 3)
        {
            // we just silently drop bad lines
            return;
        }

        Block block;

        block.start_ip = to_u(toks_[0]);
        block.end_ip = to_u(toks_[1]);
        block.loc = to_u(toks_[2]);

        emit(Buffer(&block, sizeof(block)));
    }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
cmpq $0x3, 0x48(%rax)
jae 0x7550
jmp 0x762f
movq 0x58(%rsp), %rdi
callq 0x78d0
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
callq 0x78e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq %rax, %rsi
movq %rcx, %rdx
addq $0x10, %rdx
addq $0x30, %rcx
callq 0x7740
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
callq 0x78f0
cmpq $0x3, %rax
je 0x759f
jmp 0x762f
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x7930
movq (%rax), %rdi
callq 0x7910
movq 0x8(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movl $0x1, %esi
callq 0x7930
movq (%rax), %rdi
callq 0x7910
movq 0x8(%rsp), %rdi
movl %eax, 0x50(%rsp)
movl $0x2, %esi
callq 0x7930
movq (%rax), %rdi
callq 0x7910
movl %eax, 0x54(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x4c(%rsp), %rsi
movl $0xc, %edx
callq 0x7950
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
jmp 0x7625
leaq 0x38(%rsp), %rdi
callq 0x7980
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x7980
jmp 0x764e
jmp 0x7650
movq 0x30(%rsp), %rdi
callq 0x44d0
movq %rax, %rdi
callq 0x5b40
nopw %cs:(%rax,%rax)
nopl (%rax)