LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/shaswata56[P]BenchUtil/BenchmarkFLOPS64.c
// Function: main
int main (int argc, char** argv) {
	int n;
	if (argc == 1) {
		printf("Number of CPU cores to run Benchmark: ");
		scanf("%d", &n);
	} else {
		n = atoi(argv[1]);
	}
    printf("Benchmarking for 64 Bit Floating point operations per second\n");
	initFLOPS64(n);
	return 0;
}

// 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)
jne 0x121e
leaq 0x4ecd(%rip), %rdi      # 0x60d0
movb $0x0, %al
callq 0x1050
leaq 0x4ee6(%rip), %rdi      # 0x60f7
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x10b0
jmp 0x122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
leaq 0x4ec5(%rip), %rdi      # 0x60fa
movb $0x0, %al
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/baileywjohnson[P]mpi-matrix-mult/make-matrix.c
// Function: main
int main(int argc, char *argv[]){

	double *A;
	char *in;

	int rows, columns, lower, upper;
	
	if(argc != 11){
		printf("USAGE: make-matrix -m <number of rows> -n <number of columns> -l <lower bound> -u <upper bound> -o <output file>\n");
		exit(1);
	}

	int c;
	while((c = getopt(argc, argv, "m:n:l:u:o:")) != -1){
		switch(c){
			case 'm':
				rows = atoi(optarg);
				break;
			case 'n':
				columns = atoi(optarg);
				break;
			case 'l':
				lower = atoi(optarg);
				break;
			case 'u':
				upper = atoi(optarg);
				break;
			case 'o':
				in = optarg;
				break;
			case '?':
				exit(1);
				break;
			default:
				break;
		}
	}	

	make_matrix(rows, columns, lower, upper, &A);
	write_matrix(in, rows, columns, A);
	free(A);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xb, -0x8(%rbp)
je 0x1234
leaq 0xebd(%rip), %rdi       # 0x20e0
movb $0x0, %al
callq 0x1030
movl $0x1, %edi
callq 0x1040
jmp 0x1236
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xf0e(%rip), %rdx       # 0x2152
callq 0x1050
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
je 0x12eb
movl -0x34(%rbp), %eax
addl $-0x3f, %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x36, %eax
ja 0x12e4
movq -0x40(%rbp), %rax
leaq 0xd93(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x2d6f(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x24(%rbp)
jmp 0x12e6
movq 0x2d5b(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x28(%rbp)
jmp 0x12e6
movq 0x2d47(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x2c(%rbp)
jmp 0x12e6
movq 0x2d33(%rip), %rax      # 0x3ff0
movq (%rax), %rdi
callq 0x1090
movl %eax, -0x30(%rbp)
jmp 0x12e6
movq 0x2d1f(%rip), %rax      # 0x3ff0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12e6
movl $0x1, %edi
callq 0x1040
jmp 0x12e6
jmp 0x1236
movl -0x24(%rbp), %edi
movl -0x28(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
leaq -0x18(%rbp), %r8
callq 0x1330
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x1490
movq -0x18(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/chan.c
// Function: Producer
void Producer(void *ptr){
    channel_t ch = *(int *)ptr;
    int o = 0;
    int i = 0;
    for (i = 0; i<10; i++){
        o++;
        if (channel_write(ch, (void *)&o) != 0){
            printf("channel brokern,Producer exit\n");
            break;
        }
        uvc_sleep(100);
    }
    printf("Producer send over\n");
    channel_close(ch);
    uvc_return();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0xa, -0x14(%rbp)
jge 0x13ff
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
leaq -0x10(%rbp), %rsi
callq 0x2a30
cmpl $0x0, %eax
je 0x13ea
leaq 0x2c23(%rip), %rdi      # 0x4004
movb $0x0, %al
callq 0x1100
jmp 0x13ff
movl $0x64, %edi
callq 0x1a80
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13ba
leaq 0x2c1d(%rip), %rdi      # 0x4023
movb $0x0, %al
callq 0x1100
movl -0xc(%rbp), %edi
callq 0x2850
movb $0x0, %al
callq 0x1770
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/chan.c
// Function: Consumer
void Consumer(void *ptr){
    
    channel_t ch = *(int *)ptr;
    int o = 0;
    while(1){
        if (channel_read(ch, (void *)&o) != 0){
            printf("channel brokern,Consumer exit\n");
            break;
        }
        printf("Consumer read %d\n",o);
    }
    printf("Consumer recv over\n");
    uvc_return();

}

// 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), %edi
leaq -0x10(%rbp), %rsi
callq 0x2ca0
cmpl $0x0, %eax
je 0x146d
leaq 0x2bd3(%rip), %rdi      # 0x4037
movb $0x0, %al
callq 0x1100
jmp 0x1480
movl -0x10(%rbp), %esi
leaq 0x2bdf(%rip), %rdi      # 0x4056
movb $0x0, %al
callq 0x1100
jmp 0x144c
leaq 0x2be1(%rip), %rdi      # 0x4068
movb $0x0, %al
callq 0x1100
movb $0x0, %al
callq 0x1770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/chan.c
// Function: main
int main(){
    channel_t ch;
    ch = channel_create(0, sizeof(int));
    uvc_create("Producer",10 * 1024, Producer, (void *)&ch);
    uvc_create("Consumer",10 * 1024, Consumer, (void *)&ch);
    uvc_schedule();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
movl $0x4, %esi
callq 0x26c0
movl %eax, -0x4(%rbp)
leaq 0x2bbe(%rip), %rdi      # 0x407c
movl $0x2800, %esi           # imm = 0x2800
leaq -0x13a(%rip), %rdx      # 0x1390
leaq -0x4(%rbp), %rcx
callq 0x19c0
leaq 0x2bab(%rip), %rdi      # 0x4085
movl $0x2800, %esi           # imm = 0x2800
leaq -0xb6(%rip), %rdx       # 0x1430
leaq -0x4(%rbp), %rcx
callq 0x19c0
movb $0x0, %al
callq 0x15a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_task_uv
void uvc_task_uv(void *ptr){
	uvc_thread_env *env = uvc_get_env();
	env->uv_task = uvc_self();
	uv_run(env->loop, UV_RUN_DEFAULT);
	env->uv_task = NULL;
	uvc_return();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3720
movq %rax, -0x10(%rbp)
callq 0x3890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x140b8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1280
movq -0x10(%rbp), %rax
movq $0x0, 0x140b8(%rax)
callq 0x1770
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_schedule
void uvc_schedule(){
	uvc_ctx *ctx;
	queue_t *node;
	uvc_thread_env *env;
	env = uvc_get_env();
	for (;;){
		if (!queue_empty(&env->ready_queue) ){
			node = queue_last(&env->ready_queue);
			queue_remove( node);
			ctx = queue_data(node, uvc_ctx, task_node);
		}
		else{
			//只有当没有ready任务时才运行uvloop
			if (env->uv_task){
				ctx = env->uv_task;
			}
			else{
				printf("no task need run ,exit\n");
				exit(0);
			}
		}
		
		if (ctx != NULL){
			env->runing_task = ctx;
			ctx->status = UVC_STATUS_RUNING;
			//printf("task[%s] runing\n",ctx->name);
			uvc_resume(ctx);
			//printf("task[%s] stoping\n",ctx->name);
		}
		if (ctx->status == UVC_STATUS_DIE){
			coro_stack_free(&ctx->stack);
			free(ctx);
		}else{
			ctx->status = UVC_STATUS_PENDING;
		}
		

	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x3720
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x140d0, %rax          # imm = 0x140D0
movq -0x18(%rbp), %rcx
cmpq 0x140d0(%rcx), %rax
je 0x160c
movq -0x18(%rbp), %rax
movq 0x140d0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $-0x118, %rax           # imm = 0xFEE8
movq %rax, -0x8(%rbp)
jmp 0x1642
movq -0x18(%rbp), %rax
cmpq $0x0, 0x140b8(%rax)
je 0x162b
movq -0x18(%rbp), %rax
movq 0x140b8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1640
leaq 0x2a5c(%rip), %rdi      # 0x408e
movb $0x0, %al
callq 0x1100
xorl %edi, %edi
callq 0x1250
jmp 0x1642
cmpq $0x0, -0x8(%rbp)
je 0x166f
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x140c8(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x130(%rax)
movq -0x8(%rbp), %rdi
callq 0x16b0
movq -0x8(%rbp), %rax
cmpl $0x4, 0x130(%rax)
jne 0x1694
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
callq 0x3bb0
movq -0x8(%rbp), %rdi
callq 0x1030
jmp 0x16a2
movq -0x8(%rbp), %rax
movl $0x1, 0x130(%rax)
jmp 0x15b1
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_resume
void uvc_resume(uvc_ctx *ctx){
	uvc_thread_env *env=uvc_get_env();
	ctx->status = UVC_STATUS_RUNING;
	env->runing_task = ctx;
	RESUME(env, ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3720
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x3, 0x130(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x140c8(%rax)
movq -0x10(%rbp), %rax
movq 0x140c0(%rax), %rdi
addq $0x48, %rdi
movq -0x8(%rbp), %rsi
addq $0x48, %rsi
callq 0x38e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_return
void uvc_return(){
	uvc_ctx *ctx=uvc_self();
	uvc_thread_env *env = uvc_get_env();
	env->runing_task->status= UVC_STATUS_DIE;
	printf("task[%s] exit\n",uvc_ctx_get_name());
	YIELD(env);
	//TODO 当前协程先出栈，然后resume到专门释放协程的协程。
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x3890
movq %rax, -0x8(%rbp)
callq 0x3720
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x140c8(%rax), %rax
movl $0x4, 0x130(%rax)
callq 0x1750
movq %rax, %rsi
leaq 0x28fb(%rip), %rdi      # 0x40a9
movb $0x0, %al
callq 0x1100
movq -0x10(%rbp), %rax
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rax
movq 0x140c0(%rax), %rsi
addq $0x48, %rsi
callq 0x38e0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_switch
void uvc_switch(uvc_ctx *prev, uvc_ctx *next){
	printf("[switch]  %s  ->  %s\n", prev->name, next->name);
	uvc_thread_env *env = uvc_get_env();
	next->status = UVC_STATUS_RUNING;
	prev->status = UVC_STATUS_READY;
	env->runing_task = next;
	coro_transfer(&prev->cur, &next->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x2759(%rip), %rdi      # 0x40b8
movb $0x0, %al
callq 0x1100
callq 0x3720
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x3, 0x130(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x130(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x140c8(%rax)
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rsi
callq 0x38e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_create
void uvc_create(char *name, unsigned int size, coro_func func, void *arg){
	uvc_ctx *ctx = (uvc_ctx *)malloc(sizeof(uvc_ctx));
	memset(ctx, 0, sizeof(uvc_ctx));
	//ctx->data=arg;
	coro_stack_alloc(&ctx->stack, size);
	coro_create(&ctx->cur, func, arg, ctx->stack.sptr, ctx->stack.ssze);
	if (name == NULL || strlen(name) == 0){
		sprintf(ctx->name, "coro");
	}
	else{
		sprintf(ctx->name, name);
	}
	uvc_ready(ctx);
	//uvc_resume(ctx);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x140, %edi            # imm = 0x140
callq 0x11d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x140, %edx            # imm = 0x140
callq 0x1150
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
movl -0xc(%rbp), %esi
callq 0x3a20
movq -0x28(%rbp), %rdi
addq $0x48, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x28(%rbp), %rax
movq 0x58(%rax), %r8
callq 0x3900
cmpq $0x0, -0x8(%rbp)
je 0x1a40
movq -0x8(%rbp), %rdi
callq 0x10c0
cmpq $0x0, %rax
jne 0x1a54
movq -0x28(%rbp), %rdi
leaq 0x2683(%rip), %rsi      # 0x40ce
movb $0x0, %al
callq 0x1240
jmp 0x1a63
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rsi
movb $0x0, %al
callq 0x1240
movq -0x28(%rbp), %rdi
callq 0x18c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_sleep
void uvc_sleep(uint64_t msec){
	uvc_thread_env *env = uvc_get_env();
	uv_timer_t timer;
	timer.data = uvc_self();
	uv_timer_init(uvc_loop_default(), &timer);
	uv_timer_start(&timer, uvc_timer_cb, msec, 0);

	if (env->uv_task == NULL){
		uvc_create("UV_LOOP", UV_TASK_STACK_SIZE, uvc_task_uv, NULL);
	}

	uvc_yield();
	uv_close((uv_handle_t *)&timer, uvc_timer_close_cb);
	uvc_yield();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3720
movq %rax, -0x10(%rbp)
callq 0x3890
movq %rax, -0xa8(%rbp)
callq 0x1520
movq %rax, %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1120
movq -0x8(%rbp), %rdx
leaq -0xa8(%rbp), %rdi
leaq 0x66(%rip), %rsi        # 0x1b30
xorl %eax, %eax
movl %eax, %ecx
callq 0x1210
movq -0x10(%rbp), %rax
cmpq $0x0, 0x140b8(%rax)
jne 0x1afd
leaq 0x25eb(%rip), %rdi      # 0x40d3
movl $0x100000, %esi         # imm = 0x100000
leaq -0x5a4(%rip), %rdx      # 0x1550
xorl %eax, %eax
movl %eax, %ecx
callq 0x19c0
callq 0x1880
leaq -0xa8(%rbp), %rdi
leaq 0x40(%rip), %rsi        # 0x1b50
callq 0x1050
callq 0x1880
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_io_create
int uvc_io_create(uvc_io *io, uvc_io_type_t type)
{
	uv_handle_t *h;
	uvc_thread_env *env = uvc_get_env();
	
	memset(io,0,sizeof(uvc_io));
	switch(type){
	case UVC_IO_TCP:
		h = (uv_handle_t *)malloc(sizeof(uv_tcp_t));
		uv_tcp_init(uvc_loop_default(),(uv_tcp_t *)h);
		//io->cur=ctx;
		io->handle=h;
		break;
	case UVC_IO_FS:
		 h = (uv_handle_t *)malloc(sizeof(uv_fs_t));
		io->handle=h;
		break;

	default:
		assert("unknown handle type");
	}
	if (env->uv_task == NULL){
		uvc_create("UV_LOOP", UV_TASK_STACK_SIZE, uvc_task_uv, NULL);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x3720
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x30(%rax)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1bb8
jmp 0x1bae
movl -0x24(%rbp), %eax
subl $0x3, %eax
je 0x1be5
jmp 0x1c01
movl $0xf8, %edi
callq 0x11d0
movq %rax, -0x18(%rbp)
callq 0x1520
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x11b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1c2c
movl $0x1b8, %edi            # imm = 0x1B8
callq 0x11d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x1c2c
movb $0x1, %al
testb $0x1, %al
jne 0x1c09
jmp 0x1c0b
jmp 0x1c2a
leaq 0x24dd(%rip), %rdi      # 0x40ef
leaq 0x24ec(%rip), %rsi      # 0x4105
movl $0x12a, %edx            # imm = 0x12A
leaq 0x24e6(%rip), %rcx      # 0x410b
callq 0x1110
jmp 0x1c2c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x140b8(%rax)
jne 0x1c56
leaq 0x2492(%rip), %rdi      # 0x40d3
movl $0x100000, %esi         # imm = 0x100000
leaq -0x6fd(%rip), %rdx      # 0x1550
xorl %eax, %eax
movl %eax, %ecx
callq 0x19c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_tcp_bind
int uvc_tcp_bind(uvc_io *io,char *ip,short port){
	int status;
	struct sockaddr_in addr;
	status = uv_ip4_addr(ip,port,&addr);
	if (status){
		return status;
	}
#if OLD_LIBUV
    return uv_tcp_bind((uv_tcp_t*)io->handle,(const struct sockaddr *)&addr);
#else
    return uv_tcp_bind((uv_tcp_t*)io->handle,(const struct sockaddr *)&addr,0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
movswl -0x1a(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x10d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x1c99
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1caf
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x11c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_read
ssize_t uvc_read(uvc_io *io,void *data,size_t len){
	ssize_t nread=0;
	io->buf.base=(char *)data;
	io->buf.len=len;
	io->handle->data=io;
	nread=uv_read_start((uv_stream_t *)io->handle,uvc_alloc_cb,uvc_read_cb);
	if(nread ==UV_EOF){
		return nread;
	}
	io->cur =uvc_self();
	uvc_yield();
	uv_read_stop((uv_stream_t *)io->handle);
	return io->nread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x5e(%rip), %rsi        # 0x1d70
leaq 0x97(%rip), %rdx        # 0x1db0
callq 0x1080
cltq
movq %rax, -0x28(%rbp)
cmpq $-0xfff, -0x28(%rbp)    # imm = 0xF001
jne 0x1d38
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d65
callq 0x3890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1260
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_read_cb
static void uvc_read_cb(uv_stream_t* stream,ssize_t nread,const uv_buf_t* buf)
{
	uvc_io *io= (uvc_io *)stream->data;
	io->buf.base=buf->base;
	io->buf.len=buf->len;
	io->nread=nread;
	uvc_io_ready(io->cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x17e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_read2
ssize_t uvc_read2(uvc_io *io,void *data,size_t len,uint64_t timeout){
	ssize_t nread=0;
	io->buf.base=(char *)data;
	io->buf.len=len;

	uv_timer_t timer;
	timer.data=io;
	io->timeout=0;
	uv_timer_init(uvc_loop_default(),&timer);
	uv_timer_start(&timer,uvc_iotimer_cb,timeout,0);

	nread=uv_read_start((uv_stream_t *)io->handle,uvc_alloc_cb,uvc_read_cb);
	if(nread ==UV_EOF){
		return nread;
	}
	io->cur =uvc_self();
	uvc_yield( );
	uv_read_stop((uv_stream_t *)io->handle);
	if(io->timeout == 0){
		return ETIMEDOUT;
	}
	return io->nread;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
callq 0x1520
movq %rax, %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1120
movq -0x28(%rbp), %rdx
leaq -0xc8(%rbp), %rdi
leaq 0x99(%rip), %rsi        # 0x1f20
xorl %eax, %eax
movl %eax, %ecx
callq 0x1210
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
leaq -0x12f(%rip), %rsi      # 0x1d70
leaq -0xf6(%rip), %rdx       # 0x1db0
callq 0x1080
cltq
movq %rax, -0x30(%rbp)
cmpq $-0xfff, -0x30(%rbp)    # imm = 0xF001
jne 0x1ec5
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f06
callq 0x3890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1260
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x1efa
movq $0x6e, -0x8(%rbp)
jmp 0x1f06
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_write
ssize_t uvc_write(uvc_io *io,void *data,size_t len){
	uv_buf_t buf;
	uv_write_t req;
	ssize_t nwrite=0;
	buf.base=(char *)data;
	buf.len=len;
	req.data=io;
	uv_write(&req,(uv_stream_t *)io->handle,&buf,1,uvc_write_cb);
	io->cur =uvc_self();
	uvc_yield( );
	return (ssize_t)io->return_status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0xf0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0xe8(%rbp), %rdi
leaq -0x28(%rbp), %rdx
movl $0x1, %ecx
leaq 0x34(%rip), %r8         # 0x1ff0
callq 0x10a0
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movslq 0x20(%rax), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_close
void uvc_close(uvc_io *io){
	io->handle->data=io;
	uv_close(io->handle,uvc_close_cb);
	io->cur =uvc_self();
	uvc_yield( );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
leaq 0x26(%rip), %rsi        # 0x2080
callq 0x1050
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_tcp_connect
int uvc_tcp_connect(uvc_io *io,char *ip,short port){
	int status;
	uv_connect_t req;
	struct sockaddr_in addr;
	status = uv_ip4_addr(ip,port,&addr);
	if (status){
		return status;
	}

	req.data = io;
	uv_tcp_connect(&req, (uv_tcp_t *)io->handle, (const struct sockaddr*)&addr, uvc_connect_cb);
	io->cur =uvc_self();
	uvc_yield( );
	return io->return_status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
movswl -0x1a(%rbp), %esi
leaq -0x90(%rbp), %rdx
callq 0x10d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x20ff
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2144
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x2f(%rip), %rcx        # 0x2150
callq 0x1140
callq 0x3890
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_listen
int uvc_listen(uvc_io *io,int backlog){
	io->handle->data=io;
	uv_listen((uv_stream_t *)io->handle,backlog,uvc_connection_cb);
	io->cur =uvc_self();
	uvc_yield( );
	return io->return_status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
leaq 0x30(%rip), %rdx        # 0x21f0
callq 0x1230
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_fs_open
uv_file uvc_fs_open(uvc_io *io,char *path,int flasgs){
	io->handle->data=io;
	uv_fs_open(uvc_loop_default(),(uv_fs_t *)io->handle,path,flasgs,0,uvc_fs_cb);
	io->cur =uvc_self();
	uvc_yield( );
	io->file = ((uv_fs_t *)(io->handle))->result;
	uv_fs_req_cleanup((uv_fs_t *)io->handle);
	return io->file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %r8d, %r8d
leaq 0x4d(%rip), %r9         # 0x22f0
callq 0x10b0
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x58(%rax), %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_fs_read
int uvc_fs_read(uvc_io *io,void *data,ssize_t size){
	io->handle->data=io;
	uv_buf_t buf;
	buf.len=size;
	buf.base=data;
	uv_fs_read(uvc_loop_default(),(uv_fs_t *)io->handle,io->file,&buf,1,-1,uvc_fs_cb);
	io->cur =uvc_self();
	uvc_yield( );
	uv_fs_req_cleanup((uv_fs_t *)io->handle);
	return ((uv_fs_t *)(io->handle))->result;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
leaq -0x28(%rbp), %rcx
movl $0x1, %r8d
movq $-0x1, %r9
leaq -0x92(%rip), %rax       # 0x22f0
movq %rax, (%rsp)
callq 0x1090
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x58(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_fs_write
int uvc_fs_write(uvc_io *io,void *data,ssize_t size){
    uv_buf_t buf;
	io->handle->data=io;
    buf.len=size;
    buf.base=data;
	uv_fs_write(uvc_loop_default() ,(uv_fs_t *)io->handle,io->file,&buf,1,-1,uvc_fs_cb);
	io->cur =uvc_self();
	uvc_yield( );
	return ((uv_fs_t *)(io->handle))->result;;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
leaq -0x28(%rbp), %rcx
movl $0x1, %r8d
movq $-0x1, %r9
leaq -0x132(%rip), %rax      # 0x22f0
movq %rax, (%rsp)
callq 0x1040
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x58(%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_fs_close
int uvc_fs_close(uvc_io *io){
	io->handle->data=io;
	uv_fs_close(uvc_loop_default(),(uv_fs_t *)io->handle,io->file,uvc_fs_cb);
	io->cur =uvc_self();
	uvc_yield();
	uv_fs_req_cleanup((uv_fs_t *)io->handle);
	free(io->handle);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x34(%rax), %edx
leaq -0x1a9(%rip), %rcx      # 0x22f0
callq 0x1060
callq 0x3890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x1880
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x10e0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_fs_stat
int uvc_fs_stat( char *path,uv_stat_t *statbuf){
	uv_fs_t req;
	req.data=uvc_self();
	uv_fs_stat(uvc_loop_default(),&req,path,uvc_fs_cb2);

	uvc_yield();
	memcpy(statbuf,&req.statbuf,sizeof(uv_stat_t));
	uv_fs_req_cleanup(&req);
	return req.result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3890
movq %rax, -0x1c8(%rbp)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rdx
leaq -0x1c8(%rbp), %rsi
leaq 0x47(%rip), %rcx        # 0x2560
callq 0x1160
callq 0x1880
movq -0x10(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
addq $0x70, %rsi
movl $0xa0, %edx
callq 0x1190
leaq -0x1c8(%rbp), %rdi
callq 0x10e0
movq -0x170(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_queue_work
int uvc_queue_work( uv_work_cb cb){
	uv_work_t req;
	req.data=uvc_self();
	uv_queue_work(uvc_loop_default(),&req,cb,uvc_after_work_cb);
	uvc_yield();
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3890
movq %rax, -0x88(%rbp)
callq 0x1520
movq %rax, %rdi
movq -0x8(%rbp), %rdx
leaq -0x88(%rbp), %rsi
leaq 0x1b(%rip), %rcx        # 0x25e0
callq 0x11a0
callq 0x1880
xorl %eax, %eax
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_is_closed
int channel_is_closed(channel_t c){
	channel *chan = channel_pool_get(get_chan_pool(),c);
	if(chan!=NULL && chan->id == c){
		return 1;
	} 
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
callq 0x38c0
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x2660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x264b
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x264b
movl $0x1, -0x4(%rbp)
jmp 0x2652
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_pool_get
static channel *channel_pool_get(channel_pool *pool, channel_t i){
	channel *chan = pool->channels[(i) % MAX_CHANNEL_POOL];
	if (chan && chan->id == i){
		return chan;
	}
	return NULL;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl $0x2800, %ecx           # imm = 0x2800
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movslq %edx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x26ab
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x26ab
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26b3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_create
channel_t channel_create(int cnt,int elem_size){

	channel *c=NULL;
	int idx=0;
	channel_pool *pool=get_chan_pool();
	idx=find_empty_slot(pool);
	if(idx<0){
		return -1;
	}
	c=malloc(sizeof(channel) +(elem_size*cnt));
	memset(c,0,sizeof(channel));
	c->size=elem_size;
	c->cnt=cnt;
	c->id = idx;
	queue_init(&c->readq);
	queue_init(&c->writq);
	
	channel_pool_put(pool,idx,c);
	return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x38c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x27d0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x2704
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x27bf
movl -0xc(%rbp), %eax
imull -0x8(%rbp), %eax
movslq %eax, %rdi
addq $0x58, %rdi
callq 0x11d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x1150
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
addq $0x38, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
addq $0x38, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2800, %ecx           # imm = 0x2800
cltd
idivl %ecx
movq -0x38(%rbp), %rax
movl %edx, %ecx
movq -0x30(%rbp), %rdx
movslq %ecx, %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: find_empty_slot
static int find_empty_slot(channel_pool *pool){
	int i=0;

	for (i = pool->current_empty + 1; i != pool->current_empty; i++){
		pool->maxid++;
		if(channel_pool_get(pool,i)==NULL){
			pool->current_empty = i;
			return pool->maxid;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x283b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2660
cmpq $0x0, %rax
jne 0x282e
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2842
jmp 0x2830
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x27ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_close
int channel_close(channel_t c){
	channel_pool *pool=get_chan_pool();
	channel *chan;
	uvc_ctx *ctx;
	uvc_ctx *ctx_self =uvc_self();
	chan=channel_pool_get(pool,c);
	if(chan == NULL ||chan->id !=c || chan->closeing==1){
		return -1;
	}
	chan->closeing=1;
	
	
	//唤醒所有发送队列，让发生者知道已经发送失败。
	do
    {
        if(queue_empty(&chan->writq) )break;
		ctx = channel_queue_get(&chan->writq);
		uvc_ready(ctx);
		uvc_ready(ctx_self);
		uvc_yield();
    }while(1);


	//如果chanbuf中还有数据，那么不能立即关闭管道，
	//否则发送放无法获知释放已经送达数据。
	if (chanbuf_empty(chan) && queue_empty(&chan->readq)){
		channel_pool_remove(pool, c);
		free(chan); 
	}else{
		do
	    {
	        if(queue_empty(&chan->readq) )break;
			ctx = channel_queue_get(&chan->readq);
			if (ctx!=ctx_self){
				printf("channel closeing,wakeup task[%s]\n",ctx->name);
				uvc_ready(ctx);
				uvc_ready(ctx_self);
				uvc_yield();
			}
	    }while(1);
	}
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
callq 0x38c0
movq %rax, -0x10(%rbp)
callq 0x3890
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x8(%rbp), %esi
callq 0x2660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x289a
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x289a
movq -0x18(%rbp), %rax
cmpl $0x1, 0x50(%rax)
jne 0x28a6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29b2
movq -0x18(%rbp), %rax
movl $0x1, 0x50(%rax)
movq -0x18(%rbp), %rax
addq $0x38, %rax
movq -0x18(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x28c5
jmp 0x28f5
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x29c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18c0
movq -0x28(%rbp), %rdi
callq 0x18c0
callq 0x1880
movb $0x1, %al
testb $0x1, %al
jne 0x28b1
jmp 0x28f5
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x2945
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x2945
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x8(%rbp), %eax
movl $0x2800, %ecx           # imm = 0x2800
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movslq %edx, %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x29ab
jmp 0x2947
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x295b
jmp 0x29a9
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x29c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x299f
movq -0x20(%rbp), %rsi
leaq 0x17b5(%rip), %rdi      # 0x4136
movb $0x0, %al
callq 0x1100
movq -0x20(%rbp), %rdi
callq 0x18c0
movq -0x28(%rbp), %rdi
callq 0x18c0
callq 0x1880
jmp 0x29a1
movb $0x1, %al
testb $0x1, %al
jne 0x2947
jmp 0x29a9
jmp 0x29ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_queue_get
static uvc_ctx *channel_queue_get(queue_t *q){
	queue_t *node = NULL;
	node = queue_last(q);
	queue_remove(node);
	/*is selected*/
	if (node->ext == NULL){
		return queue_data(node, uvc_ctx, i_node);
	}
	else{
		return (uvc_ctx *)node->ext;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2a1b
movq -0x18(%rbp), %rax
addq $-0x100, %rax
movq %rax, -0x8(%rbp)
jmp 0x2a27
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_write
int channel_write(channel_t c,void *buf){
	channel *chan = NULL;
	uvc_ctx *ctx;
	void *p=NULL;
	chan = channel_pool_get(get_chan_pool(), c);
	if(chan == NULL ||chan->id !=c || chan->closeing==1){
		return -1;
	}

	if(!chanbuf_full(chan)){
		//buffered channel,and buffer not full
		chanbuf_push(chan, buf);
		if(!queue_empty(&chan->readq)){
			ctx = channel_queue_get(&chan->readq);
			uvc_ready(ctx);
		}
		//写入buffer的数据不管
		return 0;
	}else{
		ctx = uvc_self();
		ctx->cbuf = buf;
		channel_queue_put(&chan->writq, ctx);
		//当readq不为空的时候，writeq一定为空
		if(queue_empty(&chan->readq)){
			uvc_yield();
		}else{
			ctx = channel_queue_get(&chan->readq);
			uvc_ready(ctx);
		}
	}
	//检查管道释放
	if(chan == NULL ||chan->id !=c || chan->closeing==1){
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
callq 0x38c0
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x2660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2a80
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2a80
movq -0x18(%rbp), %rax
cmpl $0x1, 0x50(%rax)
jne 0x2a8c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2b92
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a9f
movb $0x1, %al
testb $0x1, %al
jne 0x2b07
jmp 0x2ac2
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
cltq
movq -0x18(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq -0x18(%rbp), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %rdx
je 0x2b07
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2ba0
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x2afb
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x29c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18c0
movl $0x0, -0x4(%rbp)
jmp 0x2b92
callq 0x3890
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x2c40
movq -0x18(%rbp), %rax
addq $0x20, %rax
movq -0x18(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x2b49
callq 0x1880
jmp 0x2b63
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x29c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x18c0
jmp 0x2b65
cmpq $0x0, -0x18(%rbp)
je 0x2b82
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x2b82
movq -0x18(%rbp), %rax
cmpl $0x1, 0x50(%rax)
jne 0x2b8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2b92
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_readable
int channel_readable(channel_t c){
	channel *chan = NULL;
	chan=channel_pool_get(get_chan_pool(),c);
	if(chan == NULL||chan->id !=c)return -1;
	if (!queue_empty(&chan->writq) || !chanbuf_empty(chan)){
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x38c0
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x2660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2f2a
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x2f33
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2f65
movq -0x10(%rbp), %rax
addq $0x38, %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x2f55
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x2f5e
movl $0x1, -0x4(%rbp)
jmp 0x2f65
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_writeable
int channel_writeable(channel_t c){
	channel *chan = NULL;
	chan = channel_pool_get(get_chan_pool(), c);
	if(chan == NULL||chan->id !=c)return -1;
	if (!queue_empty(&chan->readq) || !chanbuf_full(chan)){
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x38c0
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x2660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2faa
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x2fb3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x300b
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x2ffb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2fd8
movb $0x1, %al
testb $0x1, %al
jne 0x3004
jmp 0x2ffb
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
cltq
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rax
cmpq %rax, %rdx
je 0x3004
movl $0x1, -0x4(%rbp)
jmp 0x300b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: channel_select_remove
int channel_select_remove(channel *chan){
	uvc_ctx *ctx=uvc_self();
	//queue_t *node;
	queue_t *q = queue_head(&chan->readq);  
   for (; q != queue_sentinel(&chan->readq); q = queue_next(&chan->readq))  {
   		if(q->ext == ctx){
   			queue_remove(q);
   		}
   }

   for (; q != queue_sentinel(&chan->writq); q = queue_next(&chan->writq))  {
   		if(q->ext == ctx){
   			queue_remove(q);
   		}
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3890
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
je 0x3095
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3085
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3087
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3041
jmp 0x3097
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
je 0x30eb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x30db
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x30dd
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3097
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/whtc123[P]libuvc/uvc.c
// Function: uvc_get_env
static uvc_thread_env *uvc_get_env(){
	uvc_ctx *ctx = NULL;
	uv_once(&once,uvc_init);
	uvc_thread_env *env=(uvc_thread_env *)uv_key_get(&uvc_key);
	if(env==NULL){
		env=(uvc_thread_env *)malloc(sizeof(uvc_thread_env));
		memset(env,0,sizeof(uvc_thread_env));
		env->loop = uv_loop_new();
		queue_init(&env->pending_queue);
		queue_init(&env->ready_queue);
		
		ctx = (uvc_ctx *)malloc(sizeof(uvc_ctx));
		memset(ctx, 0, sizeof(uvc_ctx));
		coro_stack_alloc(&ctx->stack, 0);
		coro_create(&ctx->cur, NULL, NULL, ctx->stack.sptr, ctx->stack.ssze);
		sprintf(ctx->name, "ROOT");
		env->schedule_task = ctx;
		env->runing_task = ctx;
		ctx->status = UVC_STATUS_RUNING;
		uv_key_set(&uvc_key,env);
	}
	return env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
leaq 0x16a41(%rip), %rdi     # 0x1a178
leaq -0x223e(%rip), %rsi     # 0x1500
callq 0x1180
leaq 0x2a16(%rip), %rdi      # 0x6160
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3882
movl $0x14100, %edi          # imm = 0x14100
callq 0x11d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x14100, %edx          # imm = 0x14100
callq 0x1150
callq 0x11e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x140e8, %rcx          # imm = 0x140E8
movq -0x10(%rbp), %rax
movq %rcx, 0x140e8(%rax)
movq -0x10(%rbp), %rcx
addq $0x140e8, %rcx          # imm = 0x140E8
movq -0x10(%rbp), %rax
movq %rcx, 0x140f0(%rax)
movq -0x10(%rbp), %rcx
addq $0x140d0, %rcx          # imm = 0x140D0
movq -0x10(%rbp), %rax
movq %rcx, 0x140d0(%rax)
movq -0x10(%rbp), %rcx
addq $0x140d0, %rcx          # imm = 0x140D0
movq -0x10(%rbp), %rax
movq %rcx, 0x140d8(%rax)
movl $0x140, %edi            # imm = 0x140
callq 0x11d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x140, %edx            # imm = 0x140
callq 0x1150
movq -0x8(%rbp), %rdi
addq $0x50, %rdi
xorl %esi, %esi
callq 0x3a20
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x58(%rax), %r8
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x3900
movq -0x8(%rbp), %rdi
leaq 0x952(%rip), %rsi       # 0x4191
movb $0x0, %al
callq 0x1240
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x140c0(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x140c8(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x130(%rax)
movq -0x10(%rbp), %rsi
leaq 0x28e3(%rip), %rdi      # 0x6160
callq 0x1070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)