LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mruby-zest[P]osc-bridge/test/mock-test.c
// Function: test_vector_functionality
void test_vector_functionality(bridge_t *br)
{
    char buffer[1024];
    rtosc_message(buffer, sizeof(buffer), "/vector/test", "ffff", 1.1, 2.2, 3.3, 4.4);
    br_recv(br, buffer);
    br_recv(br, buffer);
    void **v1_ = malloc(sizeof(void*));
    *v1_ = &v1;

    br_add_callback(br, "/vector/test", print_response, v1_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
leaq 0x2037(%rip), %rdx      # 0xe099
leaq 0x225e(%rip), %rcx      # 0xe2c7
movsd 0x1e1f(%rip), %xmm0     # 0xde90
movsd 0x1e1f(%rip), %xmm1     # 0xde98
movsd 0x1e1f(%rip), %xmm2     # 0xdea0
movsd 0x1e1f(%rip), %xmm3     # 0xdea8
movb $0x4, %al
callq 0x88e0
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x2470
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x2470
movl $0x8, %edi
callq 0x21f0
movq %rax, -0x418(%rbp)
movq -0x418(%rbp), %rax
leaq 0x50b1(%rip), %rcx      # 0x11180
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x418(%rbp), %rcx
leaq 0x1fb5(%rip), %rsi      # 0xe099
leaq -0x79b(%rip), %rdx      # 0xb950
callq 0x39c0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/amanelis[P]uici/client_udp.c
// Function: main
int main(int argc, char *argv[]) {
   ssize_t byteswritten;
   char request[BUFSIZE];
   int requestfd;  
   int rlen;
   u_port_t serverport;
 
   if (argc != 3) {
      fprintf(stderr, "Usage: %s servername serverport\n", argv[0]);
      return 1;
   }
   serverport = (u_port_t) atoi(argv[2]);
   if ((requestfd = u_openudp(0)) == -1) {     /* create unbound UDP endpoint */
      perror("Failed to create UDP endpoint");
      return 1;
   }
   sprintf(request, "[%ld]\n", (long)getpid());           /* create a request */
   rlen = strlen(request);
    /* use  simple-request protocol to send a request to (server, serverport) */
   byteswritten = u_sendtohost(requestfd, request, rlen, argv[1], serverport);
   if (byteswritten == -1)
      perror("Failed to send");
   if (r_close(requestfd) == -1 || byteswritten == -1)
      return 1;
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x137a
movq 0x3ca2(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1c9d(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1140
movl $0x1, -0x4(%rbp)
jmp 0x145c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11d0
movw %ax, -0x42a(%rbp)
xorl %edi, %edi
callq 0x1fe0
movl %eax, -0x424(%rbp)
cmpl $-0x1, %eax
jne 0x13b8
leaq 0x1c7e(%rip), %rdi      # 0x3025
callq 0x11c0
movl $0x1, -0x4(%rbp)
jmp 0x145c
leaq -0x420(%rbp), %rax
movq %rax, -0x438(%rbp)
callq 0x1070
movq -0x438(%rbp), %rdi
movslq %eax, %rdx
leaq 0x1c67(%rip), %rsi      # 0x3043
movb $0x0, %al
callq 0x11f0
leaq -0x420(%rbp), %rdi
callq 0x1090
movl %eax, -0x428(%rbp)
movl -0x424(%rbp), %edi
leaq -0x420(%rbp), %rsi
movslq -0x428(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl -0x42a(%rbp), %r8d
callq 0x23f0
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x1435
leaq 0x1c1a(%rip), %rdi      # 0x304a
callq 0x11c0
movl -0x424(%rbp), %edi
callq 0x1470
cmpl $-0x1, %eax
je 0x144c
cmpq $-0x1, -0x18(%rbp)
jne 0x1455
movl $0x1, -0x4(%rbp)
jmp 0x145c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tarun388[P]myexpos_2019/spl/lex.yy.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 187 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 186);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0xbeb2(%rip), %rax      # 0xe180
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x7f3f(%rip), %rax      # 0xa220
cmpw $0x0, (%rax,%rcx,2)
je 0x22fc
movl -0x4(%rbp), %eax
movl %eax, 0xbe9b(%rip)      # 0xe18c
movq -0x10(%rbp), %rax
movq %rax, 0xbe94(%rip)      # 0xe190
jmp 0x22fe
movslq -0x4(%rbp), %rcx
leaq 0x82b7(%rip), %rax      # 0xa5c0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x8083(%rip), %rax      # 0xa3a0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x2356
movslq -0x4(%rbp), %rcx
leaq 0x840f(%rip), %rax      # 0xa740
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xbb, -0x4(%rbp)
jl 0x2354
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x8572(%rip), %rax      # 0xa8c0
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x22fe
movslq -0x4(%rbp), %rcx
leaq 0x825f(%rip), %rax      # 0xa5c0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x858b(%rip), %rax      # 0xa900
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0xba, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x239b
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x23a1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/X1319RAY[P]fileIO/fgetc.c
// Function: main
int main(int argc, char* argv[]){
	
	// コマンドライン引数のチェック
	if(argc != 2){
		fprintf(stderr, "引数の数が間違っています．\n");
		fprintf(stderr, "./fgetc input.txt\n");
		return 1;
	}
	
	// C言語のファイル入力のための準備
	FILE* fp; // FILE型構造体
	// 読み込みモードでファイルを開く
	fp = fopen(argv[1], "r"); // 失敗するとNULLを返す
	// ファイルを開くのに失敗したときの処理
	if(fp == NULL){
		fprintf(stderr, "Error: file not opened.\n");
		return 1;
	}
	
	// fgetc()で1文字ずつ読み込む
	int tmp; // fgetc()はint型の文字コードを返す
	int num = 0;
	int sum = 0;
	while((tmp = fgetc(fp)) != EOF){
		// ここでtmpを煮るなり焼くなりする
		printf("%c", (char)tmp); // そのまま出力
		
		// 数字ならnumに数として格納
		if(isdigit(tmp)){ // tmpが数字なら
			num = num * 10; // 位を1つ大きくする
			num += tmp - '0'; // 一の位に値を入れる
		}
		else{
			// 数字が終わった直後ならnumがsumに加算される
			// その後numを0にしているので直後以外はsumに0が加算される
			sum += num;
			num = 0;
		}
	}
	
	printf("\nsum: %d\n", sum);
	
	// ファイルを閉じる
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x11e8
movq 0x2e45(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe47(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1060
movq 0x2e2d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe58(%rip), %rsi       # 0x202d
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe49(%rip), %rsi       # 0x2040
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x122b
movq 0x2dea(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe2a(%rip), %rsi       # 0x2042
movb $0x0, %al
callq 0x1060
movl $0x1, -0x4(%rbp)
jmp 0x12c0
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1050
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x129f
movl -0x1c(%rbp), %eax
movsbl %al, %esi
leaq 0xe04(%rip), %rdi       # 0x205b
movb $0x0, %al
callq 0x1040
callq 0x1080
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x128d
imull $0xa, -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
subl $0x30, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x129d
movl -0x20(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x1239
movl -0x24(%rbp), %esi
leaq 0xdb5(%rip), %rdi       # 0x205e
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/fsstat.c
// Function: main
int main(int argc, char * argv[]) {
    struct _fst * fst = fst_create(); 

    const char * ifilename = NULL; 
    FILE * fin = stdin;

    if (argc > 1)
        ifilename = argv[1];

    if (ifilename) {
        if (( fin = fopen(ifilename, "rb")) == NULL ) {
            fprintf(stderr, "Error opening file: %s", ifilename);
            exit(EXIT_FAILURE);
        }
    }

    fst_read(fst, fin);

    printf("states:\t\t%"PRIu32"\n", fst->n_states);
    printf("arcs:\t\t%"PRIu32"\n", fst_get_n_arcs(fst));
    printf("sorted input:\t%d\n", fst->flags & ISORT ? 1 : 0);
    printf("sorted output:\t%d\n", fst->flags & OSORT ? 1 : 0);
    printf("start state:\t%"PRIu32"\n", fst->start);

    fst_remove(fst);
    
    if (fin != stdout) {
        fclose(fin);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x2740
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x40c8(%rip), %rax      # 0xafd8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x6f29
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6f72
movq -0x20(%rbp), %rdi
leaq 0x11ae(%rip), %rsi      # 0x80e9
callq 0x1150
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x6f70
movq 0x40a7(%rip), %rax      # 0xaff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x1173(%rip), %rsi      # 0x80d2
movb $0x0, %al
callq 0x10f0
movl $0x1, %edi
callq 0x1180
jmp 0x6f72
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2bc0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
leaq 0x17f2(%rip), %rdi      # 0x877f
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x2e80
movl %eax, %esi
leaq 0x17e6(%rip), %rdi      # 0x878c
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
movzbl 0xd(%rax), %ecx
andl $0x1, %ecx
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0x17cb(%rip), %rdi      # 0x8797
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
movzbl 0xd(%rax), %ecx
andl $0x2, %ecx
xorl %esi, %esi
movl $0x1, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
leaq 0x17b7(%rip), %rdi      # 0x87a9
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x17b6(%rip), %rdi      # 0x87bc
movb $0x0, %al
callq 0x10a0
movq -0x18(%rbp), %rdi
callq 0x2950
movq -0x28(%rbp), %rax
movq 0x3faf(%rip), %rcx      # 0xafd0
cmpq (%rcx), %rax
je 0x702f
movq -0x28(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CSerxzm[P]WindowstoLinuxInterface/src/REN.c
// Function: main
int main(int argc, char** argv){
    char lines[argc+1][255];
    predealLine(argc, argv, lines);
    if((strcmp("ren",lines[0])==0)||(strcmp("rename",lines[0])==0)){
        struct stat dir_stat;
        if((access(lines[1],F_OK)!=0)){
            perror("Don't exist DIR1\n");
            return 0;
        }
        else if(stat(lines[1], &dir_stat)<0){
            perror("Stat error!\n");
            return 0;
        }
        else if(rename(lines[1],lines[2])<0){
            perror("Rename error!\n");
        }
		else{
			printf("rename %s to %s \n",lines[1],lines[2]);
		}
    }
    else{
        perror("error after lines\n");
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
shlq $0x8, %rcx
subq %rax, %rcx
addq $0xf, %rcx
movabsq $0x1fffffffff0, %rdx    # imm = 0x1FFFFFFFFF0
andq %rdx, %rcx
movq %rsp, %rdx
subq %rcx, %rdx
movq %rdx, -0xc0(%rbp)
movq %rdx, %rsp
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x11c0
movq -0xc0(%rbp), %rsi
leaq 0xc36(%rip), %rdi       # 0x2004
callq 0x1050
cmpl $0x0, %eax
je 0x13f4
movq -0xc0(%rbp), %rsi
leaq 0xc22(%rip), %rdi       # 0x2008
callq 0x1050
cmpl $0x0, %eax
jne 0x14ca
movq -0xc0(%rbp), %rdi
addq $0xff, %rdi
xorl %esi, %esi
callq 0x1080
cmpl $0x0, %eax
je 0x1430
leaq 0xbfa(%rip), %rdi       # 0x200f
callq 0x1090
movl $0x0, -0x4(%rbp)
movl $0x1, -0xb4(%rbp)
jmp 0x14e7
movq -0xc0(%rbp), %rdi
addq $0xff, %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1060
cmpl $0x0, %eax
jge 0x146e
leaq 0xbcb(%rip), %rdi       # 0x2021
callq 0x1090
movl $0x0, -0x4(%rbp)
movl $0x1, -0xb4(%rbp)
jmp 0x14e7
movq -0xc0(%rbp), %rsi
movq %rsi, %rdi
addq $0xff, %rdi
addq $0x1fe, %rsi            # imm = 0x1FE
callq 0x10a0
cmpl $0x0, %eax
jge 0x149e
leaq 0xb97(%rip), %rdi       # 0x202e
callq 0x1090
jmp 0x14c4
movq -0xc0(%rbp), %rdx
movq %rdx, %rsi
addq $0xff, %rsi
addq $0x1fe, %rdx            # imm = 0x1FE
leaq 0xb80(%rip), %rdi       # 0x203d
movb $0x0, %al
callq 0x1040
jmp 0x14c6
jmp 0x14c8
jmp 0x14d6
leaq 0xb7e(%rip), %rdi       # 0x204f
callq 0x1090
movl $0x0, -0x4(%rbp)
movl $0x1, -0xb4(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/8-Synchronization/pthread_mutex.c
// Function: do_your_job
void *do_your_job(void *input)
{
	int number = *((int *) input);
	int i = 0;

	printf("Thread %d: starts execution.\n", number);

	while(1)
	{
		pthread_mutex_lock(&mutex);	// locking

		if(shared < max)		// the shared counter
		{
			shared++;		// writing shared variables
			i++;
			printf("Thread %d: shared = %d.\n", number, shared);
		}
		else
		{
			pthread_mutex_unlock(&mutex);	// unlocking before break.
			break;
		}

		pthread_mutex_unlock(&mutex);	// unlocking
		sleep(rand() % 2);	// forced context switching
	}

	printf("Thread %d: termination: I'm responsible for %d updates.\n", number, i);

	pthread_exit(0);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %esi
leaq 0xdbe(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
leaq 0x2e54(%rip), %rdi      # 0x40a8
callq 0x1100
movl 0x2e71(%rip), %eax      # 0x40d0
cmpl 0x2e6f(%rip), %eax      # 0x40d4
jge 0x1298
movl 0x2e63(%rip), %eax      # 0x40d0
addl $0x1, %eax
movl %eax, 0x2e5a(%rip)      # 0x40d0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
movl 0x2e48(%rip), %edx      # 0x40d0
leaq 0xd93(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1030
jmp 0x12a6
leaq 0x2e09(%rip), %rdi      # 0x40a8
callq 0x1070
jmp 0x12c8
leaq 0x2dfb(%rip), %rdi      # 0x40a8
callq 0x1070
callq 0x1110
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x10f0
jmp 0x124d
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0xd66(%rip), %rdi       # 0x203b
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/sift.c
// Function: korder
int
korder (void const* a, void const* b) {
  double x = ((double*) a) [2] - ((double*) b) [2] ;
  if (x < 0) return -1 ;
  if (x > 0) return +1 ;
  return 0 ;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq -0x18(%rsp), %rax
subsd 0x10(%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rsp), %xmm0
jbe 0x23e9
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x240a
movsd -0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x2402
movl $0x1, -0x4(%rsp)
jmp 0x240a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_get_double
VL_INLINE int
vl_file_meta_get_double (VlFileMeta *self, double *x)
{
  int err ;
  size_t n ;
  double y ;

  switch (self -> protocol) {

  case VL_PROT_ASCII :
    err = fscanf (self -> file, " ") ;
    if (err == EOF) return VL_ERR_EOF ;
    err = fscanf (self -> file, "%lg", x) ;
    if (err == EOF) return VL_ERR_EOF ;
    if (err <  1  ) return VL_ERR_BAD_ARG ;
    break ;

  case VL_PROT_BINARY :
    n = fread (&y, sizeof(double), 1, self -> file) ;
    if (n < 1) return VL_ERR_BAD_ARG ;
    vl_swap_host_big_endianness_8 (x, &y) ;
    break ;

  default :
    abort() ;
  }

  return VL_ERR_OK ;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x404(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x48b2
jmp 0x48a4
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x492b
jmp 0x4973
movq 0x28(%rsp), %rax
movq 0x808(%rax), %rdi
leaq 0x454e(%rip), %rsi      # 0x8e13
movb $0x0, %al
callq 0x2060
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x48e4
movl $0x5, 0x34(%rsp)
jmp 0x4980
movq 0x28(%rsp), %rax
movq 0x808(%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x4a09(%rip), %rsi      # 0x9305
movb $0x0, %al
callq 0x2060
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
jne 0x4918
movl $0x5, 0x34(%rsp)
jmp 0x4980
cmpl $0x1, 0x1c(%rsp)
jge 0x4929
movl $0x3, 0x34(%rsp)
jmp 0x4980
jmp 0x4978
movq 0x28(%rsp), %rax
movq 0x808(%rax), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2090
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jae 0x4962
movl $0x3, 0x34(%rsp)
jmp 0x4980
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4f10
jmp 0x4978
callq 0x2040
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_put_double
VL_INLINE int
vl_file_meta_put_double (VlFileMeta * self, double x)
{
  int err ;
  size_t n ;
  double y ;

  switch (self -> protocol) {

  case VL_PROT_ASCII :
    err = fprintf (self -> file, "%g ", x) ;
    break ;

  case VL_PROT_BINARY :
    vl_swap_host_big_endianness_8 (&y, &x) ;
    n = fwrite (&y, sizeof(double), 1, self -> file) ;
    err = n < 1 ;
    break ;

  default :
    abort() ;
  }

  return err ? VL_ERR_ALLOC : VL_ERR_OK ;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x404(%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x4dc0
jmp 0x4db5
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x4de6
jmp 0x4e2e
movq 0x30(%rsp), %rax
movq 0x808(%rax), %rdi
movsd 0x28(%rsp), %xmm0
leaq 0x455a(%rip), %rsi      # 0x9333
movb $0x1, %al
callq 0x2120
movl %eax, 0x24(%rsp)
jmp 0x4e33
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x4f10
movq 0x30(%rsp), %rax
movq 0x808(%rax), %rcx
leaq 0x10(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x2260
movq %rax, 0x18(%rsp)
cmpq $0x1, 0x18(%rsp)
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0x4e33
callq 0x2040
movl 0x24(%rsp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/src/generic-driver.h
// Function: vl_file_meta_put_uint8
VL_INLINE int
vl_file_meta_put_uint8 (VlFileMeta *self, vl_uint8 x)
{
  size_t n ;
  int err ;

  switch (self -> protocol) {

  case VL_PROT_ASCII :
    err = fprintf (self -> file, "%d ", x) ;
    if (err) return VL_ERR_ALLOC ;
    break ;

  case VL_PROT_BINARY :
    n = fwrite (&x, sizeof(vl_uint8), 1, self -> file) ;
    if (n < 1) return VL_ERR_ALLOC ;
    break ;

  default :
    abort() ;
  }

  return VL_ERR_OK ;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x18(%rsp), %rax
movl 0x404(%rax), %eax
movl %eax, (%rsp)
subl $0x1, %eax
je 0x4e7f
jmp 0x4e75
movl (%rsp), %eax
subl $0x2, %eax
je 0x4eb5
jmp 0x4eec
movq 0x18(%rsp), %rax
movq 0x808(%rax), %rdi
movzbl 0x17(%rsp), %edx
leaq 0x44a0(%rip), %rsi      # 0x9337
movb $0x0, %al
callq 0x2120
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x4eb3
movl $0x2, 0x24(%rsp)
jmp 0x4ef9
jmp 0x4ef1
movq 0x18(%rsp), %rax
movq 0x808(%rax), %rcx
leaq 0x17(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x2260
movq %rax, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jae 0x4eea
movl $0x2, 0x24(%rsp)
jmp 0x4ef9
jmp 0x4ef1
callq 0x2040
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/zpole[P]IICV/./vl/host.h
// Function: vl_swap_host_big_endianness_8
VL_INLINE void
vl_swap_host_big_endianness_8 (void *dst, void* src)
{
  char *dst_ = (char*) dst ;
  char *src_ = (char*) src ;
#if defined(VL_ARCH_BIG_ENDIAN)
    dst_ [0] = src_ [0] ;
    dst_ [1] = src_ [1] ;
    dst_ [2] = src_ [2] ;
    dst_ [3] = src_ [3] ;
    dst_ [4] = src_ [4] ;
    dst_ [5] = src_ [5] ;
    dst_ [6] = src_ [6] ;
    dst_ [7] = src_ [7] ;
#else
    dst_ [0] = src_ [7] ;
    dst_ [1] = src_ [6] ;
    dst_ [2] = src_ [5] ;
    dst_ [3] = src_ [4] ;
    dst_ [4] = src_ [3] ;
    dst_ [5] = src_ [2] ;
    dst_ [6] = src_ [1] ;
    dst_ [7] = src_ [0] ;
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movb 0x7(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movq -0x20(%rsp), %rax
movb 0x6(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x1(%rax)
movq -0x20(%rsp), %rax
movb 0x5(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x2(%rax)
movq -0x20(%rsp), %rax
movb 0x4(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x3(%rax)
movq -0x20(%rsp), %rax
movb 0x3(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x4(%rax)
movq -0x20(%rsp), %rax
movb 0x2(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x5(%rax)
movq -0x20(%rsp), %rax
movb 0x1(%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x6(%rax)
movq -0x20(%rsp), %rax
movb (%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, 0x7(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/echo.c
// Function: main
int main(int argc, char** argv) {
    if (argc > 1) {
        int i;
        for (i = 1;i < argc;i++) {
            printf("%s ",argv[i]);
        }
        printf("\n");
    } else {
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x11a0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1190
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xe86(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1163
leaq 0xe71(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
jmp 0x11ae
leaq 0xe61(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_should_keep_alive
int
http_should_keep_alive (const http_parser *parser)
{
  if (parser->http_major > 0 && parser->http_minor > 0) {
    /* HTTP/1.1 */
    if (parser->flags & F_CONNECTION_CLOSE) {
      return 0;
    }
  } else {
    /* HTTP/1.0 or earlier */
    if (!(parser->flags & F_CONNECTION_KEEP_ALIVE)) {
      return 0;
    }
  }

  return !http_message_needs_eof(parser);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %eax
cmpl $0x0, %eax
jle 0xa797
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %eax
cmpl $0x0, %eax
jle 0xa797
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0xff, %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xa795
movl $0x0, -0x4(%rbp)
jmp 0xa7d1
jmp 0xa7b8
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0xff, %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xa7b6
movl $0x0, -0x4(%rbp)
jmp 0xa7d1
jmp 0xa7b8
movq -0x10(%rbp), %rdi
callq 0xa7e0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_message_needs_eof
int
http_message_needs_eof (const http_parser *parser)
{
  if (parser->type == HTTP_REQUEST) {
    return 0;
  }

  /* See RFC 2616 section 4.4 */
  if (parser->status_code / 100 == 1 || /* 1xx e.g. Continue */
      parser->status_code == 204 ||     /* No Content */
      parser->status_code == 304 ||     /* Not Modified */
      parser->flags & F_SKIPBODY) {     /* response to a HEAD request */
    return 0;
  }

  /* RFC 7230 3.3.3, see `s_headers_almost_done` */
  if ((parser->uses_transfer_encoding == 1) &&
      (parser->flags & F_CHUNKED) == 0) {
    return 1;
  }

  if ((parser->flags & F_CHUNKED) || parser->content_length != ULLONG_MAX) {
    return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xa802
movl $0x0, -0x4(%rbp)
jmp 0xa8c1
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movl $0x64, %ecx
cltd
idivl %ecx
cmpl $0x1, %eax
je 0xa857
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0xcc, %eax
je 0xa857
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
andl $0xffff, %eax           # imm = 0xFFFF
cmpl $0x130, %eax            # imm = 0x130
je 0xa857
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0xff, %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0xa860
movl $0x0, -0x4(%rbp)
jmp 0xa8c1
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x1d, %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0xa890
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0xff, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xa890
movl $0x1, -0x4(%rbp)
jmp 0xa8c1
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0xff, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xa8b1
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0xa8ba
movl $0x0, -0x4(%rbp)
jmp 0xa8c1
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_parser_init
void
http_parser_init (http_parser *parser, enum http_parser_type t)
{
  void *data = parser->data; /* preserve application data */
  memset(parser, 0, sizeof(*parser));
  parser->data = data;
  parser->type = t;
  parser->state = (t == HTTP_REQUEST ? s_start_req : (t == HTTP_RESPONSE ? s_start_res : s_start_req_or_res));
  parser->http_errno = HPE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3200
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0x3, %edx
andl $-0x4, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
jne 0xad4a
movl $0x12, %eax
movl %eax, -0x1c(%rbp)
jmp 0xad60
movl -0xc(%rbp), %edx
movl $0x2, %eax
movl $0x4, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0x7f, %edx
shll $0xa, %edx
andl $0xfffe03ff, %ecx       # imm = 0xFFFE03FF
orl %edx, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
andl $0x80ffffff, %ecx       # imm = 0x80FFFFFF
orl $0x0, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/http-parser/http_parser.c
// Function: http_parser_pause
void
http_parser_pause(http_parser *parser, int paused) {
  /* Users should only be pausing/unpausing a parser that is not in an error
   * state. In non-debug builds, there's not much that we can do about this
   * other than ignore it.
   */
  if (HTTP_PARSER_ERRNO(parser) == HPE_OK ||
      HTTP_PARSER_ERRNO(parser) == HPE_PAUSED) {
    uint32_t nread = parser->nread; /* used by the SET_ERRNO macro */
    SET_ERRNO((paused) ? HPE_PAUSED : HPE_OK);
  } else {
    assert(0 && "Attempting to pause parser in error state");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x18, %eax
andl $0x7f, %eax
cmpl $0x0, %eax
je 0xb453
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
shrl $0x18, %eax
andl $0x7f, %eax
cmpl $0x1f, %eax
jne 0xb491
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
xorl %edx, %edx
movl $0x1f, %eax
cmpl $0x0, %ecx
cmovnel %eax, %edx
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
andl $0x7f, %edx
shll $0x18, %edx
andl $0x80ffffff, %ecx       # imm = 0x80FFFFFF
orl %edx, %ecx
movl %ecx, 0x14(%rax)
jmp 0xb4b0
leaq 0x29f07(%rip), %rdi     # 0x3539f
leaq 0x297f5(%rip), %rsi     # 0x34c94
movl $0x9fc, %edx            # imm = 0x9FC
leaq 0x29f25(%rip), %rcx     # 0x353d0
callq 0x3250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel.c
// Function: channel_create
int channel_create(
	channel_t** pctx,
	const char* name,
    const char* args,
	const config_t* conf,
	const proxy_t* proxies,
	const int proxy_num,
	const chnroute_ctx chnr,
	const chnroute_ctx blacklist,
	void* data)
{
	channel_info_t* info;
	char chname[20] = {0};
	char *dot;

	dot = strchr(name, '.');
	if (dot) {
		memcpy(chname, name, MIN(dot - name, sizeof(chname) - 1));
	}
	else {
		strncpy(chname, name, sizeof(chname) - 1);
	}

	info = _infos;
	while (info) {

		if (strcmp(info->name, chname) == 0) {
			return info->create(pctx,
				name, args, conf,
				proxies, proxy_num,
				chnr, blacklist,
				data);
		}

		info++;
	}
	return CHANNEL_NO_EXIST;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movl %r9d, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x14, %edx
callq 0x3200
movq -0x20(%rbp), %rdi
movl $0x2e, %esi
callq 0x3160
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0xbb69
leaq -0x60(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq $0x13, %rax
jae 0xbb4b
movq -0x68(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x80(%rbp)
jmp 0xbb56
movl $0x13, %eax
movq %rax, -0x80(%rbp)
jmp 0xbb56
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rdx
callq 0x32d0
jmp 0xbb7b
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x13, %edx
callq 0x31f0
leaq 0x35bae(%rip), %rax     # 0x41730
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xbbf1
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3500
cmpl $0x0, %eax
jne 0xbbe3
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x3c(%rbp), %r9d
movq 0x10(%rbp), %rbx
movq 0x18(%rbp), %r11
movq 0x20(%rbp), %r10
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
movl %eax, -0xc(%rbp)
jmp 0xbbf8
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
jmp 0xbb86
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_each
int cache_each(channel_t *ctx,
		int (*f)(const ns_msg_t *msg, void *data), void *data)
{
	cache_t *c = (cache_t*)ctx;
	dlitem_t *cur, *nxt;
	cache_item_t *item;
	int r;
	dllist_foreach(&c->items, cur, nxt,
		cache_item_t, item, entry) {
		r = f(item->msg, data);
		if (r)
			return r;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xbf51
jmp 0xbf9f
movq -0x18(%rbp), %rax
movq -0x40(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
je 0xbf74
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbfa6
jmp 0xbf76
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0xbf37
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_get
const ns_msg_t *cache_get(channel_t *ctx, const char *key)
{
	cache_t *c = (cache_t*)ctx;
	cache_item_t *item;
	struct rbnode_t *rbn;

	if (!key) {
		loge("invalid arguments\n");
		return NULL;
	}

	rbn = rbtree_lookup(&c->dic, key);
	if (!rbn) {
		loge("item not exists - %s\n", key);
		return NULL;
	}

	item = rbtree_container_of(rbn, cache_item_t, node);
	return item->msg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc00f
jmp 0xbfd1
movb $0x0, %al
callq 0x242d0
cmpl $0x3, (%rax)
jl 0xc003
movl $0x3, %edi
leaq 0x29c09(%rip), %rsi     # 0x35bf2
leaq 0x29c16(%rip), %rdx     # 0x35c06
movl $0xc8, %ecx
leaq 0x29c14(%rip), %r8      # 0x35c10
movb $0x0, %al
callq 0x243b0
jmp 0xc005
movq $0x0, -0x8(%rbp)
jmp 0xc083
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x3b10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc06f
jmp 0xc02d
movb $0x0, %al
callq 0x242d0
cmpl $0x3, (%rax)
jl 0xc063
movq -0x18(%rbp), %r9
movl $0x3, %edi
leaq 0x29ba9(%rip), %rsi     # 0x35bf2
leaq 0x29bb6(%rip), %rdx     # 0x35c06
movl $0xce, %ecx
leaq 0x29bc7(%rip), %r8      # 0x35c23
movb $0x0, %al
callq 0x243b0
jmp 0xc065
movq $0x0, -0x8(%rbp)
jmp 0xc083
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_remove
int cache_remove(channel_t *ctx, const char *key)
{
	cache_t *c = (cache_t*)ctx;
	cache_item_t *item;
	struct rbnode_t *rbn;

	if (!key) {
		loge("invalid arguments\n");
		return -1;
	}

	rbn = rbtree_lookup(&c->dic, key);
	if (!rbn) {
		loge("item not exists - %s\n", key);
		return -1;
	}

	item = rbtree_container_of(rbn, cache_item_t, node);
	dllist_remove(&item->entry);
	rbtree_remove(&c->dic, &item->node);
	cache_item_destroy(item);
	logi("cache removed: %s\n", key);
	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, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xc0f1
jmp 0xc0b1
movb $0x0, %al
callq 0x242d0
cmpl $0x3, (%rax)
jl 0xc0e3
movl $0x3, %edi
leaq 0x29b29(%rip), %rsi     # 0x35bf2
leaq 0x29b69(%rip), %rdx     # 0x35c39
movl $0xdd, %ecx
leaq 0x29b34(%rip), %r8      # 0x35c10
movb $0x0, %al
callq 0x243b0
jmp 0xc0e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc1db
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x3b10
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc153
jmp 0xc10f
movb $0x0, %al
callq 0x242d0
cmpl $0x3, (%rax)
jl 0xc145
movq -0x18(%rbp), %r9
movl $0x3, %edi
leaq 0x29ac7(%rip), %rsi     # 0x35bf2
leaq 0x29b07(%rip), %rdx     # 0x35c39
movl $0xe3, %ecx
leaq 0x29ae5(%rip), %r8      # 0x35c23
movb $0x0, %al
callq 0x243b0
jmp 0xc147
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc1db
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movq -0x28(%rbp), %rsi
callq 0x3b90
movq -0x28(%rbp), %rdi
callq 0xc1f0
movb $0x0, %al
callq 0x242d0
cmpl $0x6, (%rax)
jl 0xc1d2
movq -0x18(%rbp), %r9
movl $0x6, %edi
leaq 0x29a3a(%rip), %rsi     # 0x35bf2
leaq 0x29a7a(%rip), %rdx     # 0x35c39
movl $0xeb, %ecx
leaq 0x29a7b(%rip), %r8      # 0x35c46
movb $0x0, %al
callq 0x243b0
jmp 0xc1d4
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/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_item_destroy
static void cache_item_destroy(cache_item_t* item)
{
	if (item) {
		free(item->node.key);
		ns_msg_free(item->msg);
		free(item->msg);
		free(item);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc232
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x27870
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3460
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: update_expire
static inline void update_expire(cache_t *c, cache_item_t *item, int ttl)
{
	if (c->conf->cache_timeout == CACHE_TIMEOUT_FOLLOWING_TTL) {
		item->expire = time(NULL) + ttl;
	}
	else if (c->conf->cache_timeout != CACHE_TIMEOUT_NEVEL_EXPIRE) {
		item->expire = time(NULL) + c->conf->cache_timeout;
	}
}

// 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 0x8(%rax), %rax
cmpl $0x1, 0x8c(%rax)
jne 0xc591
xorl %eax, %eax
movl %eax, %edi
callq 0x3330
movq %rax, %rcx
movslq -0x14(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc5ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x8c(%rax)
je 0xc5c8
xorl %eax, %eax
movl %eax, %edi
callq 0x3330
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq 0x8c(%rax), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0xc5ca
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_item_add
static void cache_item_add(cache_t* c, cache_item_t* item)
{
	dlitem_t* cur, * nxt;
	cache_item_t* p;

	/* TODO: Use Heap Data Structure, see https://en.wikipedia.org/wiki/Heap_(data_structure) */
	dllist_foreach(&c->items, cur, nxt,
		cache_item_t, p, entry) {
		
		if (p->expire >= item->expire) {
			dllist_add_before(&p->entry, &item->entry);
			return;
		}
	}

	dllist_add(&c->items, &item->entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xc624
jmp 0xc6ab
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x40(%rcx), %rax
jl 0xc67d
jmp 0xc638
movq -0x28(%rbp), %rcx
addq $0x28, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0xc6f0
jmp 0xc67f
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xc607
jmp 0xc6ad
movq -0x8(%rbp), %rcx
addq $0x58, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x28, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cache_load_cachedbs
int cache_load_cachedbs(channel_t *ctx, const char *filenames, int override)
{
	char *s, *p, *saveptr = NULL;
	struct stat fstat = {0};

	if (!filenames || !*filenames) {
		loge("Invalid filenames: %s\n", filenames);
		return -1;
	}

	s = strdup(filenames);

	for (p = strtok_r(s, ",", &saveptr);
		p && *p;
		p = strtok_r(NULL, ",", &saveptr)) {

		if (stat(p, &fstat)) {
			logw("Failed to load cache: Failed to open the file - \"%s\"\n", p);
		}
		else if (cache_load_cachedb(ctx, p, override) == -1) {
			free(s);
			return -1;
		}
	}

	free(s);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0xc8(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x3200
cmpq $0x0, -0x18(%rbp)
je 0xd7f1
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd837
jmp 0xd7f3
movb $0x0, %al
callq 0x242d0
cmpl $0x3, (%rax)
jl 0xd829
movq -0x18(%rbp), %r9
movl $0x3, %edi
leaq 0x283e3(%rip), %rsi     # 0x35bf2
leaq 0x2862d(%rip), %rdx     # 0x35e43
movl $0x25e, %ecx            # imm = 0x25E
leaq 0x28635(%rip), %r8      # 0x35e57
movb $0x0, %al
callq 0x243b0
jmp 0xd82b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd936
movq -0x18(%rbp), %rdi
callq 0x3620
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2861f(%rip), %rsi     # 0x35e6e
leaq -0x38(%rbp), %rdx
callq 0x3610
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0xc9(%rbp)
je 0xd87e
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xc9(%rbp)
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0xd88d
jmp 0xd926
movq -0x30(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x3310
cmpl $0x0, %eax
je 0xd8de
jmp 0xd8a4
movb $0x0, %al
callq 0x242d0
cmpl $0x4, (%rax)
jl 0xd8da
movq -0x30(%rbp), %r9
movl $0x4, %edi
leaq 0x28332(%rip), %rsi     # 0x35bf2
leaq 0x2857c(%rip), %rdx     # 0x35e43
movl $0x269, %ecx            # imm = 0x269
leaq 0x2859d(%rip), %r8      # 0x35e70
movb $0x0, %al
callq 0x243b0
jmp 0xd8dc
jmp 0xd907
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xd090
cmpl $-0x1, %eax
jne 0xd905
movq -0x28(%rbp), %rdi
callq 0x3460
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xd936
jmp 0xd907
jmp 0xd909
xorl %eax, %eax
movl %eax, %edi
leaq 0x2855a(%rip), %rsi     # 0x35e6e
leaq -0x38(%rbp), %rdx
callq 0x3610
movq %rax, -0x30(%rbp)
jmp 0xd85c
movq -0x28(%rbp), %rdi
callq 0x3460
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: step
static int step(channel_t* ctx,
	fd_set* readset, fd_set* writeset, fd_set* errorset)
{
	cache_t* c = (cache_t*)ctx;
	if (c->conf->cache_timeout != CACHE_TIMEOUT_NEVEL_EXPIRE) {
		cache_check_expire(c);
	}
	return 0;
}

// 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), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x8c(%rax)
je 0xdbda
movq -0x28(%rbp), %rdi
callq 0xdf40
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: query
static int query(channel_t* ctx,
	const ns_msg_t* msg,
	channel_query_cb callback, void* state)
{
	cache_t* c = (cache_t*)ctx;
	const char* key;
	struct rbnode_t* rbn;
	cache_item_t* item;

	key = msg_key(msg);

	rbn = rbtree_lookup(&c->dic, key);
	if (!rbn) {
		goto error;
	}

	item = rbtree_container_of(rbn, cache_item_t, node);

	logi("hit cache: %s - %s\n", key, msg_answers(item->msg));

	if (callback)
		callback(ctx, 0, item->msg, TRUE, TRUE, state);

	return 0;

error:
	if (callback)
		callback(ctx, -1, NULL, TRUE, FALSE, state);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd760
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
movq -0x38(%rbp), %rsi
callq 0x3b10
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xdc3e
jmp 0xdcc8
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, %al
callq 0x242d0
cmpl $0x6, (%rax)
jl 0xdc95
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x27de0
movq -0x50(%rbp), %r9
movl $0x6, %edi
leaq 0x27f7b(%rip), %rsi     # 0x35bf2
leaq 0x28633(%rip), %rdx     # 0x362b1
movl $0x99, %ecx
leaq 0x282e0(%rip), %r8      # 0x35f6a
movq %rax, (%rsp)
movb $0x0, %al
callq 0x243b0
jmp 0xdc97
cmpq $0x0, -0x20(%rbp)
je 0xdcbf
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rcx
movq 0x38(%rcx), %rdx
movq -0x28(%rbp), %r9
xorl %esi, %esi
movl $0x1, %r8d
movl %r8d, %ecx
callq *%rax
movl $0x0, -0x4(%rbp)
jmp 0xdcf5
cmpq $0x0, -0x20(%rbp)
je 0xdcee
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %r9
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
callq *%rax
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: destroy
static void destroy(channel_t* ctx)
{
	cache_t* c = (cache_t*)ctx;
	dlitem_t* cur, * nxt;
	cache_item_t* item;
	dllist_foreach(&c->items, cur, nxt,
		cache_item_t, item, entry) {
		dllist_remove(&item->entry);
		cache_item_destroy(item);
	}
	c->dic.root = NULL;
	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x58, %rcx
cmpq %rcx, %rax
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdd59
jmp 0xddb4
jmp 0xdd5b
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rdi
callq 0xc1f0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
movq %rax, %rcx
addq $0x28, %rcx
subq %rcx, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xdd3f
movq -0x10(%rbp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rbp), %rdi
callq 0x3460
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/GangZhuo[P]dohclient/src/channel_cache.c
// Function: cb_querystring
static int cb_querystring(char *name, char *value, void *state)
{
	struct cb_querystring_state_t *st = state;
	cache_t *ctx = st->ctx;

	if (strcmp(name, "cachedb") == 0) {
		if (cache_load_cachedbs((channel_t*)ctx, value, st->override)) {
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x27fa7(%rip), %rsi     # 0x35da9
callq 0x3500
cmpl $0x0, %eax
jne 0xde30
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edx
callq 0xd7b0
cmpl $0x0, %eax
je 0xde2e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xde37
jmp 0xde30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq