LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_alloc_buffer
sliding_window_v4 *sliding_window_v4_alloc_buffer(sliding_window_v4 *sw,size_t size) {
	/* sanity check: the buffer pointer is NULL */
	assert(sw->buffer == NULL);
	/* sanity check: caller isn't trying to alloc a buffer on top of a buffer or mmap() window, it must be a null window */
	assert(sw->type == SLIDING_WINDOW_V4_TYPE_NULL);
	/* OK, zero the struct and prepare it for buffer management */
	memset(sw,0,sizeof(*sw));
	if (size < 2) size = 2;
	sw->buffer = (unsigned char*)malloc(size);
	if (!sw->buffer) return NULL;
	sw->type = SLIDING_WINDOW_V4_TYPE_BUFFER;
	sw->u.buffer.lib_owner = 1; /* this library owns the buffer */
	sw->fence = sw->buffer + size;
	sw->data = sw->end = sw->buffer;
	return sw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6c4c
jmp 0x6c6b
leaq 0x2d9f(%rip), %rdi      # 0x99f2
leaq 0x2dab(%rip), %rsi      # 0x9a05
movl $0x46, %edx
leaq 0x2e8d(%rip), %rcx      # 0x9af3
callq 0x1080
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x6c7a
jmp 0x6c99
leaq 0x2ec1(%rip), %rdi      # 0x9b42
leaq 0x2d7d(%rip), %rsi      # 0x9a05
movl $0x48, %edx
leaq 0x2e5f(%rip), %rcx      # 0x9af3
callq 0x1080
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
cmpq $0x2, -0x18(%rbp)
jae 0x6cb8
movq $0x2, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6cdf
movq $0x0, -0x8(%rbp)
jmp 0x6d21
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_create_null
sliding_window_v4* sliding_window_v4_create_null() {
	sliding_window_v4 *sw = (sliding_window_v4*)malloc(sizeof(sliding_window_v4));
	if (!sw) return NULL;
	memset(sw,0,sizeof(*sw));
	return sw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x1110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6d57
movq $0x0, -0x8(%rbp)
jmp 0x6d6f
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_create_buffer
sliding_window_v4* sliding_window_v4_create_buffer(size_t size) {
	sliding_window_v4 *sw = sliding_window_v4_create_null();
	if (!sw) return NULL;
	if (sliding_window_v4_alloc_buffer(sw,size) == NULL) {
		free(sw);
		return NULL;
	}
	return sw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x6d30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6da6
movq $0x0, -0x8(%rbp)
jmp 0x6dd4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6c30
cmpq $0x0, %rax
jne 0x6dcc
movq -0x18(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x6dd4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_destroy
sliding_window_v4* sliding_window_v4_destroy(sliding_window_v4 *sw) {
	if (sw) {
		sliding_window_v4_free(sw);
		memset(sw,0,sizeof(*sw));
		free(sw);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x6e15
movq -0x8(%rbp), %rdi
callq 0x6e20
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1090
movq -0x8(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_resize_buffer
int sliding_window_v4_resize_buffer(sliding_window_v4 *sw,size_t new_size) {
	unsigned char *np;

	assert(sw->type == SLIDING_WINDOW_V4_TYPE_BUFFER);

	if (new_size < 2) new_size = 2;

	/* don't resize if we're resizing to the same size buffer */
	if (sw->buffer+new_size == sw->fence) return 1;

	/* check for pointer location overflow */
	if (size_t_overflow(sw->buffer,new_size)) return 0;

	/* don't allow resizing if doing so would leave the data & end pointers outside the buffer (violating window sanity) */
	if (sw->data > (sw->buffer+new_size)) return 0;
	if (sw->end > (sw->buffer+new_size)) return 0;

	/* carry out the resize. manage pointers so that if realloc() fails we can gracefully return the struct unmodified */
	if ((np = (unsigned char*)realloc(sw->buffer,new_size)) == NULL) return 0;

	/* throw away the old pointer and update the structure */
	{
		size_t old_do = (size_t)(sw->data - sw->buffer);
		size_t old_eo = (size_t)(sw->end - sw->buffer);
		sw->buffer = np;
		sw->fence = np + new_size;
		sw->data = np + old_do;
		sw->end = np + old_eo;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x1, %eax
jne 0x6e9f
jmp 0x6ebe
leaq 0x2cc4(%rip), %rdi      # 0x9b6a
leaq 0x2b58(%rip), %rsi      # 0x9a05
movl $0x8c, %edx
leaq 0x2cdb(%rip), %rcx      # 0x9b94
callq 0x1080
cmpq $0x2, -0x18(%rbp)
jae 0x6ecd
movq $0x2, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x6eee
movl $0x1, -0x4(%rbp)
jmp 0x6fe9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x7000
cmpq $0x0, %rax
je 0x6f10
movl $0x0, -0x4(%rbp)
jmp 0x6fe9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x6f34
movl $0x0, -0x4(%rbp)
jmp 0x6fe9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x6f58
movl $0x0, -0x4(%rbp)
jmp 0x6fe9
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x1120
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x6f7b
movl $0x0, -0x4(%rbp)
jmp 0x6fe9
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
addq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_resize
int sliding_window_v4_resize(sliding_window_v4 *sw,size_t new_size) {
	if (sw == NULL)
		return 0;
	else if (sw->type == SLIDING_WINDOW_V4_TYPE_BUFFER)
		return sliding_window_v4_resize_buffer(sw,new_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7050
movl $0x0, -0x4(%rbp)
jmp 0x7078
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x1, %eax
jne 0x706f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6e80
movl %eax, -0x4(%rbp)
jmp 0x7078
jmp 0x7071
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_data_advance
size_t sliding_window_v4_data_advance(sliding_window_v4 *sw,size_t bytes) {
	if (sw->buffer == NULL)
		return 0;

	/* don't let the caller advance too far and violate the pointer rule specified in the header file */
	if ((sw->data+bytes) > sw->end)
		bytes = (size_t)(sw->end - sw->data);

	sw->data += bytes;
	return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x70b0
movq $0x0, -0x8(%rbp)
jmp 0x70f5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x70dd
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_wrote
size_t sliding_window_v4_wrote(sliding_window_v4 *sw,size_t bytes) {
	if (sw->buffer == NULL)
		return 0;

	/* to clarify: the caller loads data into memory at sw->end and uses this function to
	 * tell us HOW much data it wrote so the sliding window can follow along */
	if ((sw->end+bytes) > sw->fence)
		bytes = (size_t)(sw->fence - sw->end);

	sw->end += bytes;
	return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x7120
movq $0x0, -0x8(%rbp)
jmp 0x7165
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x714d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_flush
size_t sliding_window_v4_flush(sliding_window_v4 *sw) {
	size_t valid_data,ret=0;

    SYSTEM_PAGE_SIZE_init();

	/* copy the valid data left back to the front of the buffer, reset data/end pointers. */
	/* NOTICE: used properly this allows fast reading and parsing of streams. over-used, and
	 * performance will suffer horribly. call this function only when you need to. */

	/* if already there, do nothing */
	if (sw->data == sw->buffer) return 0;

	if (sw->type == SLIDING_WINDOW_V4_TYPE_BUFFER) {
		ret = (size_t)(sw->data - sw->buffer);
		valid_data = sliding_window_v4_data_available(sw);
		if (valid_data > 0) memmove(sw->buffer,sw->data,valid_data);
		sw->data = sw->buffer;
		sw->end = sw->data + valid_data;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x7230
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x71a4
movq $0x0, -0x8(%rbp)
jmp 0x721e
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x1, %eax
jne 0x7216
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7260
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jbe 0x71f3
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1140
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_lazy_flush
size_t sliding_window_v4_lazy_flush(sliding_window_v4 *sw) {
	/* lazy flush: call sliding_window_flush() only if more than half the entire buffer has
	 * been consumed. a caller that wants a generally-optimal streaming buffer policy would
	 * call this instead of duplicating code to check and call all over the place. */
	size_t threshhold = ((size_t)(sw->fence - sw->buffer)) >> 1;
	if ((sw->data+threshhold) >= sw->end && sliding_window_v4_data_offset(sw) >= (threshhold/2))
		return sliding_window_v4_flush(sw);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq %rcx, %rax
shrq %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x72df
movq -0x10(%rbp), %rdi
callq 0x7300
movq -0x18(%rbp), %rcx
shrq %rcx
cmpq %rcx, %rax
jb 0x72df
movq -0x10(%rbp), %rdi
callq 0x7170
movq %rax, -0x8(%rbp)
jmp 0x72e7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_free_buffer
void sliding_window_v4_free_buffer(sliding_window_v4 *sw) {
	if (sw->buffer != NULL) {
		if (sw->u.buffer.lib_owner) {
			free(sw->buffer); /* we own the buffer, we free it */
			sw->buffer = NULL;
		}
		else if (sw->u.buffer.owner_free_buffer != NULL) {
			/* the buffer is owned by someone else, and that someone else
			 * gave us a callback to free it by. */
			sw->u.buffer.owner_free_buffer(sw);
			sw->buffer = NULL;
		}
		else {
			/* no way to free the buffer. hope the owner intended it that
			 * way, or else a memory leak may happen */
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7385
movq -0x8(%rbp), %rax
cmpb $0x0, 0x30(%rax)
je 0x7359
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x7383
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x737f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x7381
jmp 0x7381
jmp 0x7383
jmp 0x7385
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/sliding_window.c
// Function: sliding_window_v4_is_sane
int sliding_window_v4_is_sane(sliding_window_v4 *sw) {
	if (sw == NULL) return 0;

	/* if any of the pointers are NULL, */
	if (sw->buffer == NULL || sw->data == NULL || sw->fence == NULL || sw->end == NULL) {
		/* if it's a memory buffer: NO, the pointers must not be null */
		if (sw->type == SLIDING_WINDOW_V4_TYPE_BUFFER)
			return 0;

		/* if it's not, then for the window to be valid all four pointers must be NULL.
		 * We enforce consistency here: either they are all non-NULL or they are all NULL. */
		if (sw->buffer != NULL || sw->data != NULL || sw->fence != NULL || sw->end != NULL)
			return 0;

		/* it's valid, then */
		return 1;
	}

	return	(sw->buffer <= sw->data) &&
		(sw->data <= sw->end) &&
		(sw->end <= sw->fence) &&
		(sw->buffer != sw->fence);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x73ab
movl $0x0, -0x4(%rbp)
jmp 0x7490
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x73d6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x73d6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x73d6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x742c
movq -0x10(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x1, %eax
jne 0x73ef
movl $0x0, -0x4(%rbp)
jmp 0x7490
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x741a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x741a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x741a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x7423
movl $0x0, -0x4(%rbp)
jmp 0x7490
movl $0x1, -0x4(%rbp)
jmp 0x7490
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x11(%rbp)
ja 0x7485
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x18(%rdx), %rcx
movb %al, -0x11(%rbp)
ja 0x7485
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rbp)
ja 0x7485
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/util.c
// Function: encodeuri
static int
encodeuri(char *buf, size_t bufsiz, const char *s)
{
	static const char *table = "0123456789ABCDEF";
	size_t i, b;

	for (i = 0, b = 0; s[i]; i++) {
		if (s[i] == ' ' ||
		    (unsigned char)s[i] > 127 ||
		    iscntrl((unsigned char)s[i])) {
			if (b + 3 >= bufsiz)
				return -1;
			buf[b++] = '%';
			buf[b++] = table[((unsigned char)s[i] >> 4) & 15];
			buf[b++] = table[(unsigned char)s[i] & 15];
		} else if (b < bufsiz) {
			buf[b++] = s[i];
		} else {
			return -1;
		}
	}
	if (b >= bufsiz)
		return -1;
	buf[b] = '\0';

	return 0;
}

// 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 $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x2354
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x226f
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x7f, %eax
jg 0x226f
callq 0x11d0
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x2309
movq -0x30(%rbp), %rax
addq $0x3, %rax
cmpq -0x18(%rbp), %rax
jb 0x2289
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x237a
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb $0x25, (%rax,%rcx)
movq 0x2e59(%rip), %rax      # 0x5100
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
movq 0x2e24(%rip), %rax      # 0x5100
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
andl $0xf, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x2341
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2336
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x233f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x237a
jmp 0x2341
jmp 0x2343
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2214
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x2367
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x237a
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/util.c
// Function: parseline
size_t
parseline(char *line, char *fields[FieldLast])
{
	char *prev, *s;
	size_t i;

	for (prev = line, i = 0;
	    (s = strchr(prev, '\t')) && i < FieldLast - 1;
	    i++) {
		*s = '\0';
		fields[i] = prev;
		prev = s + 1;
	}
	fields[i++] = prev;
	/* make non-parsed fields empty. */
	for (; i < FieldLast; i++)
		fields[i] = "";

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x9, %esi
callq 0x1090
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x23db
cmpq $0x7, -0x28(%rbp)
setb %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x23e4
jmp 0x2415
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23b0
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movq %rdx, (%rax,%rcx,8)
cmpq $0x8, -0x28(%rbp)
jae 0x2458
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
leaq 0x1024(%rip), %rdx      # 0x346a
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2430
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/util.c
// Function: strtotime
int
strtotime(const char *s, time_t *t)
{
	long long l;
	char *e;

	errno = 0;
	l = strtoll(s, &e, 10);
	if (errno || *s == '\0' || *e)
		return -1;
	/* NOTE: assumes time_t is 64-bit on 64-bit platforms:
	         long long (atleast 32-bit) to time_t. */
	if (t)
		*t = (time_t)l;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x1040
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1120
movq %rax, -0x20(%rbp)
callq 0x1040
cmpl $0x0, (%rax)
jne 0x24c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x24c3
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x24cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x24e5
cmpq $0x0, -0x18(%rbp)
je 0x24de
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/util.c
// Function: xmlencode
void
xmlencode(const char *s, FILE *fp)
{
	for (; *s; ++s) {
		switch (*s) {
		case '<':  fputs("&lt;",   fp); break;
		case '>':  fputs("&gt;",   fp); break;
		case '\'': fputs("&#39;",  fp); break;
		case '&':  fputs("&amp;",  fp); break;
		case '"':  fputs("&quot;", fp); break;
		default:   fputc(*s, fp);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x25b3
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x1c, %eax
ja 0x2590
movq -0x18(%rbp), %rax
leaq 0xfe3(%rip), %rcx       # 0x3510
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq 0x105d(%rip), %rdi      # 0x359e
callq 0x10c0
jmp 0x25a0
movq -0x10(%rbp), %rsi
leaq 0x1050(%rip), %rdi      # 0x35a3
callq 0x10c0
jmp 0x25a0
movq -0x10(%rbp), %rsi
leaq 0x1043(%rip), %rdi      # 0x35a8
callq 0x10c0
jmp 0x25a0
movq -0x10(%rbp), %rsi
leaq 0x1037(%rip), %rdi      # 0x35ae
callq 0x10c0
jmp 0x25a0
movq -0x10(%rbp), %rsi
leaq 0x102b(%rip), %rdi      # 0x35b4
callq 0x10c0
jmp 0x25a0
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
movq -0x10(%rbp), %rsi
callq 0x10e0
jmp 0x25a2
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x2500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/util.c
// Function: printutf8pad
void
printutf8pad(FILE *fp, const char *s, size_t len, int pad)
{
	wchar_t wc;
	size_t col = 0, i, slen;
	int rl, w;

	if (!len)
		return;

	slen = strlen(s);
	for (i = 0; i < slen; i += rl) {
		if ((rl = mbtowc(&wc, s + i, slen - i < 4 ? slen - i : 4)) <= 0)
			break;
		if ((w = wcwidth(wc)) == -1)
			continue;
		if (col + w > len || (col + w == len && s[i + rl])) {
			fputs("\xe2\x80\xa6", fp);
			col++;
			break;
		}
		fwrite(&s[i], 1, rl, fp);
		col += w;
	}
	for (; col < len; ++col)
		putc(pad, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x25eb
jmp 0x2726
movq -0x10(%rbp), %rdi
callq 0x1080
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x2700
movq -0x10(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
cmpq $0x4, %rax
jae 0x2636
movq -0x38(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x2641
movl $0x4, %eax
movq %rax, -0x50(%rbp)
jmp 0x2641
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x1140
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jg 0x265f
jmp 0x2700
movl -0x20(%rbp), %edi
callq 0x1170
movl %eax, -0x40(%rbp)
cmpl $-0x1, %eax
jne 0x2671
jmp 0x26ef
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
ja 0x26ab
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
addq %rcx, %rax
cmpq -0x18(%rbp), %rax
jne 0x26c9
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
addq %rdx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x26c9
movq -0x8(%rbp), %rsi
leaq 0xf05(%rip), %rdi       # 0x35bb
callq 0x10c0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2700
movq -0x10(%rbp), %rdi
addq -0x30(%rbp), %rdi
movslq -0x3c(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x11c0
movslq -0x40(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movslq -0x3c(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x2600
jmp 0x2702
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x2726
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x1110
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2702
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/strlcat.c
// Function: strlcat
size_t
strlcat(char *dst, const char *src, size_t dsize)
{
	const char *odst = dst;
	const char *osrc = src;
	size_t n = dsize;
	size_t dlen;

	/* Find the end of dst and adjust bytes left but don't go past end. */
	while (n-- != 0 && *dst != '\0')
		dst++;
	dlen = dst - odst;
	n = dsize - dlen;

	if (n-- == 0)
		return(dlen + strlen(src));
	while (*src != '\0') {
		if (n != 0) {
			*dst++ = *src;
			n--;
		}
		src++;
	}
	*dst = '\0';

	return(dlen + (src - osrc));	/* count does not include NUL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
je 0x2786
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x278f
jmp 0x279d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x275c
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
jne 0x27ee
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x2851
jmp 0x27f0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x2834
cmpq $0x0, -0x38(%rbp)
je 0x2826
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x27f0
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/strlcpy.c
// Function: strlcpy
size_t
strlcpy(char *dst, const char *src, size_t dsize)
{
	const char *osrc = src;
	size_t nleft = dsize;

	/* Copy as many bytes as will fit. */
	if (nleft != 0) {
		while (--nleft != 0) {
			if ((*dst++ = *src++) == '\0')
				break;
		}
	}

	/* Not enough room in dst, add NUL and traverse rest of src. */
	if (nleft == 0) {
		if (dsize != 0)
			*dst = '\0';		/* NUL-terminate dst */
		while (*src++)
			;
	}

	return(src - osrc - 1);	/* count does not include NUL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x28cb
jmp 0x2889
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x28c9
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %al, (%rcx)
movsbl %al, %eax
cmpl $0x0, %eax
jne 0x28c7
jmp 0x28c9
jmp 0x2889
jmp 0x28cb
cmpq $0x0, -0x28(%rbp)
jne 0x28fa
cmpq $0x0, -0x18(%rbp)
je 0x28e0
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x28e2
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpb $0x0, (%rax)
je 0x28f8
jmp 0x28e2
jmp 0x28fa
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
subq $0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/zhoudian64[P]OS2-exp/mount_example.c
// Function: main
int main()
{
   const char* src  = "none";
   const char* trgt = "./tmp_example";
   const char* type = "tmpfs";
   const unsigned long mntflags = 0;
   const char* opts = "mode=0777,uid=65534";   /* 65534 is the uid of nobody */

   int result = mount(src, trgt, type, mntflags, opts);

   if (result == 0)
   {
      printf("Mount created at %s...\n", trgt);
      printf("Press <return> to unmount the volume: ");
      getchar();

      umount(trgt);
   }
   else
   {
     printf("Error : Failed to mount %s\n"
             "Reason: %s [%d]\n",
             src, strerror(errno), errno);
      return -1;
   }

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xe5e(%rip), %rax       # 0x2004
movq %rax, -0x10(%rbp)
leaq 0xe58(%rip), %rax       # 0x2009
movq %rax, -0x18(%rbp)
leaq 0xe5b(%rip), %rax       # 0x2017
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
leaq 0xe4e(%rip), %rax       # 0x201d
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x1050
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x1225
movq -0x18(%rbp), %rsi
leaq 0xe31(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1060
leaq 0xe3b(%rip), %rdi       # 0x2049
movb $0x0, %al
callq 0x1060
callq 0x1070
movq -0x18(%rbp), %rdi
callq 0x1040
jmp 0x1263
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x1030
movl (%rax), %edi
callq 0x1080
movq %rax, -0x40(%rbp)
callq 0x1030
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movl (%rax), %ecx
leaq 0xe1d(%rip), %rdi       # 0x2070
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x126a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/client.c
// Function: nodeIter
static UA_StatusCode
nodeIter(UA_NodeId childId, UA_Boolean isInverse, UA_NodeId referenceTypeId, void *handle) {  
  UA_NodeId *parent = (UA_NodeId *) handle;
  
  if(!isInverse) {
    printf("%d, %d --- %d ---> NodeId %d, %d\n",
           parent->namespaceIndex, parent->identifier.numeric,
           referenceTypeId.identifier.numeric, childId.namespaceIndex,
           childId.identifier.numeric);
  }
  return UA_STATUSCODE_GOOD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
leaq 0x28(%rbp), %rcx
movq %rcx, -0x28(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
jne 0x2661
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
movzwl (%rdx), %esi
movq -0x18(%rbp), %rdx
movl 0x8(%rdx), %edx
movl 0x8(%rcx), %ecx
movzwl (%rax), %r8d
movl 0x8(%rax), %r9d
leaq 0xd99(%rip), %rdi       # 0x33f3
movb $0x0, %al
callq 0x10a0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/../include/ua_client_highlevel.h
// Function: UA_Client_addReferenceTypeNode
static UA_INLINE UA_StatusCode
UA_Client_addReferenceTypeNode(UA_Client *client, const UA_NodeId requestedNewNodeId,
                               const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                               const UA_QualifiedName browseName, const UA_ReferenceTypeAttributes attr,
                               UA_NodeId *outNewNodeId) {
    return __UA_Client_addNode(client, UA_NODECLASS_REFERENCETYPE, requestedNewNodeId,
                               parentNodeId, referenceTypeId, browseName, UA_NODEID_NULL,
                               (const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],
                               outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x70(%rbp), %rdx
leaq 0x58(%rbp), %r9
leaq 0x40(%rbp), %r10
leaq 0x28(%rbp), %r11
leaq 0x10(%rbp), %rbx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x20, %esi
movq 0x2432(%rip), %rax      # 0x4fd0
movq 0x243b(%rip), %rcx      # 0x4fe0
addq $0xf78, %rcx            # imm = 0xF78
movq (%rbx), %r14
movq %r14, (%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x8(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x10(%rsp)
movq (%r11), %rbx
movq %rbx, 0x18(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x20(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x28(%rsp)
movq (%r10), %r11
movq %r11, 0x30(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x38(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x40(%rsp)
movq (%r9), %r10
movq %r10, 0x48(%rsp)
movq 0x8(%r9), %r10
movq %r10, 0x50(%rsp)
movq 0x10(%r9), %r9
movq %r9, 0x58(%rsp)
movq (%rax), %r9
movq %r9, 0x60(%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x1040
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/../include/ua_client_highlevel.h
// Function: UA_Client_addObjectTypeNode
static UA_INLINE UA_StatusCode
UA_Client_addObjectTypeNode(UA_Client *client, const UA_NodeId requestedNewNodeId,
                            const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                            const UA_QualifiedName browseName, const UA_ObjectTypeAttributes attr,
                            UA_NodeId *outNewNodeId) {
    return __UA_Client_addNode(client, UA_NODECLASS_OBJECTTYPE, requestedNewNodeId,
                               parentNodeId, referenceTypeId, browseName, UA_NODEID_NULL,
                               (const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],
                               outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x70(%rbp), %rdx
leaq 0x58(%rbp), %r9
leaq 0x40(%rbp), %r10
leaq 0x28(%rbp), %r11
leaq 0x10(%rbp), %rbx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x8, %esi
movq 0x22c2(%rip), %rax      # 0x4fd0
movq 0x22cb(%rip), %rcx      # 0x4fe0
addq $0x938, %rcx            # imm = 0x938
movq (%rbx), %r14
movq %r14, (%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x8(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x10(%rsp)
movq (%r11), %rbx
movq %rbx, 0x18(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x20(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x28(%rsp)
movq (%r10), %r11
movq %r11, 0x30(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x38(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x40(%rsp)
movq (%r9), %r10
movq %r10, 0x48(%rsp)
movq 0x8(%r9), %r10
movq %r10, 0x50(%rsp)
movq 0x10(%r9), %r9
movq %r9, 0x58(%rsp)
movq (%rax), %r9
movq %r9, 0x60(%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x1040
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/../include/ua_client_highlevel.h
// Function: UA_Client_addObjectNode
static UA_INLINE UA_StatusCode
UA_Client_addObjectNode(UA_Client *client, const UA_NodeId requestedNewNodeId,
                        const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                        const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
                        const UA_ObjectAttributes attr, UA_NodeId *outNewNodeId) {
    return __UA_Client_addNode(client, UA_NODECLASS_OBJECT, requestedNewNodeId,
                               parentNodeId, referenceTypeId, browseName, typeDefinition,
                               (const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],
                               outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x88(%rbp), %rdx
leaq 0x70(%rbp), %rax
leaq 0x58(%rbp), %r9
leaq 0x40(%rbp), %r10
leaq 0x28(%rbp), %r11
leaq 0x10(%rbp), %rbx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x1, %esi
movq 0x21bb(%rip), %rcx      # 0x4fe0
addq $0x1018, %rcx           # imm = 0x1018
movq (%rbx), %r14
movq %r14, (%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x8(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x10(%rsp)
movq (%r11), %rbx
movq %rbx, 0x18(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x20(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x28(%rsp)
movq (%r10), %r11
movq %r11, 0x30(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x38(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x40(%rsp)
movq (%r9), %r10
movq %r10, 0x48(%rsp)
movq 0x8(%r9), %r10
movq %r10, 0x50(%rsp)
movq 0x10(%r9), %r9
movq %r9, 0x58(%rsp)
movq (%rax), %r9
movq %r9, 0x60(%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x1040
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/../include/ua_client_highlevel.h
// Function: UA_Client_addVariableNode
static UA_INLINE UA_StatusCode
UA_Client_addVariableNode(UA_Client *client, const UA_NodeId requestedNewNodeId,
                          const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,
                          const UA_QualifiedName browseName, const UA_NodeId typeDefinition,
                          const UA_VariableAttributes attr, UA_NodeId *outNewNodeId) {
    return __UA_Client_addNode(client, UA_NODECLASS_VARIABLE, requestedNewNodeId,
                               parentNodeId, referenceTypeId, browseName, typeDefinition,
                               (const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],
                               outNewNodeId); }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x88(%rbp), %rdx
leaq 0x70(%rbp), %rax
leaq 0x58(%rbp), %r9
leaq 0x40(%rbp), %r10
leaq 0x28(%rbp), %r11
leaq 0x10(%rbp), %rbx
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %r8
movl $0x2, %esi
movq 0x20ab(%rip), %rcx      # 0x4fe0
addq $0x528, %rcx            # imm = 0x528
movq (%rbx), %r14
movq %r14, (%rsp)
movq 0x8(%rbx), %r14
movq %r14, 0x8(%rsp)
movq 0x10(%rbx), %rbx
movq %rbx, 0x10(%rsp)
movq (%r11), %rbx
movq %rbx, 0x18(%rsp)
movq 0x8(%r11), %rbx
movq %rbx, 0x20(%rsp)
movq 0x10(%r11), %r11
movq %r11, 0x28(%rsp)
movq (%r10), %r11
movq %r11, 0x30(%rsp)
movq 0x8(%r10), %r11
movq %r11, 0x38(%rsp)
movq 0x10(%r10), %r10
movq %r10, 0x40(%rsp)
movq (%r9), %r10
movq %r10, 0x48(%rsp)
movq 0x8(%r9), %r10
movq %r10, 0x50(%rsp)
movq 0x10(%r9), %r9
movq %r9, 0x58(%rsp)
movq (%rax), %r9
movq %r9, 0x60(%rsp)
movq 0x8(%rax), %r9
movq %r9, 0x68(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x70(%rsp)
callq 0x1040
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/fritzw[P]cube-utils/cube-encoder.c
// Function: fsize
long int fsize(FILE *f) {
    long int original, size;
    original = ftell(f);
    fseek(f, 0, SEEK_END);
    size = ftell(f);
    fseek(f, original, SEEK_SET);
    return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10f0
movq -0x8(%rbp), %rdi
callq 0x10b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x10f0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/fritzw[P]cube-utils/cube-encoder.c
// Function: ends_with
int ends_with(char *subject, char *ending) {
	int subjectlength = strlen(subject);
	int endlength = strlen(ending);
	if (endlength > subjectlength) {
		return 0;
	}
	return 0 == strncmp(subject + subjectlength - endlength, ending, endlength);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1080
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1080
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x12c9
movl $0x0, -0x4(%rbp)
jmp 0x12fe
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x1040
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test
static int _test(String * s)
{
	size_t len;
	size_t i;

	/* string_get_length */
	printf("%s: Testing %s\n", PROGNAME, "string_get_length()");
	if((len = string_get_length(s)) == 0)
		return 2;
	printf("\"%s\" => %zu\n", s, len);
	/* string_clear */
	printf("%s: Testing %s\n", PROGNAME, "string_clear()");
	string_clear(s);
	for(i = 0; i <= len; i++)
		if(s[i] != '\0')
			return 4;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x747(%rip), %rdi       # 0x206a
leaq 0x750(%rip), %rsi       # 0x207a
leaq 0x750(%rip), %rdx       # 0x2081
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x10c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1954
movl $0x2, -0x4(%rbp)
jmp 0x19d2
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x732(%rip), %rdi       # 0x2095
movb $0x0, %al
callq 0x1090
leaq 0x6f9(%rip), %rdi       # 0x206a
leaq 0x702(%rip), %rsi       # 0x207a
leaq 0x723(%rip), %rdx       # 0x20a2
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rdi
callq 0x1110
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0x19cb
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x19bb
movl $0x4, -0x4(%rbp)
jmp 0x19d2
jmp 0x19bd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1997
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test2
static int _test2(String const * string, String const * rtrim, int rcount)
{
	int ret = 0;
	String * s;
	int res;

	if((s = string_new(string)) == NULL)
		return -1;
	/* string_rtrim */
	printf("%s: Testing %s\n", PROGNAME, "string_rtrim()");
	if((res = string_rtrim(s, rtrim)) != rcount)
	{
		printf("%s: %s, %s, %d: Test failed (expected: %d)\n", PROGNAME,
				string, rtrim, res, rcount);
		ret = 8;
	}
	string_delete(s);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1a16
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a82
leaq 0x64d(%rip), %rdi       # 0x206a
leaq 0x656(%rip), %rsi       # 0x207a
leaq 0x686(%rip), %rdx       # 0x20b1
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1060
movl %eax, -0x2c(%rbp)
cmpl -0x1c(%rbp), %eax
je 0x1a73
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl -0x1c(%rbp), %r9d
leaq 0x662(%rip), %rdi       # 0x20c0
leaq 0x615(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x8, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test3
static int _test3(String const * string, String const * ltrim, int lcount)
{
	int ret = 0;
	String * s;
	int res;

	if((s = string_new(string)) == NULL)
		return -1;
	/* string_rtrim */
	printf("%s: Testing %s\n", PROGNAME, "string_ltrim()");
	if((res = string_ltrim(s, ltrim)) != lcount)
	{
		printf("%s: %s, %s, %d: Test failed (expected: %d)\n", PROGNAME,
				string, ltrim, res, lcount);
		ret = 16;
	}
	string_delete(s);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1ac6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1b32
leaq 0x59d(%rip), %rdi       # 0x206a
leaq 0x5a6(%rip), %rsi       # 0x207a
leaq 0x611(%rip), %rdx       # 0x20ec
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10b0
movl %eax, -0x2c(%rbp)
cmpl -0x1c(%rbp), %eax
je 0x1b23
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl -0x1c(%rbp), %r9d
leaq 0x5b2(%rip), %rdi       # 0x20c0
leaq 0x565(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x10, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DeforaOS[P]libSystem/tests/string.c
// Function: test4
static int _test4(String const * string, String const * trim, int count)
{
	int ret = 0;
	String * s;
	int res;

	if((s = string_new(string)) == NULL)
		return -1;
	/* string_trim */
	printf("%s: Testing %s\n", PROGNAME, "string_trim()");
	if((res = string_trim(s, trim)) != count)
	{
		printf("%s: %s, %s, %d: Test failed (expected: %d)\n", PROGNAME,
				string, trim, res, count);
		ret = 32;
	}
	string_delete(s);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1b76
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1be2
leaq 0x4ed(%rip), %rdi       # 0x206a
leaq 0x4f6(%rip), %rsi       # 0x207a
leaq 0x570(%rip), %rdx       # 0x20fb
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10f0
movl %eax, -0x2c(%rbp)
cmpl -0x1c(%rbp), %eax
je 0x1bd3
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x2c(%rbp), %r8d
movl -0x1c(%rbp), %r9d
leaq 0x502(%rip), %rdi       # 0x20c0
leaq 0x4b5(%rip), %rsi       # 0x207a
movb $0x0, %al
callq 0x1090
movl $0x20, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1080
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)