LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/dns/DNSCache.cpp
// Function: DNSCache::DNS(char*, char*)
struct sockaddr_in* DNSCache::DNS(  char *host , char *port)
{
	struct sockaddr_in *saddr = NULL;

	if ( host == NULL || port == NULL)
	{
		return NULL;
	}
	pthread_mutex_lock(&lock);
	if ((saddr = (struct sockaddr_in*)hl.get( host ))== NULL)
	{
		saddr = dns( host , port );
		if (saddr != NULL )
		{
			hl.set(host,saddr);
			//------debug
			puts("DNS CaCHED!");
			pthread_mutex_unlock(&lock);
			return saddr;
		}
		pthread_mutex_unlock(&lock);
		return NULL;
	}
	else
	{
		puts("Get Cache");
		pthread_mutex_unlock(&lock);
		return saddr;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8aa2
cmpq $0x0, -0x20(%rbp)
jne 0x8aaf
movq $0x0, -0x8(%rbp)
jmp 0x8b53
leaq 0xbb56a(%rip), %rdi     # 0xc4020
callq 0x8410
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8b80
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x8b33
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xb550
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8b1d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x8bb0
leaq 0x99526(%rip), %rdi     # 0xa2028
callq 0x8470
leaq 0xbb512(%rip), %rdi     # 0xc4020
callq 0x81f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8b53
leaq 0xbb4fc(%rip), %rdi     # 0xc4020
callq 0x81f0
movq $0x0, -0x8(%rbp)
jmp 0x8b53
leaq 0x994fa(%rip), %rdi     # 0xa2034
callq 0x8470
leaq 0xbb4da(%rip), %rdi     # 0xc4020
callq 0x81f0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Download/./../URL/URL.h
// Function: URL::setStateToDB(int)
int setStateToDB( int state )
	{
		char buf[1024] = { 0 };
		Persistence *db = Persistence::getPersistence();
		sprintf(buf,"update url set state=%d where id=%d",state,this->id);
		db->exec(buf);
	
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x8160
callq 0x9f10
movq %rax, %rcx
movq -0x420(%rbp), %rax
movq %rcx, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
movl -0xc(%rbp), %edx
movl (%rax), %ecx
leaq 0x98ef6(%rip), %rsi     # 0xa20bf
movb $0x0, %al
callq 0x8080
movq -0x418(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa010
ud2
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HTTP/./HTTP.cpp
// Function: isHex(char*)
int isHex( char *num)
{
	while( *num != '\r' )
	{
		if ( *num >='0' && *num <= '9' || *num >= 'a' && *num <='f' ||*num>='A' && *num <='F')
		{
			;
		}else
		{
			return 0;
		}
		num++;
	}
	if ( *(num+1) == '\n')
	{
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
je 0x92c5
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x927c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x92ac
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jl 0x9294
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x66, %eax
jle 0x92ac
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jl 0x92ae
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x46, %eax
jg 0x92ae
jmp 0x92b7
movl $0x0, -0x4(%rbp)
jmp 0x92e2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9258
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0xa, %eax
jne 0x92db
movl $0x1, -0x4(%rbp)
jmp 0x92e2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HTTP/./HTTP.cpp
// Function: HTTP::~HTTP()
HTTP::~HTTP()
{
	if ( this->body != NULL )
	{
		pthread_mutex_lock(&lock);
		free( this->body );
		pthread_mutex_unlock(&lock);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x9690
leaq 0xba9d6(%rip), %rdi     # 0xc4048
callq 0x8410
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8320
leaq 0xba9bd(%rip), %rdi     # 0xc4048
callq 0x81f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Hex2I/./Hex2I.c
// Function: hex2i
int hex2i( const char *hex )
{
	int ret = 0;
	int index = strlen( hex ) - 1;
	int temp = 0;
	int per = 1;
	int i;
	for( i = index; i>= 0; i--)
	{
		if( hex[i] >= 'a' && hex[i] <= 'f' )
		{
			temp = hex[i] - 'a' + 10;
		}
		else if ( hex[i] >= 'A' && hex[i] <= 'F' )
		{
			temp = hex[i] - 'A' + 10;
		}
		else if ( hex[i] >= '0' && hex[i] <= '9' )
		{
			temp = hex[i] - '0';	
		}
		else
		{
			ret = 0;
			per = 1;
			continue;
		}
		ret += ( per * temp );
		per*=16;
		
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8120
subq $0x1, %rax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x9814
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x61, %eax
jl 0x976d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
jg 0x976d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x14(%rbp)
jmp 0x97f0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x97a6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0x97a6
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x14(%rbp)
jmp 0x97ee
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x97dc
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jg 0x97dc
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
jmp 0x97ec
movl $0x0, -0xc(%rbp)
movl $0x1, -0x18(%rbp)
jmp 0x9806
jmp 0x97ee
jmp 0x97f0
movl -0x18(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x18(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9727
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Download/./../URL/URL.h
// Function: URL::URL()
URL()
	{
		id = 0;
		urlStr = NULL;
		type = 0;
		deep = 0;
		state = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Download/./../URL/URL.h
// Function: URL::setURLStr(char const*)
int setURLStr( const char *str)
	{
		int length = strlen( str ) + 1;
		urlStr = new char[length];
		if ( urlStr == NULL )
		{	
			return -1;
		}
		sprintf( urlStr,"%s",str);
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8120
addq $0x1, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x8040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x9bbc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9bdd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x9d22d(%rip), %rsi     # 0xa6dfc
movb $0x0, %al
callq 0x8080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Download/./../URL/URL.h
// Function: URL::save()
int save()
	{
		char buf[1024] = { 0 };
		Persistence *db = Persistence::getPersistence();
		sprintf(buf,"insert into url(urlstr,type,deep) values('%s',%d,%d)",this->urlStr,this->type,this->deep);
		db->exec(buf);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x8160
callq 0x9f10
movq %rax, %rcx
movq -0x420(%rbp), %rax
movq %rcx, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
movq 0x8(%rax), %rdx
movl 0x10(%rax), %ecx
movl 0x14(%rax), %r8d
leaq 0x984da(%rip), %rsi     # 0xa2146
movb $0x0, %al
callq 0x8080
movq -0x418(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0xa010
ud2
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/ModelTool/ModelTool.cpp
// Function: Model::Model(char const*)
Model::Model( const char *filename )
{
	output = NULL;
	this->handle = dlopen( filename , RTLD_NOW );
	if ( this->handle == NULL )
	{
		puts(dlerror());
	}
}

// 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)
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x83d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x9d9b
callq 0x82a0
movq %rax, %rdi
callq 0x8470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/ModelTool/ModelTool.cpp
// Function: Model::getMethod(char const*)
OUTPUTFUNC Model::getMethod( const char *funcName )
{
	output = (OUTPUTFUNC)dlsym( this->handle, funcName);
	if ( output == NULL  )
	{
		puts("getMethod Error``````````````");
	}
	return output;
}

// 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)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x8538
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x9e22
leaq 0x9836a(%rip), %rdi     # 0xa2187
callq 0x8470
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Persistence/Persistence.cpp
// Function: Persistence::Persistence(char const*)
Persistence::Persistence( const char *dbfile )
{
	int ret;	
	unlink(dbfile);//remove old dbfile

//	this->lock = PTHREAD_MUTEX_INITIALIZER; 
	pthread_mutex_init( &(this->lock) , NULL );
	ret = sqlite3_open( dbfile , &(this->db) );
	if ( ret != SQLITE_OK )
	{
		mylog( ERROR , "create database error");
		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, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8140
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8440
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x28, %rsi
callq 0x1f200
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9f03
movl $0x2, %edi
leaq 0x982b8(%rip), %rsi     # 0xa21ac
callq 0xbdb0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x8340
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Persistence/Persistence.cpp
// Function: Persistence::~Persistence()
Persistence::~Persistence()
{
	if (this->err != NULL )
		sqlite3_free( this->err );

	sqlite3_close( this->db );

	delete pdb;
	
	pthread_mutex_destroy(&(this->lock));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x30(%rax)
je 0x9fbc
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xe700
jmp 0x9fba
jmp 0x9fbc
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1dd30
jmp 0x9fcb
movq 0xba0a6(%rip), %rax     # 0xc4078
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9ff3
movq -0x18(%rbp), %rdi
callq 0x9f90
movq -0x18(%rbp), %rdi
movl $0x38, %esi
callq 0x82e0
movq -0x10(%rbp), %rdi
callq 0x8300
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8930
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Persistence/Persistence.cpp
// Function: Persistence::exec(char const*)
int Persistence::exec( const char *sql )// insert update delete create table etc without select 
{
	int ret = 0;	
	pthread_mutex_lock(&(this->lock));

	if (this->err != NULL )
		sqlite3_free( this->err );
	ret = sqlite3_exec(this->db,sql,0,0,&(this->err));
	if (ret != SQLITE_OK )
	{
		mylog(ERROR,sql);
		mylog(ERROR,this->err);
	}
	pthread_mutex_unlock(&(this->lock));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x8410
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa04c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xe700
movq -0x20(%rbp), %r8
movq 0x28(%r8), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %r8
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x19c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa091
movq -0x10(%rbp), %rsi
movl $0x2, %edi
callq 0xbdb0
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x2, %edi
callq 0xbdb0
movq -0x20(%rbp), %rdi
callq 0x81f0
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/Persistence/Persistence.cpp
// Function: Persistence::query(char const*, int (*)(void*, int, char**, char**), void*)
int Persistence::query( const char *sql , callback fun, void *data)//all select insert update delete
{
	int ret = 0;	
	pthread_mutex_lock(&(this->lock));

	if (this->err != NULL )
		sqlite3_free( this->err );
	ret = sqlite3_exec(this->db,sql,fun,data,&(this->err));
	if (ret != SQLITE_OK )
	{
		mylog(ERROR,sql);
		mylog(ERROR,this->err);
	}
	pthread_mutex_unlock(&(this->lock));
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
callq 0x8410
movq -0x30(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa0f4
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xe700
movq -0x30(%rbp), %r8
movq 0x28(%r8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
addq $0x30, %r8
callq 0x19c90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0xa13a
movq -0x10(%rbp), %rsi
movl $0x2, %edi
callq 0xbdb0
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x2, %edi
callq 0xbdb0
movq -0x30(%rbp), %rdi
callq 0x81f0
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/SockTool/SockTool.cpp
// Function: SockTool::Socket()
int SockTool::Socket()
{
	int fd;
	pthread_mutex_lock(&socklock);
	fd = socket( AF_INET , SOCK_STREAM , 0 );
	pthread_mutex_unlock(&socklock);
	return fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb9f29(%rip), %rdi     # 0xc40a8
callq 0x8410
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x80a0
movl %eax, -0x4(%rbp)
leaq 0xb9f09(%rip), %rdi     # 0xc40a8
callq 0x81f0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/SockTool/SockTool.cpp
// Function: SockTool::Close(int)
int SockTool::Close( int fd )
{
	pthread_mutex_lock(&sockclose);
	close(fd);
	pthread_mutex_unlock(&sockclose);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0xb9f0e(%rip), %rdi     # 0xc40d0
callq 0x8410
movl -0x4(%rbp), %edi
callq 0x8520
leaq 0xb9efa(%rip), %rdi     # 0xc40d0
callq 0x81f0
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/URLManager/URLManager.cpp
// Function: URLManager::loadURL()
int URLManager::loadURL()
{
	int length = urlQue->getCount();
	int loadcount;
	Persistence *db;
	char sql[512] = { 0 };

	if ( length < URLLESSIZE )
	{
		//here need load url
		loadcount = URLMAXSIZE - length;
		db = Persistence::getPersistence();
		
		if ( db == NULL )
		{
			return -1;
		}
		sprintf(sql,"select * from url where state=0 order by id desc limit %d",loadcount);
		db->query(sql,load,this->urlQue);
	}
		//nothing
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x228(%rbp)
movq (%rax), %rdi
callq 0xa8f0
movl %eax, -0x14(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x8160
cmpl $0x2, -0x14(%rbp)
jge 0xa79b
movl $0xa, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x9f10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa762
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xa7a2
leaq -0x220(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x97a70(%rip), %rsi     # 0xa21e3
movb $0x0, %al
callq 0x8080
movq -0x228(%rbp), %rax
movq -0x20(%rbp), %rdi
leaq -0x220(%rbp), %rsi
movq (%rax), %rcx
leaq -0x436(%rip), %rdx      # 0xa360
callq 0xa0b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/URLManager/./../Queue/Queue.h
// Function: Queue<URL>::Queue(int)
Queue<T>::Queue( int method )
{
    head = NULL;
    tail = NULL;
    length = 0;
    this->method = method;
    pthread_mutex_init( &lock , NULL );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0x0, 0x14(%rdi)
movl -0xc(%rbp), %eax
movl %eax, 0x10(%rdi)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8440
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/URLManager/./../Queue/Queue.h
// Function: Queue<URL>::pop()
T*  Queue<T>::pop()
{
    if ( head == NULL || length <= 0)
    {
	tail = head = NULL;
        return NULL;
    }
    pthread_mutex_lock(&lock);
    T *temp = head->node;
    Node<T> *del = head;
    head = head->next;
    delete del;
    length--;
    pthread_mutex_unlock(&lock);
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
je 0xa934
movq -0x28(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jg 0xa951
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, -0x8(%rbp)
jmp 0xa9b7
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
callq 0x8410
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa999
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0x82e0
movq -0x28(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x18, %rdi
callq 0x81f0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/URLManager/./../Queue/Queue.h
// Function: Queue<URL>::pushTail(URL*)
int Queue<T>::pushTail( T *node )
{
    Node<T> *temp = NULL;
    if ( node  == NULL)
    {
        return -1;
    }
    pthread_mutex_lock(&lock);
    temp = new Node<T>;
    temp->node = node;
    temp->next = NULL;
    if ( tail == NULL && head == NULL )
    {
        tail = temp;
        head = temp;
    }
    else if ( tail != NULL )
    {
        tail->next = temp;
        tail = temp;
    }
    length++;
    pthread_mutex_unlock(&lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaa02
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x8410
movl $0x10, %edi
callq 0x82d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x18(%rbp), %rcx
movq $0x0, 0x8(%rcx)
cmpq $0x0, 0x8(%rax)
jne 0xaa61
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xaa61
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0xaa86
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xaa84
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0xaa86
movq -0x20(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x18, %rdi
callq 0x81f0
ud2
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/URLManager/./../Queue/Queue.h
// Function: Queue<URL>::pushHead(URL*)
int Queue<T>::pushHead( T *node )
{
    Node<T> *temp = NULL;
    if ( node == NULL)
    {
        return -1;
    }

    pthread_mutex_lock( &lock );
    temp = new Node<T>;
    temp->node = node;
    temp->next = head;
    head = temp;
    if ( tail == NULL)
    {
	temp->next = NULL;
        tail = head;
    }
    length++;
    pthread_mutex_unlock(&lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaad2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x8410
movl $0x10, %edi
callq 0x82d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, (%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
jne 0xab2f
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, 0x8(%rcx)
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
movl 0x14(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x14(%rdi)
addq $0x18, %rdi
callq 0x81f0
ud2
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/parserurl/./URLParser.cpp
// Function: URLParser::getHost(char*)
char *URLParser::getHost( char *url )
{
	char *temp = NULL;
	pthread_mutex_lock( &lock );
	temp = gethost(url);	
	pthread_mutex_unlock( &lock );
	return temp;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0xb9595(%rip), %rdi     # 0xc4100
callq 0x8410
movq -0x8(%rbp), %rdi
callq 0xbf60
movq %rax, -0x10(%rbp)
leaq 0xb957c(%rip), %rdi     # 0xc4100
callq 0x81f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/parserurl/./URLParser.cpp
// Function: URLParser::getPort(char*)
char *URLParser::getPort( char *url )
{
	char *temp = NULL;
        pthread_mutex_lock( &lock );
        temp = getport(url);
        pthread_mutex_unlock( &lock );
        return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0xb9545(%rip), %rdi     # 0xc4100
callq 0x8410
movq -0x8(%rbp), %rdi
callq 0xc0d0
movq %rax, -0x10(%rbp)
leaq 0xb952c(%rip), %rdi     # 0xc4100
callq 0x81f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/parserurl/./URLParser.cpp
// Function: URLParser::getRes(char*)
char *URLParser::getRes( char *url )
{
	char *temp = NULL;
        pthread_mutex_lock( &lock );
        temp = getres(url);
        pthread_mutex_unlock( &lock );
        return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0xb94f5(%rip), %rdi     # 0xc4100
callq 0x8410
movq -0x8(%rbp), %rdi
callq 0xc300
movq %rax, -0x10(%rbp)
leaq 0xb94dc(%rip), %rdi     # 0xc4100
callq 0x81f0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/parserurl/./URLParser.cpp
// Function: URLParser::deleteMemery(void*)
void URLParser::deleteMemery( void *del)
{
	pthread_mutex_lock(&lockd);
	if ( del != NULL )
	{
		free(del);
	}
	pthread_mutex_unlock(&lockd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xb94d5(%rip), %rdi     # 0xc4128
callq 0x8410
cmpq $0x0, -0x8(%rbp)
je 0xac68
movq -0x8(%rbp), %rdi
callq 0x8320
leaq 0xb94b9(%rip), %rdi     # 0xc4128
callq 0x81f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/bloom/bloom.c
// Function: add
void add( char *str )
{
	int i = 0;
	unsigned h = 0;
	for( i = 0; i< 8; i++)
	{
		h = hash( str , seeds[i]);
		bloom[h/sizeof(int)] |= 1<<(h%sizeof(int));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0xacf9
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0xb760a(%rip), %rax     # 0xc22c0
movl (%rax,%rcx,4), %esi
callq 0xad00
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
andq $0x3, %rax
movl %eax, %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %eax
movl %eax, %ecx
shrq $0x2, %rcx
leaq 0xb946f(%rip), %rax     # 0xc4150
orl (%rax,%rcx,4), %edx
leaq 0xb9465(%rip), %rax     # 0xc4150
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xaca1
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/bloom/bloom.c
// Function: hash
static unsigned int hash( char *str , int seed)
{
	char *temp = str;
	unsigned int ret = 0;
	while( temp != NULL && *temp !='\0')
	{
		ret = ret*seed + *temp;
		temp++;
	}
	return ret % BLOOM_BIT_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0xad36
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xad3f
jmp 0xad60
movl -0x1c(%rbp), %eax
imull -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xad1a
movl -0x1c(%rbp), %eax
movl $0x9c40, %ecx           # imm = 0x9C40
xorl %edx, %edx
divq %rcx
movl %edx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/bloom/bloom.c
// Function: search
int search( char *str)
{
	int  i = 0;
	unsigned int h = 0;
	for( i = 0; i< 8; i++)
	{
		h = hash( str, seeds[i]);
		if ( (bloom[h/sizeof(int)] & 1<<(h%sizeof(int))) == 0)
			return 0;

	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xae01
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xb750a(%rip), %rax     # 0xc22c0
movl (%rax,%rcx,4), %esi
callq 0xad00
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
shrq $0x2, %rcx
leaq 0xb937f(%rip), %rax     # 0xc4150
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
andq $0x3, %rcx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0xadf4
movl $0x0, -0x4(%rbp)
jmp 0xae08
jmp 0xadf6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xada1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/ConfigParser/configparser.cpp
// Function: ConfigParser::init()
void ConfigParser::init()
{

    this->duration = 10;
    this->timeout  = 10;
    this->jobnum   = 8;
    this->deepth   = 3;
    this->method   = 1;
    memset(this->modes, 0 , sizeof(ModePair*)*MODESIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xa, (%rdi)
movl $0xa, 0x4(%rdi)
movl $0x8, 0x8(%rdi)
movl $0x3, 0xc(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x18, %rdi
xorl %esi, %esi
movl $0xa0, %edx
callq 0x8160
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/ConfigParser/configparser.cpp
// Function: ConfigParser::~ConfigParser()
ConfigParser::~ConfigParser()
{
    for( int  i = 0; i < MODESIZE ; i++ )
    {
        if (this->modes[i] != NULL)
        {
            delete this->modes[i];
        }
    }
    delete ConfigParser::config;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0xb00e
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x18(%rax,%rcx,8)
je 0xb001
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xafff
movq -0x20(%rbp), %rdi
callq 0xbc10
movq -0x20(%rbp), %rdi
movl $0x10, %esi
callq 0x82e0
jmp 0xb001
jmp 0xb003
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xafbb
movq 0xc2d83(%rip), %rax     # 0xcdd98
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xb036
movq -0x28(%rbp), %rdi
callq 0xafa0
movq -0x28(%rbp), %rdi
movl $0xb8, %esi
callq 0x82e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/dns/dns.c
// Function: dns
struct sockaddr_in *dns( char *hostname ,char *port)
{
	struct addrinfo *ai=NULL;
	struct addrinfo i;
	struct sockaddr_in *p = NULL;
	int ret;
	if (hostname == NULL|| port == NULL)
	{
		return NULL;
	}
	memset(&i,0 ,sizeof(struct addrinfo));
	i.ai_family = AF_INET;
//	i.ai_flags = AI_PASSIVE;
	i.ai_socktype = SOCK_STREAM;
	ret = getaddrinfo(hostname,port,&i,&ai);
	if (ret != 0 && ai == NULL)
	{
		puts(gai_strerror(ret));
		return NULL;
	}
	p = (struct sockaddr_in*)malloc(sizeof(struct sockaddr_in));
	if (p==NULL)
	{
		freeaddrinfo(ai);
		return NULL;
	}
	memset(p, 0 , sizeof(struct sockaddr_in));
	memcpy(p,ai->ai_addr,sizeof(struct sockaddr_in));
/*	p->sin_family = AF_INET;
	p->sin_port = htons(atoi(port));
	memcpy( &(p->sin_addr) ,&(ai->ai_addr->sin_addr) , sizeof(struct in_addr) );
*/	
	freeaddrinfo(ai);
	return p;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x58(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb57e
cmpq $0x0, -0x18(%rbp)
jne 0xb58b
movq $0x0, -0x8(%rbp)
jmp 0xb64b
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x8160
movl $0x2, -0x4c(%rbp)
movl $0x1, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x8370
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
je 0xb5e8
cmpq $0x0, -0x20(%rbp)
jne 0xb5e8
movl -0x5c(%rbp), %edi
callq 0x83c0
movq %rax, %rdi
callq 0x8470
movq $0x0, -0x8(%rbp)
jmp 0xb64b
movl $0x10, %edi
callq 0x83b0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xb610
movq -0x20(%rbp), %rdi
callq 0x83a0
movq $0x0, -0x8(%rbp)
jmp 0xb64b
movq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x8160
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x83a0
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hash.c
// Function: hash
unsigned int hash( const char *str , int len)
{

	unsigned int ret = 0;
	unsigned int seed = 131;
	
	int i;
	for ( i = 0 ; i < len ; i++)
	{
		ret = ret * seed + str[i];
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x83, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xb6ab
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xb680
movl -0x10(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hashlist.c
// Function: initHashList
int   initHashList( HashList *list )
{
    if ( list == NULL )
    {
        return -1;
    }
    list->length = 0;
    memset( list->list , 0 , sizeof( list->list ));
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb6cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb6f1
movq -0x10(%rbp), %rax
movl $0x0, 0xf0(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0xf0, %edx
callq 0x8160
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hashlist.c
// Function: destroyHashList
int   destroyHashList( HashList *list)
{
    int i = 0;
    HashNode *temp;
    if ( list == NULL )
    {
        return -1;
    }

    for( i = 0; i < LISTLENGTH ; i++ )
    {
        while( list->list[i].next != NULL )
        {
            temp = list->list[i].next;
            list->list[i].next = list->list[i].next->next;
            if (temp != NULL )
                free(temp);
        }
    }
    list->length = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb726
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb7c0
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0xb7ab
jmp 0xb735
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0xb79e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x20(%rbp)
je 0xb79c
movq -0x20(%rbp), %rdi
callq 0x8320
jmp 0xb735
jmp 0xb7a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb72d
movq -0x10(%rbp), %rax
movl $0x0, 0xf0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hashlist.c
// Function: addElement
int   addElement( HashList *list, const char *key , void *value )
{
    int pos = 0;
    HashNode *temp = NULL;
    void *data = NULL;
    char *tkey = NULL;

    if ( list == NULL || key == NULL || value == NULL )
    {
        return -1;
    }

    data = getElement( list , key );
    if (data != NULL )
    {
        return -1;
    }

    pos = hash( key ,strlen(key)) % LISTLENGTH;

    temp = (HashNode*)malloc( sizeof( HashNode ) + strlen( key )+ 1 );

    if ( temp == NULL )
    {
        return -1;
    }
    tkey = (char *)(temp + 1);
    sprintf(tkey , "%s", key);
    temp->node = value;
    temp->key = tkey;
    temp->next = list->list[pos].next;
    list->list[pos].next = temp;
    list->length++;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb818
cmpq $0x0, -0x18(%rbp)
je 0xb818
cmpq $0x0, -0x20(%rbp)
jne 0xb824
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb925
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xb930
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xb848
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb925
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8120
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xb660
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8120
movq %rax, %rdi
addq $0x18, %rdi
addq $0x1, %rdi
callq 0x83b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xb8a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb925
movq -0x30(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x9b541(%rip), %rsi     # 0xa6dfc
movb $0x0, %al
callq 0x8080
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0xf0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xf0(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hashlist.c
// Function: getElement
void* getElement( HashList *list, const char *key)
{
    int pos = 0;
    HashNode *temp = NULL;

    if ( list == NULL || key == NULL )
    {
        return NULL;
    }

    pos = hash( key , strlen( key )) % LISTLENGTH;
    temp = list->list[pos].next;
    while( temp != NULL )
    {
        if ( !strcmp ( temp->key , key ))
        {
            return temp->node;
        }
        temp = temp->next;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb95d
cmpq $0x0, -0x18(%rbp)
jne 0xb967
movq $0x0, -0x8(%rbp)
jmp 0xb9e6
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8120
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0xb660
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xb9de
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x83e0
cmpl $0x0, %eax
jne 0xb9d0
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xb9e6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xb9a6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/HashList/hashlist.c
// Function: delElement
void* delElement( HashList *list, const char *key)
{
    int pos = 0;
    HashNode *temp = NULL;
    HashNode *pre = NULL;
    HashNode *del = NULL;
    void *data = NULL;
    if ( list == NULL || key == NULL )
    {
        return NULL;
    }

    pos = hash( key , strlen( key )) % LISTLENGTH;
    pre = &(list->list[pos]);
    temp = list->list[pos].next;
    while( temp != NULL )
    {
        if ( !strcmp ( temp->key , key ))
        {
            del = temp;
            data = temp->node;
            pre->next = del->next;
            free( del );
            list->length--;
            return data;
        }
        pre = temp;
        temp = temp->next;
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xba35
cmpq $0x0, -0x18(%rbp)
jne 0xba42
movq $0x0, -0x8(%rbp)
jmp 0xbb18
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8120
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xb660
movl $0xa, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbb10
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x83e0
cmpl $0x0, %eax
jne 0xbafa
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rdi
callq 0x8320
movq -0x10(%rbp), %rax
movl 0xf0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xf0(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbb18
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xba94
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/ConfigParser/modepair.cpp
// Function: ModePair::ModePair(char*, int)
ModePair::ModePair(char *mode, int type)
{
    if (mode == NULL)   return;

    int len = strlen(mode);
    this->mode = new char[len+1];
    sprintf(this->mode,"%s",mode);
    this->type = type;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbb84
jmp 0xbbc7
movq -0x10(%rbp), %rdi
callq 0x8120
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x8040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x9b246(%rip), %rsi     # 0xa6dfc
movb $0x0, %al
callq 0x8080
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/log/mylog.c
// Function: writelog
int writelog( int fd , int filter,int level, const char *str)
{
	char buf[512] = { 0 };
	struct tm *ti;
	char a[][11]={	"[DEBUG]   ",
			"[WARNING] ",
			"[ERROR]   "};
	if ( level > ERROR || filter > ERROR || level < DEBUG || filter < DEBUG)
		return-1;
	if ( level < filter)
		return 0;
	time_t t;
	time(&t);
	ti = localtime(&t);
	
	sprintf(buf,"%s %4d/%02d/%02d %02d:%02d:%02d :%s\n", a[level],
					ti->tm_year+1900,
					ti->tm_mon+1 ,
					ti->tm_mday,
					ti->tm_hour,
					ti->tm_min,
					ti->tm_sec,
					str);
	write(fd , buf ,strlen(buf));
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movl %edi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x8160
leaq -0x250(%rbp), %rdi
leaq 0x96686(%rip), %rsi     # 0xa2300
movl $0x21, %edx
callq 0x8220
cmpl $0x2, -0x18(%rbp)
jg 0xbc9c
cmpl $0x2, -0x14(%rbp)
jg 0xbc9c
cmpl $0x0, -0x18(%rbp)
jl 0xbc9c
cmpl $0x0, -0x14(%rbp)
jge 0xbca8
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
jmp 0xbda0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xbcbc
movl $0x0, -0xc(%rbp)
jmp 0xbda0
leaq -0x258(%rbp), %rdi
callq 0x8290
leaq -0x258(%rbp), %rdi
callq 0x81c0
movq %rax, -0x228(%rbp)
leaq -0x220(%rbp), %rdi
movslq -0x18(%rbp), %rax
leaq -0x250(%rbp), %rdx
imulq $0xb, %rax, %rax
addq %rax, %rdx
movq -0x228(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x76c, %ecx            # imm = 0x76C
movq -0x228(%rbp), %rax
movl 0x10(%rax), %r8d
addl $0x1, %r8d
movq -0x228(%rbp), %rax
movl 0xc(%rax), %r9d
movq -0x228(%rbp), %rax
movl 0x8(%rax), %ebx
movq -0x228(%rbp), %rax
movl 0x4(%rax), %r11d
movq -0x228(%rbp), %rax
movl (%rax), %r10d
movq -0x20(%rbp), %rax
leaq 0x965d9(%rip), %rsi     # 0xa2321
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x8080
movl -0x10(%rbp), %eax
movl %eax, -0x264(%rbp)
leaq -0x220(%rbp), %rax
movq %rax, -0x260(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x8120
movl -0x264(%rbp), %edi
movq -0x260(%rbp), %rsi
movq %rax, %rdx
callq 0x80f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/log/mylog.c
// Function: mylog
void mylog( int level , const char *str)
{
	int fd = open( "spider.log" , O_CREAT|O_RDWR|O_APPEND,0666);
	if ( fd != -1)
	{
		writelog(fd , ERROR , level , str);
		close( fd );	
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x96580(%rip), %rdi     # 0xa2346
movl $0x442, %esi            # imm = 0x442
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x81b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0xbdfc
movl -0x14(%rbp), %edi
movl -0x4(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x2, %esi
callq 0xbc40
movl -0x14(%rbp), %edi
callq 0x8520
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/shifengbin[P]bishe/parserurl/parserurl.c
// Function: removehttp
char *removehttp(char *url)
{
	char *u = url;
	char *ru;
	int len = 0;

	if (url == NULL)
		return NULL;


	if ( (u = strstr(url , "//")) != NULL)
	{
		ru = (char*)malloc(strlen(u+1));
		if ( ru== NULL)
			return NULL;
		memset( ru , 0 , strlen(u+1));
		memcpy( ru , u+2 , strlen(u+2));
	}
	else
	{
		ru = (char*)malloc(strlen(url)+1);
		memset( ru , 0 ,strlen(url)+1);
		memcpy( ru , url, strlen(url));
	}
	return ru;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbe3f
movq $0x0, -0x8(%rbp)
jmp 0xbf4d
movq -0x10(%rbp), %rdi
leaq 0x962bc(%rip), %rsi     # 0xa2106
callq 0x8090
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0xbee0
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x8120
movq %rax, %rdi
callq 0x83b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbe8a
movq $0x0, -0x8(%rbp)
jmp 0xbf4d
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x8120
movq -0x40(%rbp), %rdi
movq %rax, %rdx
xorl %esi, %esi
callq 0x8160
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2, %rdi
callq 0x8120
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x8220
jmp 0xbf45
movq -0x10(%rbp), %rdi
callq 0x8120
movq %rax, %rdi
addq $0x1, %rdi
callq 0x83b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8120
movq -0x58(%rbp), %rdi
movq %rax, %rdx
addq $0x1, %rdx
xorl %esi, %esi
callq 0x8160
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8120
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
callq 0x8220
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)