LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jianxinzhou[P]Smart/./include/MyCondition.h
// Function: MyCondition::MyCondition(MyLock&)
MyCondition(MyLock& lock)
            : m_mutex(lock.m_mutex)
        {
            if( pthread_cond_init(&m_cond, NULL))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ": " 
                          << "pthread_cond_init failed!" << std::endl;
                exit (-1);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3370
cmpl $0x0, %eax
je 0x97a3
movq 0x138c8(%rip), %rdi     # 0x1cfd0
leaq 0x9904(%rip), %rsi      # 0x13013
callq 0x32c0
movq %rax, %rdi
leaq 0x9b05(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x98f2(%rip), %rsi      # 0x1301f
callq 0x32c0
movq %rax, %rdi
leaq 0x9ae7(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x99a3(%rip), %rsi      # 0x130ee
callq 0x32c0
movq %rax, %rdi
leaq 0x9ac9(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
movl $0xe, %esi
callq 0x3520
movq %rax, %rdi
leaq 0x9aac(%rip), %rsi      # 0x13222
callq 0x32c0
movq %rax, %rdi
leaq 0x9981(%rip), %rsi      # 0x13106
callq 0x32c0
movq %rax, %rdi
movq 0x13824(%rip), %rsi     # 0x1cfb8
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::Thread()
Thread()
            :threadId_(0),isRunning_(false)
        {
            if(pthread_attr_init(&threadAttr))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_init" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x12ca1(%rip), %rax     # 0x1cd18
addq $0x10, %rax
movq %rax, (%rdi)
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
addq $0x20, %rdi
callq 0x3390
cmpl $0x0, %eax
je 0xa13e
movq 0x12f2d(%rip), %rdi     # 0x1cfd0
leaq 0x8f69(%rip), %rsi      # 0x13013
callq 0x32c0
movq %rax, %rdi
leaq 0x916a(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x8f57(%rip), %rsi      # 0x1301f
callq 0x32c0
movq %rax, %rdi
leaq 0x914c(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x8fb5(%rip), %rsi      # 0x1309b
callq 0x32c0
movq %rax, %rdi
leaq 0x912e(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
movl $0xf, %esi
callq 0x3520
movq %rax, %rdi
leaq 0x9130(%rip), %rsi      # 0x13241
callq 0x32c0
movq %rax, %rdi
leaq 0x8f8e(%rip), %rsi      # 0x130ae
callq 0x32c0
movq %rax, %rdi
movq 0x12e89(%rip), %rsi     # 0x1cfb8
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: jianxinzhou[P]Smart/./include/Thread.h
// Function: Thread::start(void*)
void start(void* arg = NULL)
        {
            if(isRunning_)
                return;
			
            m_arg = arg ;
            isRunning_ = true ;
            
            // 将线程设置为detach
            if(pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_attr_setdetachstate" << std::endl ;
                exit(-1) ;
            }
            
            // 创建线程
            if(pthread_create(&threadId_, &threadAttr, Thread::runInThread, this))
            {
                std::cout << __DATE__ << " " << __TIME__ << " " 
                          << __FILE__ << " " << __LINE__ << ":" 
                          << "pthread_create" << std::endl;
                exit(-1) ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x10(%rax)
je 0xc083
jmp 0xc215
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x20, %rdi
movl $0x1, %esi
callq 0x33f0
cmpl $0x0, %eax
je 0xc14c
movq 0x10f1f(%rip), %rdi     # 0x1cfd0
leaq 0x6f5b(%rip), %rsi      # 0x13013
callq 0x32c0
movq %rax, %rdi
leaq 0x715c(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x6f49(%rip), %rsi      # 0x1301f
callq 0x32c0
movq %rax, %rdi
leaq 0x713e(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x6fa7(%rip), %rsi      # 0x1309b
callq 0x32c0
movq %rax, %rdi
leaq 0x7120(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
movl $0x26, %esi
callq 0x3520
movq %rax, %rdi
leaq 0x7122(%rip), %rsi      # 0x13241
callq 0x32c0
movq %rax, %rdi
leaq 0x7021(%rip), %rsi      # 0x1314f
callq 0x32c0
movq %rax, %rdi
movq 0x10e7b(%rip), %rsi     # 0x1cfb8
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
movq -0x18(%rbp), %rcx
movq %rcx, %rdi
addq $0x18, %rdi
movq %rcx, %rsi
addq $0x20, %rsi
leaq 0xfb(%rip), %rdx        # 0xc260
callq 0x3550
cmpl $0x0, %eax
je 0xc215
movq 0x10e56(%rip), %rdi     # 0x1cfd0
leaq 0x6e92(%rip), %rsi      # 0x13013
callq 0x32c0
movq %rax, %rdi
leaq 0x7093(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x6e80(%rip), %rsi      # 0x1301f
callq 0x32c0
movq %rax, %rdi
leaq 0x7075(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
leaq 0x6ede(%rip), %rsi      # 0x1309b
callq 0x32c0
movq %rax, %rdi
leaq 0x7057(%rip), %rsi      # 0x13223
callq 0x32c0
movq %rax, %rdi
movl $0x2f, %esi
callq 0x3520
movq %rax, %rdi
leaq 0x7059(%rip), %rsi      # 0x13241
callq 0x32c0
movq %rax, %rdi
leaq 0x6f74(%rip), %rsi      # 0x1316b
callq 0x32c0
movq %rax, %rdi
movq 0x10db2(%rip), %rsi     # 0x1cfb8
callq 0x3310
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3380
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jianxinzhou[P]Smart/./src/MyThread.cpp
// Function: MyThread::run()
void MyThread::run()
{
	std::cout << "run" << std::endl ;
	cache_.read_from_file( (threadPoolPtr_ -> conf_).getMapConf()["my_cache"].c_str());
	while(true)
	{
        MyTask task(threadPoolPtr_-> conf_) ;
        if(!(threadPoolPtr_ -> get_task(task)) )
        {
            break ;
        }
        task.excute(cache_) ;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq 0xf91f(%rip), %rdi      # 0x1cfd0
leaq 0x5b15(%rip), %rsi      # 0x131cd
callq 0x32c0
movq %rax, %rdi
movq 0xf8f1(%rip), %rsi      # 0x1cfb8
callq 0x3310
movq -0xf0(%rbp), %rax
movq %rax, %rcx
addq $0x60, %rcx
movq %rcx, -0xe8(%rbp)
movq 0x58(%rax), %rax
movq (%rax), %rdi
callq 0xdbb0
movq %rax, -0xe0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3540
movq -0xd8(%rbp), %rdx
leaq 0x5abf(%rip), %rsi      # 0x131d1
leaq -0x48(%rbp), %rdi
callq 0x3410
jmp 0xd71d
movq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4df0
movq %rax, -0xf8(%rbp)
jmp 0xd736
movq -0xf8(%rbp), %rdi
callq 0x3150
movq %rax, -0x108(%rbp)
leaq -0x5d(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3540
movq -0x108(%rbp), %rsi
movq -0x100(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x3410
jmp 0xd772
movq -0xe8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xd8e0
jmp 0xd784
leaq -0x28(%rbp), %rdi
callq 0x31f0
leaq -0x5d(%rbp), %rdi
callq 0x3320
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x49(%rbp), %rdi
callq 0x3320
movq -0xf0(%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax), %rsi
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0xdbd0
movq -0xf0(%rbp), %rax
movq -0x118(%rbp), %rsi
movq 0x58(%rax), %rdi
callq 0xdca0
movb %al, -0x109(%rbp)
jmp 0xd7e8
movb -0x109(%rbp), %al
testb $0x1, %al
jne 0xd87d
jmp 0xd7f8
movl $0x3, -0xcc(%rbp)
jmp 0xd8a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd858
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd84f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd846
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31f0
leaq -0x5d(%rbp), %rdi
callq 0x3320
leaq -0x48(%rbp), %rdi
callq 0x31f0
leaq -0x49(%rbp), %rdi
callq 0x3320
jmp 0xd8c8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4bb0
jmp 0xd8c8
movq -0xf0(%rbp), %rsi
addq $0x60, %rsi
leaq -0xc8(%rbp), %rdi
callq 0xfd90
jmp 0xd896
movl $0x0, -0xcc(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4bb0
movl -0xcc(%rbp), %eax
testl %eax, %eax
je 0xd8ba
jmp 0xd8b8
jmp 0xd8bf
jmp 0xd7a8
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: jianxinzhou[P]Smart/./include/ThreadPool.h
// Function: ThreadPool::get_task(MyTask&)
bool get_task(MyTask &task)
        {
            queueTaskslock_.lock();
            while(isStarted_ && queueTasks_.empty())
            {
                queueTasksCond_.wait();
            }
            if(!isStarted_)
            { 
                queueTaskslock_.unlock();
                queueTasksCond_.broadcast();
                return false ;
            }
            task = queueTasks_.front();
            queueTasks_.pop();
            queueTaskslock_.unlock();
            queueTasksCond_.broadcast();
            std::cout << "get task" << std::endl ;
            return true ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x70, %rdi
callq 0xc390
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0xd0(%rcx)
movb %al, -0x21(%rbp)
je 0xdce3
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0xef50
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xdcec
jmp 0xdcfe
movq -0x20(%rbp), %rdi
addq $0x98, %rdi
callq 0xef70
jmp 0xdcc1
movq -0x20(%rbp), %rax
testb $0x1, 0xd0(%rax)
jne 0xdd2e
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0xc3e0
movq -0x20(%rbp), %rdi
addq $0x98, %rdi
callq 0xc400
movb $0x0, -0x1(%rbp)
jmp 0xdd97
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0xefa0
movq %rax, %rsi
movq -0x18(%rbp), %rdi
callq 0xefc0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
callq 0xf020
movq -0x20(%rbp), %rdi
addq $0x70, %rdi
callq 0xc3e0
movq -0x20(%rbp), %rdi
addq $0x98, %rdi
callq 0xc400
movq 0xf258(%rip), %rdi      # 0x1cfd0
leaq 0x547f(%rip), %rsi      # 0x131fe
callq 0x32c0
movq %rax, %rdi
movq 0xf22a(%rip), %rsi      # 0x1cfb8
callq 0x3310
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::get_result()
void MyTask::get_result()
{
	std::string ch ;
	int index ;
	for(index = 0 ; index != queryWord_.size(); index ++ )
	{
		if(queryWord_[index] & (1 << 7))
		{
			ch = queryWord_.substr(index, 2) ;
			index ++ ;
		}else 
		{
			ch = queryWord_.substr(index, 1);
		}
		if( ( *mapIndexPtr_ ).count(ch) )
		{
			std::cout << "map_ cout return true " << std::endl ;
			satistic( (*mapIndexPtr_)[ch] ) ;
		}
	} 

	/*
	   std::cout <<__FILE__<<std::endl ;
	//	for_each((*m_dict).begin(), (*m_dict).end(), satistic );
	std::map<std::string , int>::iterator iter = (*m_dict).begin() ;
	//int line = 0 ;
	while(iter != (*m_dict).end())
	{
	//std::cout << "dict word: " << iter -> first << std::endl ;
	//std::cout <<"_________" << ++line << "_________________"<< std::endl ;
	satistic(*iter);
	iter ++ ;
	}
	*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3420
movl $0x0, -0x2c(%rbp)
movq -0x88(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0x3220
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
je 0x10347
movq -0x88(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x3590
movq %rax, -0x98(%rbp)
jmp 0x1020d
movq -0x98(%rbp), %rax
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10277
movq -0x88(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
leaq -0x60(%rbp), %rdi
movl $0x2, %ecx
callq 0x32f0
jmp 0x1023c
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x33a0
leaq -0x60(%rbp), %rdi
callq 0x31f0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x102a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31f0
jmp 0x10359
movq -0x88(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movl $0x1, %ecx
callq 0x32f0
jmp 0x10292
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x33a0
leaq -0x80(%rbp), %rdi
callq 0x31f0
movq -0x88(%rbp), %rax
movq 0x40(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10e00
movq %rax, -0xa0(%rbp)
jmp 0x102c5
movq -0xa0(%rbp), %rax
cmpq $0x0, %rax
je 0x10337
movq 0xccf7(%rip), %rdi      # 0x1cfd0
leaq 0x2fa4(%rip), %rsi      # 0x13284
callq 0x32c0
movq %rax, -0xa8(%rbp)
jmp 0x102ee
movq -0xa8(%rbp), %rdi
movq 0xccbc(%rip), %rsi      # 0x1cfb8
callq 0x3310
jmp 0x10303
movq -0x88(%rbp), %rax
movq 0x40(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x73d0
movq %rax, -0xb0(%rbp)
jmp 0x10320
movq -0xb0(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x10880
jmp 0x10335
jmp 0x10337
jmp 0x10339
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x101ca
leaq -0x28(%rbp), %rdi
callq 0x31f0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3530
nopw %cs:(%rax,%rax)
// File: jianxinzhou[P]Smart/./src/MyTask.cpp
// Function: MyTask::satistic(std::set<int, std::less<int>, std::allocator<int>>&)
void MyTask::satistic(std::set<int> & iset)
{
	std::set<int>::iterator iter ;
	for( iter = iset.begin() ;  iter != iset.end() ;  iter ++)
	{
		int dist = editdistance(  ((*vecDictPtr_)[ *iter ]).first  );
			if(dist < 3)
			{
				MyResult res ;
				res.word_ = ((*vecDictPtr_)[ *iter ]).first ;
				res.distance_ = dist ;
				res.frequence_ = ((*vecDictPtr_)[ *iter ]).second ; 
				result_.push( res );
			}
	}
	/*
	   std::cout << __LINE__ <<std::endl ;
	   std::cout << "value::first :" << value.first << std::endl ;
	   int dist = editdistance( value.first);
	   if(dist < 3)
	   {
	   MyResult res ;
	   res.m_word = value.first ;
	   res.m_frequence = value.second ;
	   res.m_dist = dist ;
	   m_result.push( res );
	   }
	   */
}

// 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)
leaq -0x18(%rbp), %rdi
callq 0x10c70
movq -0x10(%rbp), %rdi
callq 0x10c90
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10cf0
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x10cc0
testb $0x1, %al
jne 0x108dc
jmp 0x109dc
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10d20
movq -0x80(%rbp), %rdi
movslq (%rax), %rsi
callq 0x73b0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x10370
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x109c6
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x10d50
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10d20
movq -0x90(%rbp), %rdi
movslq (%rax), %rsi
callq 0x73b0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x3050
jmp 0x1095e
movq -0x78(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, -0x34(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10d20
movq -0x98(%rbp), %rdi
movslq (%rax), %rsi
callq 0x73b0
movq -0x78(%rbp), %rdi
movl 0x20(%rax), %eax
movl %eax, -0x38(%rbp)
addq $0x48, %rdi
leaq -0x58(%rbp), %rsi
callq 0x10d70
jmp 0x109a4
leaq -0x58(%rbp), %rdi
callq 0xce30
jmp 0x109c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xce30
jmp 0x109e5
jmp 0x109c8
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x10dc0
movq %rax, -0x70(%rbp)
jmp 0x108b9
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3530
nop
// File: jianxinzhou[P]Smart/./include/MyTask.h
// Function: MyTask::length(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int length(const std::string& str) // 计算查询词的长度
        {
            int index ;
            int len = 0 ;
            for(index = 0 ; index != str.size(); index ++)
            {
                if(str[index] & (1 << 7))
                {
                    index ++ ;
                }
                len ++ ;
            }
            return len ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3220
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
je 0x10be2
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3340
movsbl (%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x10bce
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10b8e
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jianxinzhou[P]Smart/./include/MyCompare.h
// Function: MyCompare::operator()(MyResult const&, MyResult const&)
bool operator()(const MyResult& left, const MyResult& right)
        {
            if(left.distance_ > right.distance_)
            {
                return true ;
            }
            else if(left.distance_ == right.distance_ && 
                    left.frequence_ < right.frequence_)
            {
                return true ;
            }
            else if(left.distance_ == right.distance_ && 
                    left.frequence_ == right.frequence_ && 
                    left.word_ > right.word_)
            {
                return true ;
            }
            else 
            {
                return false ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jle 0x11eda
movb $0x1, -0x1(%rbp)
jmp 0x11f3d
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x11f00
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x11f00
movb $0x1, -0x1(%rbp)
jmp 0x11f3d
movq -0x18(%rbp), %rax
movl 0x24(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jne 0x11f39
movq -0x18(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jne 0x11f39
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11f50
testb $0x1, %al
jne 0x11f33
jmp 0x11f39
movb $0x1, -0x1(%rbp)
jmp 0x11f3d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jianxinzhou[P]Smart/./src/MyCacheThread.cpp
// Function: MyCacheThread::run()
void MyCacheThread::run()
{
	while(true)
	{
		sleep(60);
		scan_cache();	
		std::cout << "scan cache" << std::endl ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x3c, %edi
callq 0x3240
movq -0x10(%rbp), %rdi
callq 0x12220
movq 0xadd2(%rip), %rdi      # 0x1cfd0
leaq 0x1097(%rip), %rsi      # 0x1329c
callq 0x32c0
movq %rax, %rdi
movq 0xada4(%rip), %rsi      # 0x1cfb8
callq 0x3310
jmp 0x121e4
nopl (%rax,%rax)
// File: jianxinzhou[P]Smart/./src/MyCacheThread.cpp
// Function: MyCacheThread::get_related(ThreadPool*)
void MyCacheThread::get_related(ThreadPool* threadPoolPtr)
{
    threadPoolPtr_ = threadPoolPtr;
    
    std::vector<MyThread>::iterator  iter1  = (threadPoolPtr_ -> vecThreads_).begin();
    std::vector<MyThread*>::iterator iter2  = vecWorkThreadPtr_.begin() ;
    
    while(iter2 != vecWorkThreadPtr_.end() && 
          iter1 != (threadPoolPtr_ -> vecThreads_).end() )
    {
        *iter2 = &(*iter1);
        iter1++;
        iter2++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq 0x58(%rax), %rdi
addq $0x8, %rdi
callq 0x9870
movq -0x48(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x60, %rdi
callq 0x12680
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
callq 0x126f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x126b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x125fe
jmp 0x12623
movq -0x48(%rbp), %rax
movq 0x58(%rax), %rdi
addq $0x8, %rdi
callq 0x98e0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x98a0
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1262c
jmp 0x1266c
leaq -0x18(%rbp), %rdi
callq 0x12720
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x12740
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc220
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x12760
movq %rax, -0x40(%rbp)
jmp 0x125d2
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jianxinzhou[P]Smart/./include/MyCache.h
// Function: MyCache::write_to_file(std::basic_ofstream<char, std::char_traits<char>>&)
void write_to_file(std::ofstream& outfile)
        {
            hashmapLock_.lock();
            for(std::unordered_map<std::string, std::string>::iterator iter = hashmap_.begin(); 
                iter != hashmap_.end();
                ++iter)
            {
                outfile << iter -> first << "\t" << iter -> second << std::endl ;
            }
            hashmapLock_.unlock();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x38, %rdi
callq 0xc390
movq -0x28(%rbp), %rdi
callq 0x12890
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10a70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10a40
testb $0x1, %al
jne 0x127ee
jmp 0x12854
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10aa0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x32a0
movq %rax, %rdi
leaq 0xab1(%rip), %rsi       # 0x132c6
callq 0x32c0
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10aa0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x32a0
movq %rax, %rdi
movq 0xa777(%rip), %rsi      # 0x1cfb8
callq 0x3310
leaq -0x18(%rbp), %rdi
callq 0x128c0
jmp 0x127ce
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0xc3e0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./msutil.h
// Function: revbit32
static inline uint32_t revbit32(uint32_t u)
{
    u = ((u >> 1) & 0x55555555) | ((u & 0x55555555) << 1);
    u = ((u >> 2) & 0x33333333) | ((u & 0x33333333) << 2);
    u = ((u >> 4) & 0x0F0F0F0F) | ((u & 0x0F0F0F0F) << 4);
    return bswap_32(u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl -0x4(%rbp), %ecx
andl $0x55555555, %ecx       # imm = 0x55555555
shll %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x2, %eax
andl $0x33333333, %eax       # imm = 0x33333333
movl -0x4(%rbp), %ecx
andl $0x33333333, %ecx       # imm = 0x33333333
shll $0x2, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x4, %eax
andl $0xf0f0f0f, %eax        # imm = 0xF0F0F0F
movl -0x4(%rbp), %ecx
andl $0xf0f0f0f, %ecx        # imm = 0xF0F0F0F
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x4da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ctSkennerton[P]fxtract/util/./msutil.h
// Function: revbit64
static inline uint64_t revbit64(uint64_t u)
{
    u = ((u >> 1) & 0x5555555555555555ULL) | ((u & 0x5555555555555555ULL) << 1);
    u = ((u >> 2) & 0x3333333333333333ULL) | ((u & 0x3333333333333333ULL) << 2);
    u = ((u >> 4) & 0x0F0F0F0F0F0F0F0FULL) | ((u & 0x0F0F0F0F0F0F0F0FULL) << 4);
    return bswap_64(u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq %rax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
andq %rcx, %rax
movabsq $0x5555555555555555, %rcx # imm = 0x5555555555555555
andq -0x8(%rbp), %rcx
shlq %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x2, %rax
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
andq %rcx, %rax
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
andq -0x8(%rbp), %rcx
shlq $0x2, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x4, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0xf0f0f0f0f0f0f0f, %rcx # imm = 0xF0F0F0F0F0F0F0F
andq -0x8(%rbp), %rcx
shlq $0x4, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4de0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ctSkennerton[P]fxtract/util/ymd.c
// Function: ymd2day
int ymd2day(YMD x)
{
    if (x.mm > 2)  x.mm -= 3; else x.mm += 9, --x.yyyy;

    // This is sufficient back to 1500-03-01. 1753 is the start of Gregorian Calendar.
    int days = (x.yyyy*1461)/4 + (x.mm*979 + 17)/32 + x.dd - BASE_DATE;
    return days 
            + (days < -72871-3) + (days < -36465-2) + (days < 59-1) 
            - (days >  73107+1) - (days > 109631+2); // Mar 1 (1700,1800,1900,2100,2200)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x1c(%rbp)
movl %esi, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x2, -0x8(%rbp)
jbe 0x71aa
movl -0x8(%rbp), %eax
subl $0x3, %eax
movl %eax, -0x8(%rbp)
jmp 0x71bc
movl -0x8(%rbp), %eax
addl $0x9, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
imull $0x5b5, -0xc(%rbp), %eax # imm = 0x5B5
shrl $0x2, %eax
imull $0x3d3, -0x8(%rbp), %ecx # imm = 0x3D3
addl $0x11, %ecx
shrl $0x5, %ecx
addl %ecx, %eax
addl -0x4(%rbp), %eax
subl $0xa96d8, %eax          # imm = 0xA96D8
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl $0xfffee356, -0x20(%rbp) # imm = 0xFFFEE356
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
cmpl $0xffff718d, -0x20(%rbp) # imm = 0xFFFF718D
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
cmpl $0x3a, -0x20(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
cmpl $0x11d94, -0x20(%rbp)   # imm = 0x11D94
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
cmpl $0x1ac41, -0x20(%rbp)   # imm = 0x1AC41
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
popq %rbp
retq
nopl (%rax)
// File: ctSkennerton[P]fxtract/util/ymd.c
// Function: day2ymd
YMD day2ymd(int nDate)
{
    YMD		x;
    nDate -= -BASE_DATE
            + (nDate < -72871 ? 3 : nDate < -36465 ? 2 : nDate < 59 ? 1 : nDate > 109631 ? -2 : nDate > 73107 ? -1 : 0);

    x.yyyy = (nDate * 4  - 1)/ 1461;
    nDate -= (x.yyyy * 1461)/ 4;
    x.mm = (nDate * 32 - 17) / 979;
    x.dd = nDate - (x.mm * 979 + 17) / 32;

    if (x.mm > 9)   x.mm -= 9, ++x.yyyy; 
    else	    x.mm += 3;

    return  x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x10(%rbp)
cmpl $0xfffee359, -0x10(%rbp) # imm = 0xFFFEE359
jge 0x725a
movl $0x3, %eax
movl %eax, -0x24(%rbp)
jmp 0x72b8
cmpl $0xffff718f, -0x10(%rbp) # imm = 0xFFFF718F
jge 0x726d
movl $0x2, %eax
movl %eax, -0x28(%rbp)
jmp 0x72b2
cmpl $0x3b, -0x10(%rbp)
jge 0x727d
movl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x72ac
cmpl $0x1ac3f, -0x10(%rbp)   # imm = 0x1AC3F
jle 0x7290
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
movl %eax, -0x30(%rbp)
jmp 0x72a6
movl -0x10(%rbp), %edx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x11d93, %edx          # imm = 0x11D93
cmovgl %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
addl $0xfff56928, %ecx       # imm = 0xFFF56928
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x2, %eax
subl $0x1, %eax
movl $0x5b5, %ecx            # imm = 0x5B5
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
imull $0x5b5, -0xc(%rbp), %ecx # imm = 0x5B5
shrl $0x2, %ecx
movl -0x10(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0x5, %eax
subl $0x11, %eax
movl $0x3d3, %ecx            # imm = 0x3D3
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
imull $0x3d3, -0x8(%rbp), %ecx # imm = 0x3D3
addl $0x11, %ecx
shrl $0x5, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
cmpl $0x9, -0x8(%rbp)
jbe 0x7332
movl -0x8(%rbp), %eax
subl $0x9, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x733b
movl -0x8(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %edx
popq %rbp
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: d_logv(int, char const*, __va_list_tag*)
static void d_logv(int level, const char *format, va_list vl)
{
	char buffer[256];
	vsnprintf(buffer, sizeof(buffer), format, vl);

	if (use_syslog && past_init) {
		syslog(level, "%s",buffer);
	} else {
		char tbuf[64];
		timeval tv;
		gettimeofday(&tv, 0);

		/* Some FreeBSDs' tv.tv_sec isn't time_t */
		time_t tv_sec = tv.tv_sec;
		strftime(tbuf, sizeof(tbuf), "%b %d %H:%M:%S", localtime(&tv_sec));

		fprintf(stderr, "%s.%06u %s\n", tbuf, (uint32_t)tv.tv_usec, buffer);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x4280
testb $0x1, 0x246ff(%rip)     # 0x297f5
je 0x511e
testb $0x1, 0x246f7(%rip)     # 0x297f6
je 0x511e
movl -0x4(%rbp), %edi
leaq -0x120(%rbp), %rdx
leaq 0x16dbb(%rip), %rsi     # 0x1becd
movb $0x0, %al
callq 0x4090
jmp 0x51a0
leaq -0x170(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4690
movq -0x170(%rbp), %rax
movq %rax, -0x178(%rbp)
leaq -0x160(%rbp), %rax
movq %rax, -0x180(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x4310
movq -0x180(%rbp), %rdi
movq %rax, %rcx
movl $0x40, %esi
leaq 0x16dfc(%rip), %rdx     # 0x1bf68
callq 0x4370
movq 0x23e58(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq -0x160(%rbp), %rdx
movq -0x168(%rbp), %rax
movl %eax, %ecx
leaq -0x120(%rbp), %r8
leaq 0x16dde(%rip), %rsi     # 0x1bf77
movb $0x0, %al
callq 0x4600
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: fatal(char const*, ...)
void fatal(const char *format, ...)
{
	va_list vl;
	va_start(vl, format);
	d_logv(LOG_CRIT, format, vl);
	va_end(vl);
	exit(-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5285
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
movl $0x2, %edi
callq 0x50c0
leaq -0x20(%rbp), %rax
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4550
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: insert_event(unsigned int, unsigned int)
void insert_event(uint32_t type, uint32_t interval) {
	timer t;
	t.type = type;
	t.interval = interval;

	insert_sorted_event(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x6ae0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: sendLeaveReport
void sendLeaveReport(int) {
	send_report(LEAVE_REPORT);
	if (daemonize && pidfile)
		unlink(pidfile);
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x56, %edi
callq 0x63b0
testb $0x1, 0x230d8(%rip)     # 0x297f4
je 0x6734
cmpq $0x0, 0x230d2(%rip)     # 0x297f8
je 0x6734
movq 0x230c9(%rip), %rdi     # 0x297f8
callq 0x41f0
xorl %edi, %edi
callq 0x4550
nopl (%rax,%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: next_event(timeval*)
void next_event(timeval *eventm) {
	update_taccum();

	timer &h = *timers.begin();

	/* we assume we always have a timer in the list */
	if (taccum > h.target) {
		taccum -= h.target;
		h.target = 0;
	} else {
		h.target -= taccum;
		taccum = 0;
	}

	eventm->tv_sec = h.target / 1000;
	eventm->tv_usec = (h.target % 1000) * 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x8e00
leaq 0x231d0(%rip), %rdi     # 0x29928
callq 0xb020
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xf3e0
movq %rax, -0x10(%rbp)
movl 0x231d4(%rip), %eax     # 0x29948
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x679f
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0x231be(%rip), %eax     # 0x29948
subl %ecx, %eax
movl %eax, 0x231b6(%rip)     # 0x29948
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x67bb
movl 0x231a3(%rip), %edx     # 0x29948
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0x2318d(%rip)     # 0x29948
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divl %ecx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
movl %eax, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: handle_mcast(std::pair<int, void (*)(int, Message const&)> const&)
static void handle_mcast(const SocketDesc &desc)
{
	Message msg;
  
	int len = RecvMsg(desc.first, msg.from, msg.to, buffer, bufferLen, msg.ttl,
		msg.timestamp);
	if (len < 0)
		return;

	if (msg.from.is_equal(beaconUnicastAddr))
		return;

	msg.buffer = buffer;
	msg.len = len;

	if (verbose > 3) {
		char tmp[64];
		info("RecvMsg(%s): len = %u", msg.from.to_string(tmp, sizeof(tmp)), len);
	}

	desc.second(desc.first, msg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
leaq -0x128(%rbp), %rdi
callq 0xc8e0
movq -0x8(%rbp), %rax
movl (%rax), %edi
leaq -0x128(%rbp), %rsi
leaq -0x128(%rbp), %rdx
addq $0x80, %rdx
leaq -0x128(%rbp), %r9
addq $0x108, %r9             # imm = 0x108
leaq -0x128(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
leaq 0x23148(%rip), %rcx     # 0x299a0
movl $0x2000, %r8d           # imm = 0x2000
movq %rax, (%rsp)
callq 0x17600
movl %eax, -0x12c(%rbp)
cmpl $0x0, -0x12c(%rbp)
jge 0x687b
jmp 0x6900
leaq -0x128(%rbp), %rdi
leaq 0x22cdf(%rip), %rsi     # 0x29568
callq 0x18340
testb $0x1, %al
jne 0x6894
jmp 0x6896
jmp 0x6900
leaq 0x23103(%rip), %rax     # 0x299a0
movq %rax, -0x18(%rbp)
movslq -0x12c(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x3, 0x22d35(%rip)     # 0x295e8
jle 0x68e9
leaq -0x128(%rbp), %rdi
leaq -0x170(%rbp), %rsi
movl $0x40, %edx
movl $0x1, %ecx
callq 0x18100
movq %rax, %rsi
movl -0x12c(%rbp), %edx
leaq 0x156a1(%rip), %rdi     # 0x1bf83
movb $0x0, %al
callq 0x51b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl (%rcx), %edi
leaq -0x128(%rbp), %rsi
callq *%rax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: handle_event()
void handle_event() {
	update_taccum();

	while (!timers.empty()) {
		if (timers.begin()->target > taccum) {
			return;
		}

		taccum -= timers.begin()->target;

		handle_single_event();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8e00
leaq 0x23004(%rip), %rdi     # 0x29928
callq 0xb120
xorb $-0x1, %al
testb $0x1, %al
jne 0x6931
jmp 0x6988
leaq 0x22ff0(%rip), %rdi     # 0x29928
callq 0xb020
movq %rax, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0xb0b0
movl 0x8(%rax), %eax
cmpl 0x22ff5(%rip), %eax     # 0x29948
jbe 0x6957
jmp 0x6988
leaq 0x22fca(%rip), %rdi     # 0x29928
callq 0xb020
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xb0b0
movl 0x8(%rax), %ecx
movl 0x22fcf(%rip), %eax     # 0x29948
subl %ecx, %eax
movl %eax, 0x22fc7(%rip)     # 0x29948
callq 0x8e70
jmp 0x691d
addq $0x10, %rsp
popq %rbp
retq
nop
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: show_version()
void show_version() {
	fprintf(stderr, "\n");
	fprintf(stderr, "dbeacon - a Multicast Beacon %s\n", versionInfo);
	fprintf(stderr, "\n");
	fprintf(stderr, "  Copyright (c) 2005-7, Hugo Santos <hugo@fivebits.net>\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "  http://fivebits.net/proj/dbeacon\n");
	fprintf(stderr, "\n");
	fprintf(stderr, "  o Ideas, IPv4 port, SSM pushing by Hoerdt Mickael;\n");
	fprintf(stderr, "  o Ideas and testing by Sebastien Chaumontet;\n");
	fprintf(stderr, "  o SSM Ping originaly by Stig Venaas\n");
	fprintf(stderr, "    - first proposed by Pavan Namburi, Kamil Sarac and Kevin C. Almeroth;\n");
	fprintf(stderr, "  o Bernhard Schmidt provided valuable resources and helped during testing.\n");
	fprintf(stderr, "\n");

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x22635(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x14999(%rip), %rsi     # 0x1b33e
movb $0x0, %al
callq 0x4600
movq 0x2261d(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x152df(%rip), %rsi     # 0x1bc9c
leaq 0x152f9(%rip), %rdx     # 0x1bcbd
movb $0x0, %al
callq 0x4600
movq 0x225fe(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x14962(%rip), %rsi     # 0x1b33e
movb $0x0, %al
callq 0x4600
movq 0x225e6(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x152d9(%rip), %rsi     # 0x1bccd
movb $0x0, %al
callq 0x4600
movq 0x225ce(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x14932(%rip), %rsi     # 0x1b33e
movb $0x0, %al
callq 0x4600
movq 0x225b6(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x152e2(%rip), %rsi     # 0x1bd06
movb $0x0, %al
callq 0x4600
movq 0x2259e(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x14902(%rip), %rsi     # 0x1b33e
movb $0x0, %al
callq 0x4600
movq 0x22586(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x152d6(%rip), %rsi     # 0x1bd2a
movb $0x0, %al
callq 0x4600
movq 0x2256e(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x152f4(%rip), %rsi     # 0x1bd60
movb $0x0, %al
callq 0x4600
movq 0x22556(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x1530c(%rip), %rsi     # 0x1bd90
movb $0x0, %al
callq 0x4600
movq 0x2253e(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x1531b(%rip), %rsi     # 0x1bdb7
movb $0x0, %al
callq 0x4600
movq 0x22526(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x1534e(%rip), %rsi     # 0x1be02
movb $0x0, %al
callq 0x4600
movq 0x2250e(%rip), %rax     # 0x28fd0
movq (%rax), %rdi
leaq 0x14872(%rip), %rsi     # 0x1b33e
movb $0x0, %al
callq 0x4600
movl $0x1, %edi
callq 0x4550
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: insert_sorted_event(timer&)
void insert_sorted_event(timer &t) {
	uint32_t accum = 0;

	tq_def::iterator i = timers.begin();

	while (1) {
		if (i == timers.end() || (accum + i->target) >= t.interval)
			break;
		accum += i->target;
		++i;
	}

	t.target = t.interval - accum;

	if (i != timers.end())
		i->target -= t.target;

	if (timers.empty()) {
		lastclk = get_timestamp();
		taccum = 0;
	}

	timers.insert(i, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x22e2e(%rip), %rdi     # 0x29928
callq 0xb020
movq %rax, -0x18(%rbp)
leaq 0x22e1e(%rip), %rdi     # 0x29928
callq 0xb080
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb050
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x39(%rbp)
jne 0x6b51
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb0b0
movq %rax, %rcx
movl -0x40(%rbp), %eax
addl 0x8(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setae %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6b5a
jmp 0x6b5c
jmp 0x6b79
leaq -0x18(%rbp), %rdi
callq 0xb0b0
movl 0x8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb0d0
jmp 0x6b03
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
leaq 0x22d97(%rip), %rdi     # 0x29928
callq 0xb080
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb0f0
testb $0x1, %al
jne 0x6bad
jmp 0x6bcb
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb0b0
movl -0x44(%rbp), %edx
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
leaq 0x22d56(%rip), %rdi     # 0x29928
callq 0xb120
testb $0x1, %al
jne 0x6bdd
jmp 0x6bf3
callq 0x184e0
movq %rax, 0x22d57(%rip)     # 0x29940
movl $0x0, 0x22d55(%rip)     # 0x29948
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xb1b0
movq -0x8(%rbp), %rdx
movq -0x30(%rbp), %rsi
leaq 0x22d19(%rip), %rdi     # 0x29928
callq 0xb140
movq %rax, -0x38(%rbp)
addq $0x50, %rsp
popq %rbp
retq
nop
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: Stats::Stats()
Stats::Stats() {
	valid = false;
	timestamp = lastupdate = 0;
	avgdelay = avgjitter = avgloss = avgdup = avgooo = 0;
	rttl = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x24(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x20(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x1c(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x18(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x14(%rax)
xorps %xmm0, %xmm0
movss %xmm0, 0x10(%rax)
movb $0x0, 0x25(%rax)
popq %rbp
retq
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: removeSource(address const&, bool)
void removeSource(const address &baddr, bool timeout) {
	Sources::iterator i = sources.find(baddr);
	if (i != sources.end()) {
		if (verbose) {
			char tmp[64];

			if (i->second.identified) {
				info("Removing source %s [%s]%s",
					baddr.to_string(tmp, sizeof(tmp)), i->second.name.c_str(),
					(timeout ? " by Timeout" : ""));
			} else {
				info("Removing source %s%s",
					baddr.to_string(tmp, sizeof(tmp)), (timeout ? " by Timeout" : ""));
			}
		}

		if (IsSSMEnabled())
			CountSSMLeave(ssmProbeAddr, baddr);

		sources.erase(i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x221d6(%rip), %rdi     # 0x29508
callq 0xb210
movq %rax, -0x18(%rbp)
leaq 0x221c6(%rip), %rdi     # 0x29508
callq 0xb270
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb240
testb $0x1, %al
jne 0x7361
jmp 0x7464
cmpl $0x0, 0x22280(%rip)     # 0x295e8
je 0x742d
leaq -0x18(%rbp), %rdi
callq 0xb2a0
testb $0x1, 0x3d8(%rax)
je 0x73eb
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
movl $0x1, %ecx
callq 0x18100
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb2a0
movq %rax, %rdi
addq $0x80, %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0x41b0
movq -0x78(%rbp), %rsi
movq %rax, %rdx
movb -0x9(%rbp), %dil
leaq 0x13f73(%rip), %rcx     # 0x1b33f
leaq 0x14abd(%rip), %rax     # 0x1be90
testb $0x1, %dil
cmovneq %rax, %rcx
leaq 0x14a94(%rip), %rdi     # 0x1be76
movb $0x0, %al
callq 0x51b0
jmp 0x742b
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x40, %edx
movl $0x1, %ecx
callq 0x18100
movq %rax, %rsi
movb -0x9(%rbp), %cl
leaq 0x13f30(%rip), %rdx     # 0x1b33f
leaq 0x14a7a(%rip), %rax     # 0x1be90
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x14a78(%rip), %rdi     # 0x1be9c
movb $0x0, %al
callq 0x51b0
jmp 0x742d
callq 0x6120
testb $0x1, %al
jne 0x7438
jmp 0x7448
movq -0x8(%rbp), %rsi
leaq 0x22275(%rip), %rdi     # 0x296b8
callq 0x7470
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
leaq 0x220ad(%rip), %rdi     # 0x29508
callq 0xb450
movq %rax, -0x70(%rbp)
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: hugosantos[P]dbeacon/dbeacon.cpp
// Function: beaconSource::getExternal(address const&, unsigned long, unsigned long)
beaconExternalStats &beaconSource::getExternal(const address &baddr, uint64_t now, uint64_t ts) {
	ExternalSources::iterator k = externalSources.find(baddr);
	if (k == externalSources.end()) {
		externalSources.insert(make_pair(baddr, beaconExternalStats()));
		k = externalSources.find(baddr);

		k->second.age = 0;

		if (verbose) {
			char tmp[64];
			info("Adding external source (%s) %s", name.c_str(), baddr.to_string(tmp, sizeof(tmp)));
		}
	}

	beaconExternalStats &stats = k->second;

	stats.lastupdate = now;

	return stats;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2b0, %rsp            # imm = 0x2B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x280(%rbp)
addq $0x2f8, %rdi            # imm = 0x2F8
movq -0x10(%rbp), %rsi
callq 0xb4b0
movq -0x280(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0xb510
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb4e0
testb $0x1, %al
jne 0x7957
jmp 0x7ad2
movq -0x280(%rbp), %rax
addq $0x2f8, %rax            # imm = 0x2F8
movq %rax, -0x298(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x290(%rbp)
leaq -0x200(%rbp), %rdi
movq %rdi, -0x288(%rbp)
callq 0x6d30
movq -0x290(%rbp), %rsi
movq -0x288(%rbp), %rdx
leaq -0x158(%rbp), %rdi
callq 0xb580
jmp 0x79a5
movq -0x298(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0xb540
movb %dl, -0x2a1(%rbp)
movq %rax, -0x2a0(%rbp)
jmp 0x79c7
movb -0x2a1(%rbp), %al
movq -0x2a0(%rbp), %rcx
movq %rcx, -0x220(%rbp)
movb %al, -0x218(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xb5c0
leaq -0x200(%rbp), %rdi
callq 0xb5f0
movq -0x280(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
movq -0x10(%rbp), %rsi
callq 0xb4b0
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb630
movl $0x0, 0x88(%rax)
cmpl $0x0, 0x21bac(%rip)     # 0x295e8
je 0x7ad0
movq -0x280(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
callq 0x41b0
movq %rax, -0x2b0(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x270(%rbp), %rsi
movl $0x40, %edx
movl $0x1, %ecx
callq 0x18100
movq -0x2b0(%rbp), %rsi
movq %rax, %rdx
leaq 0x1442a(%rip), %rdi     # 0x1beb1
movb $0x0, %al
callq 0x51b0
jmp 0x7ad0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
jmp 0x7ac2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x208(%rbp)
movl %eax, -0x20c(%rbp)
leaq -0x158(%rbp), %rdi
callq 0xb5c0
leaq -0x200(%rbp), %rdi
callq 0xb5f0
jmp 0x7b06
jmp 0x7ad2
leaq -0x28(%rbp), %rdi
callq 0xb630
addq $0x80, %rax
movq %rax, -0x278(%rbp)
movq -0x18(%rbp), %rcx
movq -0x278(%rbp), %rax
movq %rcx, (%rax)
movq -0x278(%rbp), %rax
addq $0x2b0, %rsp            # imm = 0x2B0
popq %rbp
retq
movq -0x208(%rbp), %rdi
callq 0x46f0
nopw %cs:(%rax,%rax)