LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsp, %rax
movq %rsi, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x10f0
testl %eax, %eax
jne 0x1e90
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
movq 0x28(%rbx), %rsi
leaq 0x40(%rip), %rcx        # 0x1e96
movq %rsp, %rdx
callq 0x1160
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movl 0x20(%rbx), %eax
addq $0x70, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq %rbx, (%rdi)
leaq 0x39(%rip), %rdx        # 0x1f39
callq 0x1250
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movl 0x20(%rbx), %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/whtc123[P]libuvc/uvc.c
// Function: uvc_connection_cb
static void uvc_connection_cb(uv_stream_t* server, int status)
{

	uvc_io *io=(uvc_io *)server->data;
	//uvc_io *io=((uvc_io*)(((char*)(server)) - offsetof(uvc_io, handle)));
	io->return_status=status;
	uvc_io_ready(io->cur);
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movl %esi, 0x20(%rax)
movq (%rax), %rbx
callq 0x3031
leaq 0x140d0(%rax), %rcx
movq 0x140d8(%rax), %rdx
leaq 0x118(%rbx), %rsi
movq %rdx, 0x120(%rbx)
movq %rsi, (%rdx)
movq %rcx, 0x118(%rbx)
movq %rsi, 0x140d8(%rax)
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
popq %rbx
jmp 0x312c
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rdi, (%rax)
callq 0x3031
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
leaq 0x53(%rip), %r9         # 0x2017
movq %r14, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x10d0
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movq 0x28(%rbx), %rdi
movl 0x58(%rdi), %eax
movl %eax, 0x34(%rbx)
callq 0x1100
movl 0x34(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rdi, (%rax)
leaq 0x8(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rsi, (%r14)
callq 0x3031
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
movl 0x34(%rbx), %edx
leaq -0x88(%rip), %rax       # 0x2017
movq %rax, (%rsp)
movq %r14, %rcx
movl $0x1, %r8d
movq $-0x1, %r9
callq 0x10b0
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rax
movl 0x58(%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rdi, (%rax)
leaq 0x8(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rsi, (%r14)
callq 0x3031
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
movl 0x34(%rbx), %edx
leaq -0x11b(%rip), %rax      # 0x2017
movq %rax, (%rsp)
movq %r14, %rcx
movl $0x1, %r8d
movq $-0x1, %r9
callq 0x1040
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movq 0x28(%rbx), %rax
movl 0x58(%rax), %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movq %rdi, (%rax)
callq 0x3031
movq (%rax), %rdi
movq 0x28(%rbx), %rsi
movl 0x34(%rbx), %edx
leaq -0x193(%rip), %rcx      # 0x2017
callq 0x1080
callq 0x3031
movq 0x140c8(%rax), %rax
movq %rax, (%rbx)
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
movq 0x28(%rbx), %rdi
callq 0x1100
movq 0x28(%rbx), %rdi
callq 0x1030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3031
movq 0x140c8(%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
callq 0x3031
movq (%rax), %rdi
leaq 0x59(%rip), %rcx        # 0x2282
movq %r14, %rsi
movq %r15, %rdx
callq 0x1180
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
leaq 0x78(%rsp), %r15
movl $0xa0, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11b0
movq %r14, %rdi
callq 0x1100
movl -0x18(%r15), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x3031
movq 0x140c8(%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
callq 0x3031
movq (%rax), %rdi
leaq 0x38(%rip), %rcx        # 0x233c
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11c0
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
callq 0x3031
movslq %ebx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2c, %rdx
addl %esi, %edx
shll $0xb, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rcx
testq %rcx, %rcx
je 0x23c7
cmpl %ebx, 0x10(%rcx)
je 0x23c9
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x23d8
movl $0x1, %eax
cmpl %ebx, 0x10(%rcx)
je 0x23da
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %r14d
callq 0x3031
movq %rax, %rbx
movl 0x10(%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl $0x1, %eax
jb 0x2444
movl %edx, %ecx
leal 0x1(%rcx), %edx
movl 0x14(%rbx), %ebp
incl %ebp
movl %ebp, 0x14(%rbx)
movslq %edx, %rsi
imulq $0x66666667, %rsi, %rdi # imm = 0x66666667
movq %rdi, %r8
shrq $0x3f, %r8
sarq $0x2c, %rdi
addl %r8d, %edi
shll $0xb, %edi
leal (%rdi,%rdi,4), %edi
subl %edi, %esi
movslq %esi, %rsi
movq 0x18(%rbx,%rsi,8), %rsi
testq %rsi, %rsi
je 0x243d
cmpl 0x10(%rsi), %edx
je 0x23f9
incl %ecx
movl %ecx, 0x10(%rbx)
jmp 0x2449
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %ebp, %ebp
js 0x24c6
movl %r15d, %eax
imull %r14d, %eax
movslq %eax, %rdi
addq $0x58, %rdi
callq 0x11f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movq $0x0, 0x50(%rax)
leaq 0x20(%rax), %rcx
movslq %r15d, %rdx
movq %rdx, (%rax)
movslq %r14d, %rdx
movq %rdx, 0x8(%rax)
movl %ebp, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
leaq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq %rcx, 0x40(%rax)
movl %ebp, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
imulq %rcx, %rdx
shrq $0x2d, %rdx
shll $0xb, %edx
leal (%rdx,%rdx,4), %ecx
movl %ebp, %edx
subl %ecx, %edx
movq %rax, 0x18(%rbx,%rdx,8)
jmp 0x24cb
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebx
callq 0x3031
movslq %ebx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2c, %rdx
addl %esi, %edx
shll $0xb, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %r15
testq %r15, %r15
je 0x2791
cmpl %ebx, 0x10(%r15)
je 0x2794
xorl %r15d, %r15d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %r15, %r15
je 0x293d
cmpl %ebx, 0x10(%r15)
jne 0x293d
cmpl $0x1, 0x50(%r15)
je 0x293d
movq 0x8(%r15), %rsi
testq %rsi, %rsi
je 0x27da
movslq 0x18(%r15), %rcx
leaq 0x1(%rcx), %rax
xorl %edx, %edx
divq %rsi
movslq 0x14(%r15), %rax
cmpq %rax, %rdx
jne 0x287c
callq 0x3031
movq 0x140c8(%rax), %rax
movq %r14, 0x138(%rax)
leaq 0x38(%r15), %rcx
movq 0x40(%r15), %rdx
leaq 0x100(%rax), %rsi
movq %rdx, 0x108(%rax)
movq %rsi, (%rdx)
movq %rcx, 0x100(%rax)
movq %rsi, 0x40(%r15)
leaq 0x20(%r15), %rax
movq 0x20(%r15), %r14
cmpq %r14, %rax
je 0x290a
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%r14), %rax
addq $-0x100, %r14
testq %rax, %rax
cmovneq %rax, %r14
callq 0x3031
leaq 0x140d0(%rax), %rcx
movq 0x140d8(%rax), %rdx
leaq 0x118(%r14), %rsi
movq %rdx, 0x120(%r14)
movq %rsi, (%rdx)
movq %rcx, 0x118(%r14)
movq %rsi, 0x140d8(%rax)
jmp 0x292a
movq (%r15), %rdx
imulq %rdx, %rcx
leaq (%r15,%rcx), %rdi
addq $0x54, %rdi
movq %r14, %rsi
callq 0x11b0
movslq 0x18(%r15), %rax
incq %rax
xorl %edx, %edx
divq 0x8(%r15)
movl %edx, 0x18(%r15)
movq 0x20(%r15), %rbx
addq $0x20, %r15
cmpq %rbx, %r15
je 0x2906
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movq (%rbx), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rax
addq $-0x100, %rbx
testq %rax, %rax
cmovneq %rax, %rbx
callq 0x3031
leaq 0x140d0(%rax), %rcx
movq 0x140d8(%rax), %rdx
leaq 0x118(%rbx), %rsi
movq %rdx, 0x120(%rbx)
movq %rsi, (%rdx)
movq %rcx, 0x118(%rbx)
movq %rsi, 0x140d8(%rax)
xorl %ebp, %ebp
jmp 0x293d
callq 0x3031
movq 0x140c0(%rax), %rsi
movq 0x140c8(%rax), %rdi
addq $0x48, %rdi
addq $0x48, %rsi
callq 0x312c
cmpl %ebx, 0x10(%r15)
jne 0x293d
xorl %ebp, %ebp
cmpl $0x1, 0x50(%r15)
sete %bpl
negl %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
callq 0x3031
movslq %ebx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2c, %rdx
addl %esi, %edx
shll $0xb, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rcx
testq %rcx, %rcx
je 0x2b93
cmpl %ebx, 0x10(%rcx)
je 0x2b95
xorl %ecx, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
je 0x2bbe
cmpl %ebx, 0x10(%rcx)
jne 0x2bbe
leaq 0x38(%rcx), %rdx
movl $0x1, %eax
cmpq 0x38(%rcx), %rdx
jne 0x2bbe
movl 0x14(%rcx), %edx
xorl %eax, %eax
cmpl 0x18(%rcx), %edx
setne %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
callq 0x3031
movslq %ebx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rsi
shrq $0x3f, %rsi
sarq $0x2c, %rdx
addl %esi, %edx
shll $0xb, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x18(%rax,%rcx,8), %rsi
testq %rsi, %rsi
je 0x2bf9
cmpl %ebx, 0x10(%rsi)
je 0x2bfb
xorl %esi, %esi
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rsi, %rsi
je 0x2c39
cmpl %ebx, 0x10(%rsi)
jne 0x2c39
leaq 0x20(%rsi), %rax
movl $0x1, %ecx
cmpq 0x20(%rsi), %rax
jne 0x2c39
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x2c37
movslq 0x18(%rsi), %rax
incq %rax
xorl %edx, %edx
divq %rdi
movslq 0x14(%rsi), %rax
cmpq %rax, %rdx
jne 0x2c39
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x3031
movq 0x140c8(%rax), %rax
leaq 0x20(%rbx), %rdx
movq 0x28(%rbx), %rcx
cmpq %rdx, %rcx
je 0x2c73
cmpq %rax, 0x10(%rcx)
jne 0x2c51
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
movq %rsi, (%rdi)
movq (%rcx), %rcx
movq %rdi, 0x8(%rcx)
jmp 0x2c51
leaq 0x38(%rbx), %rdx
cmpq %rdx, %rcx
je 0x2c99
cmpq %rax, 0x10(%rcx)
jne 0x2c93
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
movq %rsi, (%rdi)
movq (%rcx), %rcx
movq %rdi, 0x8(%rcx)
movq 0x40(%rbx), %rcx
jmp 0x2c77
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x1714c(%rip), %rdi     # 0x1a188
leaq -0x1b5b(%rip), %rsi     # 0x14e8
callq 0x11a0
leaq 0x3121(%rip), %rdi      # 0x6170
callq 0x1150
movq %rax, %rbx
testq %rax, %rax
jne 0x311e
movl $0x14100, %edi          # imm = 0x14100
callq 0x11f0
movq %rax, %rbx
movl $0x14100, %edx          # imm = 0x14100
movq %rax, %rdi
xorl %esi, %esi
callq 0x1170
callq 0x1200
movq %rax, (%rbx)
leaq 0x140e8(%rbx), %rax
movq %rax, 0x140e8(%rbx)
movq %rax, 0x140f0(%rbx)
leaq 0x140d0(%rbx), %rax
movq %rax, 0x140d0(%rbx)
movq %rax, 0x140d8(%rbx)
movl $0x140, %edi            # imm = 0x140
callq 0x11f0
movq %rax, %r14
movl $0x140, %edx            # imm = 0x140
movq %rax, %rdi
xorl %esi, %esi
callq 0x1170
leaq 0x50(%r14), %rdi
xorl %esi, %esi
callq 0x31f8
leaq 0x48(%r14), %rdi
movq 0x50(%r14), %rcx
movq 0x58(%r14), %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x3149
movb $0x0, 0x4(%r14)
movl $0x544f4f52, (%r14)     # imm = 0x544F4F52
movq %r14, 0x140c0(%rbx)
movq %r14, 0x140c8(%rbx)
movl $0x3, 0x130(%r14)
leaq 0x305a(%rip), %rdi      # 0x6170
movq %rbx, %rsi
callq 0x1090
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/whtc123[P]libuvc/coro.c
// Function: coro_stack_alloc
int
coro_stack_alloc (struct coro_stack *stack, unsigned int size)
{
  if (!size)
    size = 256 * 1024;

  stack->sptr = 0;
  stack->ssze = ((size_t)size * sizeof (void *) + PAGESIZE - 1) / PAGESIZE * PAGESIZE;

#if CORO_FIBER

  stack->sptr = (void *)stack;
  return 1;

#else

  size_t ssze = stack->ssze + CORO_GUARDPAGES * PAGESIZE;
  void *base;

  #if CORO_MMAP
    /* mmap supposedly does allocate-on-write for us */
    base = mmap (0, ssze, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

    if (base == (void *)-1)
      {
        /* some systems don't let us have executable heap */
        /* we assume they won't need executable stack in that case */
        base = mmap (0, ssze, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

        if (base == (void *)-1)
          return 0;
      }

    #if CORO_GUARDPAGES
      mprotect (base, CORO_GUARDPAGES * PAGESIZE, PROT_NONE);
    #endif

    base = (void*)((char *)base + CORO_GUARDPAGES * PAGESIZE);
  #else
    base = malloc (ssze);
    if (!base)
      return 0;
  #endif

  #if CORO_USE_VALGRIND
    stack->valgrind_id = VALGRIND_STACK_REGISTER ((char *)base, ((char *)base) + ssze - CORO_GUARDPAGES * PAGESIZE);
  #endif

  stack->sptr = base;
  return 1;

#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
movl $0x40000, %r14d         # imm = 0x40000
cmovnel %esi, %r14d
movq $0x0, (%rdi)
shlq $0x3, %r14
cmpq $0x0, 0x16f8e(%rip)     # 0x1a1b0
jne 0x3235
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16f7b(%rip)     # 0x1a1b0
movq 0x16f74(%rip), %rax     # 0x1a1b0
addq %rax, %r14
decq %r14
testq %rax, %rax
jne 0x3258
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16f58(%rip)     # 0x1a1b0
movq 0x16f51(%rip), %rcx     # 0x1a1b0
xorl %r15d, %r15d
movq %r14, %rax
xorl %edx, %edx
divq %rcx
subq %rdx, %r14
movq %r14, 0x8(%rbx)
leaq (%r14,%rcx,4), %r12
xorl %edi, %edi
movq %r12, %rsi
movl $0x7, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1110
cmpq $-0x1, %rax
jne 0x32bb
xorl %edi, %edi
movq %r12, %rsi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x1110
cmpq $-0x1, %rax
je 0x331d
movq %rax, %r14
cmpq $0x0, 0x16eea(%rip)     # 0x1a1b0
jne 0x32d9
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16ed7(%rip)     # 0x1a1b0
movq 0x16ed0(%rip), %rsi     # 0x1a1b0
shlq $0x2, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1220
cmpq $0x0, 0x16eba(%rip)     # 0x1a1b0
jne 0x3309
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16ea7(%rip)     # 0x1a1b0
movq 0x16ea0(%rip), %rax     # 0x1a1b0
leaq (%r14,%rax,4), %rax
movq %rax, (%rbx)
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/whtc123[P]libuvc/coro.c
// Function: coro_stack_free
void
coro_stack_free (struct coro_stack *stack)
{
#if CORO_FIBER
  /* nop */
#else
  #if CORO_USE_VALGRIND
    VALGRIND_STACK_DEREGISTER (stack->valgrind_id);
  #endif

  #if CORO_MMAP
    if (stack->sptr)
      munmap ((void*)((char *)stack->sptr - CORO_GUARDPAGES * PAGESIZE),
              stack->ssze                 + CORO_GUARDPAGES * PAGESIZE);
  #else
    free (stack->sptr);
  #endif
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x339c
movq %rdi, %r14
cmpq $0x0, 0x16e6d(%rip)     # 0x1a1b0
jne 0x3356
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16e5a(%rip)     # 0x1a1b0
movq 0x16e53(%rip), %rax     # 0x1a1b0
leaq (,%rax,4), %rcx
subq %rcx, %rbx
movq 0x8(%r14), %r14
testq %rax, %rax
jne 0x3382
movl $0x1e, %edi
callq 0x1240
movq %rax, 0x16e2e(%rip)     # 0x1a1b0
movq 0x16e27(%rip), %rax     # 0x1a1b0
leaq (%r14,%rax,4), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1210
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/rasm.cpp
// Function: parse_opt(int, char**)
void parse_opt(int argc, char *argv[])
{
	int idx = cmdopt_parse(argc, argv, opts);
	if (idx)
		throw option_error(string(argv[idx]) + ": can't parse");
	if (help_opt) {
		cmdopt_print(opts);
		std::exit(0);
	}
	if (inname.empty())
		throw option_error("input file not specified");
	if (outname.empty())
		throw option_error("output file not specified");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0xfa20(%rip), %rdx      # 0x13c60
callq 0xd3e0
testl %eax, %eax
jne 0x427d
cmpl $0x0, 0x100c8(%rip)     # 0x14318
jne 0x42db
cmpq $0x0, 0x10082(%rip)     # 0x142e0
je 0x42ee
cmpq $0x0, 0x10094(%rip)     # 0x14300
je 0x4353
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
movslq %ebp, %rax
movq (%r14,%rax,8), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x49a2
leaq 0x9d63(%rip), %rsi      # 0xe00c
leaq 0x28(%rsp), %rdi
callq 0x3500
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x43b5
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x43c2
leaq 0xf97e(%rip), %rdi      # 0x13c60
callq 0xd581
xorl %edi, %edi
callq 0x32d0
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9d0f(%rip), %rsi      # 0xe01a
leaq 0x9d20(%rip), %rdx      # 0xe032
leaq 0x8(%rsp), %rdi
callq 0x4f06
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32f0
leaq 0xf9cd(%rip), %rax      # 0x13d00
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf981(%rip), %rsi      # 0x13cc0
movq 0xfc72(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x3480
jmp 0x440b
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9cc3(%rip), %rsi      # 0xe033
leaq 0x9cd5(%rip), %rdx      # 0xe04c
leaq 0x8(%rsp), %rdi
callq 0x4f06
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x32f0
leaq 0xf968(%rip), %rax      # 0x13d00
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf91c(%rip), %rsi      # 0x13cc0
movq 0xfc0d(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x3480
jmp 0x440b
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x32f0
leaq 0xf910(%rip), %rax      # 0x13d00
movq %rax, (%rbx)
xorl %ebp, %ebp
leaq 0xf8c4(%rip), %rsi      # 0x13cc0
movq 0xfbb5(%rip), %rdx      # 0x13fb8
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x442d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x442d
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x446a
movq 0x38(%rsp), %rsi
jmp 0x4458
jmp 0x4446
jmp 0x4464
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x446a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x446a
jmp 0x4464
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x4477
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/scanner.cpp
// Function: scanner::next(tok)
void scanner::next(tok expected)
{
	tok t = next();
	if (expected != t)
		throw error(tokname(t) + " encountered, but "
				+ tokname(expected) + " expected");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %esi, %ebp
callq 0x56b4
cmpl %ebp, %eax
jne 0x604e
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
movl %r14d, %esi
callq 0x4fc8
leaq 0x815a(%rip), %rsi      # 0xe1cc
leaq 0x60(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x609d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x60a9
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x40(%rsp), %rdi
movl %ebp, %esi
callq 0x4fc8
leaq 0x80(%rsp), %rdi
movq %rsp, %rsi
leaq 0x40(%rsp), %rdx
callq 0x6be6
leaq 0x8107(%rip), %rsi      # 0xe1f0
leaq 0x80(%rsp), %rdi
callq 0x3500
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6119
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x6126
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xde9a(%rip), %rsi      # 0x13ff0
movq 0xde53(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6187
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6187
movq %rax, %r14
movb $0x1, %bpl
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61b0
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x61b0
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61d3
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x61d3
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x61f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x61f1
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6214
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6214
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6221
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/scanner.cpp
// Function: scanner::string_pair[abi:cxx11]() const
std::pair<string, string> scanner::string_pair() const
{
	auto pos = s.find(STRING_DELIM);
	if (pos == string::npos)
		throw error(s + ": compound string expected");
	return { s.substr(0, pos), s.substr(pos) };
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %r14
movq %r14, %rdi
movl $0x40, %esi
xorl %edx, %edx
callq 0x3310
cmpq $-0x1, %rax
je 0x63f7
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3280
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq $-0x1, %rcx
callq 0x3280
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x637c
movq %rdx, (%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x6382
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x30(%rbx), %rcx
movq %rcx, 0x20(%rbx)
leaq 0x38(%rsp), %rdx
movq -0x10(%rdx), %rsi
cmpq %rdx, %rsi
je 0x63c3
movq %rsi, 0x20(%rbx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x30(%rbx)
jmp 0x63c9
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rsp), %rcx
movq %rcx, 0x28(%rbx)
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x63e9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x7dd4(%rip), %rdx      # 0xe1df
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x49df
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xdbbf(%rip), %rsi      # 0x13ff0
movq 0xdb78(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6466
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6466
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6493
movq %rbx, %rdi
callq 0x31f0
jmp 0x6493
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6493
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/scanner.cpp
// Function: void convert<int>(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void convert(T &val, const string &s)
{
	std::size_t pos;
	long num = std::stol(s, &pos, 0);
	if (pos < s.size())
		throw error("wrong int:" + s);
	if (num < numeric_limits<T>::min()
			or num > numeric_limits<T>::max())
		throw error("int out of range: " + s);
	val = static_cast<T>(num);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
callq 0x3030
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3380
movq (%r13), %rcx
subq %r12, %rcx
je 0x68b2
movl (%r14), %edx
cmpl $0x22, %edx
je 0x68be
testl %edx, %edx
jne 0x6892
movl %ebp, (%r14)
cmpq 0x8(%rbx), %rcx
jb 0x68ca
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x6915
movl %eax, (%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7972(%rip), %rdi      # 0xe22b
callq 0x3190
leaq 0x7966(%rip), %rdi      # 0xe22b
callq 0x33c0
movl $0x10, %edi
callq 0x3150
movq %rax, %r14
leaq 0x792f(%rip), %rsi      # 0xe20d
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x67b9
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd6ec(%rip), %rsi      # 0x13ff0
movq 0xd6a5(%rip), %rdx      # 0x13fb0
movq %r14, %rdi
callq 0x3480
jmp 0x695e
movl $0x10, %edi
callq 0x3150
movq %rax, %r14
leaq 0x78ef(%rip), %rsi      # 0xe218
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x67b9
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xd6a1(%rip), %rsi      # 0x13ff0
movq 0xd65a(%rip), %rdx      # 0x13fb0
movq %r14, %rdi
callq 0x3480
jmp 0x6962
jmp 0x6982
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6988
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x6988
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x69a3
movq %r14, %rdi
callq 0x31f0
jmp 0x69a3
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x69a3
movl %ebp, (%r14)
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: vartbl::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void vartbl::add(const string &s)
{
	auto slot = map.size();
	if (slot > std::numeric_limits<addr>::max())
		throw error(string("table ") + name + " overflow");
	addr a = static_cast<addr>(slot);
	addrmap::add(s, a);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %r14
movq 0x38(%rdi), %rax
cmpq $0x100, %rax            # imm = 0x100
jae 0x779a
movzbl %al, %edx
movq %r14, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x88f4
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6b8f(%rip), %rsi      # 0xe346
leaq 0x6b8e(%rip), %rdx      # 0xe34c
leaq 0x20(%rsp), %rdi
callq 0x4f06
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x889a
leaq 0x6b78(%rip), %rsi      # 0xe359
leaq 0x40(%rsp), %rdi
callq 0x3500
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x780e
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x781a
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc7a8(%rip), %rsi      # 0x13ff0
movq 0xc761(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7878
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7878
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x789b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x789b
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x78ba
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x78ba
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x78c7
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: symbols::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto symbols::add(const string &s) -> addr
{
	auto it = tbl.find(s);
	if (it != tbl.end())
		return it->second;

	addr a = static_cast<addr>(data.size());
	tbl[s] = a;
	data.insert(data.end(), s.begin(), s.end());
	data.push_back('\0');

	if (data.size() > std::numeric_limits<addr>::max())
		throw error(".sym section overflow");


	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x91ce
testq %rax, %rax
je 0x794b
movzwl 0x28(%rax), %ebp
jmp 0x7999
leaq 0x38(%rbx), %r15
movl 0x40(%rbx), %ebp
subl 0x38(%rbx), %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x92ca
movw %bp, (%rax)
movq 0x40(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
addq %rdx, %rcx
movq %r15, %rdi
callq 0x9608
leaq 0x7(%rsp), %rsi
movb $0x0, (%rsi)
movq %r15, %rdi
callq 0x981a
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
cmpq $0x10000, %rax          # imm = 0x10000
jae 0x79a6
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x6993(%rip), %rsi      # 0xe34d
movq %rax, %rdi
callq 0x3100
movq 0xc627(%rip), %rsi      # 0x13ff0
movq 0xc5e0(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: strings::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
auto strings::operator[](const string &s) const -> addr
{
	auto it = tbl.find(s);
	if (it == tbl.end())
		throw error(s + ": no such defined string");
	return it->second;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
addq $0x18, %rdi
callq 0x9f4c
testq %rax, %rax
je 0x7a97
movl 0x28(%rax), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x68b8(%rip), %rdx      # 0xe363
movq %rsp, %rdi
movq %r14, %rsi
callq 0x49df
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc523(%rip), %rsi      # 0x13ff0
movq 0xc4dc(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7b02
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7b02
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7b0f
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_label(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void code::add_label(const string &s)
{
	auto res = lbl.insert({s, address()});
	if (not res.second)
		throw error(std::string("table ") + "label "
				+ " already has an element " + s);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
leaq 0x78(%rdi), %rbx
movl 0x8(%rdi), %ebp
subl (%rdi), %ebp
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x4e76
movl %ebp, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9f86
movl %edx, %ebx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7b7e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
testb $0x1, %bl
je 0x7b95
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6794(%rip), %rsi      # 0xe346
leaq 0x6793(%rip), %rdx      # 0xe34c
leaq 0x68(%rsp), %rdi
callq 0x4f06
leaq 0x67b2(%rip), %rsi      # 0xe37c
leaq 0x68(%rsp), %rdi
callq 0x3500
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7bf6
movups (%rcx), %xmm0
movups %xmm0, (%r13)
jmp 0x7c03
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x675d(%rip), %rsi      # 0xe383
callq 0x3500
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7c50
movups (%rcx), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, (%rdx)
jmp 0x7c5c
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x889a
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc354(%rip), %rsi      # 0x13ff0
movq 0xc30d(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7ccd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7ccd
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x7cf0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7cf0
movq %rax, %r14
movb $0x1, %bpl
movq 0x48(%rsp), %rdi
cmpq %r13, %rdi
je 0x7d0f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7d0f
movq %rax, %r14
movb $0x1, %bpl
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7d2e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7d2e
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7d57
movq %rbx, %rdi
callq 0x31f0
jmp 0x7d57
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7d57
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3260
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: code::offset(unsigned int, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
auto code::offset(addr from, addr to,
		const string &label, int line) -> ofs
{
	ofs d = to - from;
	if ((from + d) != to)
		throw error("too long reference to " + label
				+ " at " + std::to_string(line));
	return d;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movl %esi, %eax
subl %edi, %eax
movswl %ax, %ecx
addl %edi, %ecx
cmpl %esi, %ecx
jne 0x7d8a
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movl $0x10, %edi
callq 0x3150
movq %rax, %rbx
leaq 0x65fb(%rip), %rsi      # 0xe39c
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x67b9
leaq 0x65fe(%rip), %rsi      # 0xe3b3
leaq 0x48(%rsp), %rdi
callq 0x3500
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x7de0
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x7ded
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x6c8e
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x6be6
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
xorl %ebp, %ebp
movq 0xc1b2(%rip), %rsi      # 0x13ff0
movq 0xc16b(%rip), %rdx      # 0x13fb0
movq %rbx, %rdi
callq 0x3480
movq %rax, %r14
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7e73
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7e73
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7e96
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7e96
movq %rax, %r14
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7eb5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7eb5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7ed8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x7ed8
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x7ee5
movq %rbx, %rdi
callq 0x31f0
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: code::add_ref(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
void code::add_ref(const std::string &label, int line)
{
	auto it = lbl.find(label);
	if (it != lbl.end()) {
		put(offset(cur_addr, it->second, label, line));
	} else {
		unres.emplace_back(unresolved{label, cur_addr,
				address(), line});
		put(ofs()); // placeholder
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x78, %rdi
callq 0xa0b8
testq %rax, %rax
je 0x7f25
movl 0xf0(%rbx), %edi
movl 0x28(%rax), %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7d60
jmp 0x7f85
leaq 0xb0(%rbx), %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4e76
movl 0xf0(%rbx), %eax
movl %eax, 0x20(%r14)
movl 0x8(%rbx), %eax
subl (%rbx), %eax
movl %eax, 0x24(%r14)
movl %ebp, 0x28(%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x8b2c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7f83
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
xorl %eax, %eax
movswl %ax, %esi
movq %rbx, %rdi
callq 0x8aea
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7fb6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_c_makefile_star2_O1/almk277[P]ROSE/rasm/module.cpp
// Function: operator<<(std::ostream&, RMDHeader const&)
ostream &operator<<(ostream &s, const RMDHeader &h)
{
	buf_it it(s);
	serializer(it) << h.ident << h.rmd_version << h.name << h.version
		<< h.sizes.exp << h.sizes.ptbl << h.sizes.mtbl
		<< h.sizes.imp << h.sizes.text << h.sizes.sym << h.sizes.str
		<< h.datac << h.flags << h.size << h.pad;
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rdi,%rax), %rdx
leaq 0x8(%rsp), %rax
movq %rdx, (%rax)
xorl %ecx, %ecx
testq %rdx, %rdx
sete 0x8(%rax)
sete %cl
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x4(%rsi), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0xa508
movq %r15, %rdi
movq %r12, %rsi
callq 0x8b8e
movq %rax, %r15
movq (%rax), %rax
movq (%rax), %rdi
movzwl 0x6(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa44a
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x8b8e
movq %rax, %r15
movq (%rax), %rax
testb $0x1, 0x8(%rax)
jne 0x84b4
movq (%rax), %rdi
movb 0xc(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x85d9
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x84d8
movq (%rax), %rdi
movb 0xd(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x85e7
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x84fc
movq (%rax), %rdi
movb 0xe(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x85f5
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x8520
movq (%rax), %rdi
movb 0xf(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8603
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
movq (%rax), %rdi
movl 0x10(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa4aa
movq (%r15), %rax
movq (%rax), %rdi
movzwl 0x14(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa44a
movq (%r15), %rax
movq (%rax), %rdi
movl 0x18(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa4aa
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x857b
movq (%rax), %rdi
movb 0x1c(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x8611
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
testb $0x1, 0x8(%rax)
jne 0x859f
movq (%rax), %rdi
movb 0x1d(%r14), %al
movq 0x28(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x861f
movb %al, (%rcx)
incq 0x28(%rdi)
movq (%r15), %rax
movq (%rax), %rdi
movl 0x20(%r14), %edx
movl 0x8(%rax), %esi
callq 0xa4aa
leaq 0x24(%r14), %rdi
movq (%r15), %rax
movq (%rax), %rdx
addq $0x2c, %r14
movl 0x8(%rax), %ecx
movq %r14, %rsi
callq 0xa508
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x84b4
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x84d8
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x84fc
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x8520
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x857b
movzbl %al, %esi
movq (%rdi), %rax
callq *0x68(%rax)
jmp 0x859f
nop