LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/rand.c
// Function: tt_rand
uint _tt_rand(void)
{
	uint r;

	pthread_mutex_lock(&_mtx);
	if (_si == -1)
		__tt_srand(clock());
	r = __tt_rand();
	pthread_mutex_unlock(&_mtx);

	return r;
}

// Assembly:
pushq %rbx
leaq 0x532e(%rip), %rdi      # 0x8130
callq 0x1160
cmpl $-0x1, 0x52c6(%rip)     # 0x80d4
jne 0x2e4f
callq 0x1080
movl %eax, 0x5345(%rip)      # 0x8160
movl $0x1, %ecx
leaq 0x5339(%rip), %rdx      # 0x8160
movl %eax, %esi
shrl $0x1e, %esi
xorl %eax, %esi
imull $0x6c078965, %esi, %eax # imm = 0x6C078965
addl %ecx, %eax
movl %eax, (%rdx,%rcx,4)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x2e27
movl $0x270, 0x5285(%rip)    # imm = 0x270
cmpl $0x270, 0x527b(%rip)    # imm = 0x270
leaq 0x5300(%rip), %rax      # 0x8160
jne 0x2f37
xorl %esi, %esi
movl $0x80000000, %edx       # imm = 0x80000000
leaq 0x2930(%rip), %rcx      # 0x57a4
movl (%rax,%rsi,4), %edi
andl %edx, %edi
movl 0x4(%rax,%rsi,4), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
shrl %r9d
andl $0x1, %r8d
movl (%rcx,%r8,4), %edi
xorl 0x634(%rax,%rsi,4), %edi
xorl %r9d, %edi
movl %edi, (%rax,%rsi,4)
leaq 0x1(%rsi), %rdi
movq %rdi, %rsi
cmpq $0xe3, %rdi
jne 0x2e74
xorl %edx, %edx
movl $0x80000000, %esi       # imm = 0x80000000
movl 0x38c(%rax,%rdx,4), %edi
andl %esi, %edi
movl 0x390(%rax,%rdx,4), %r8d
movl %r8d, %r9d
andl $0x7ffffffe, %r9d       # imm = 0x7FFFFFFE
orl %edi, %r9d
shrl %r9d
andl $0x1, %r8d
movl (%rcx,%r8,4), %edi
xorl (%rax,%rdx,4), %edi
xorl %r9d, %edi
movl %edi, 0x38c(%rax,%rdx,4)
incq %rdx
cmpq $0x18c, %rdx            # imm = 0x18C
jne 0x2eba
movl $0x80000000, %edx       # imm = 0x80000000
andl 0x5c15(%rip), %edx      # 0x8b1c
movl 0x5253(%rip), %esi      # 0x8160
movl %esi, %edi
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
orl %edx, %edi
andl $0x1, %esi
movl (%rcx,%rsi,4), %ecx
xorl 0x586d(%rip), %ecx      # 0x8790
shrl %edi
xorl %edi, %ecx
movl %ecx, 0x5bef(%rip)      # 0x8b1c
movl $0x0, 0x519d(%rip)      # 0x80d4
movslq 0x5196(%rip), %rcx      # 0x80d4
leal 0x1(%rcx), %edx
movl %edx, 0x518d(%rip)      # 0x80d4
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
shrl $0xb, %ecx
xorl %eax, %ecx
movl %ecx, %eax
shll $0x7, %eax
andl $0x9d2c5680, %eax       # imm = 0x9D2C5680
xorl %ecx, %eax
movl %eax, %ecx
shll $0xf, %ecx
andl $0xefc60000, %ecx       # imm = 0xEFC60000
xorl %eax, %ecx
movl %ecx, %ebx
shrl $0x12, %ebx
xorl %ecx, %ebx
leaq 0x51b8(%rip), %rdi      # 0x8130
callq 0x1110
movl %ebx, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/sort.c
// Function: tt_sort
int tt_sort(struct tt_sort_input *input)
{
	tt_assert(input->alg >= 0 && input->alg < TT_SORT_MAX);

	_tt_key_select(&input->num);

	struct tt_sort_stat stat;
	memset(&stat, 0, sizeof(struct tt_sort_stat));
	stat.tail = input->count - 1;	/* Only for quick sort */
	int ret = tt_sort_internal[input->alg](input, &stat);

	tt_debug("time: %u, space: %u", stat.time, stat.space);

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
cmpl $0x4, 0x2c(%rdi)
jae 0x2ff4
movq %rdi, %rbx
callq 0x2b44
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movl $0x0, 0x10(%r14)
movl 0x28(%rbx), %eax
decl %eax
movl %eax, 0x10(%r14)
movl 0x2c(%rbx), %eax
leaq 0x4e02(%rip), %rcx      # 0x7dc0
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rcx,%rax,8)
movl %eax, %ebx
movl (%r14), %ecx
movl 0x4(%r14), %r8d
leaq 0x2575(%rip), %rsi      # 0x554c
leaq 0x2588(%rip), %rdx      # 0x5566
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x1597
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/sort.c
// Function: tt_sort_insert
static int tt_sort_insert(struct tt_sort_input *in, struct tt_sort_stat *stat)
{
	/* Allocate buffer for one temporary element */
	char tmp[in->num.size] _tt_align(8);
	stat->space += 1;

	void *p = in->data;
	for (int i = 1; i < in->count; i++) {
		p += in->num.size;
		/* tmp = data[i] */
		in->num._set(&in->num, tmp, p);
		/* Insert data[i] into sorted list data[0] ~ data[i-1] */
		void *q = p - in->num.size;
		for (int j = i - 1; j >= 0; q -= in->num.size, j--) {
			stat->time++;	/* Compare */
			/* if (tmp < data[j]) */
			if (in->num.cmp(&in->num, tmp, q) < 0) {
				/* data[j+1] = data[j] */
				in->num._set(&in->num, q + in->num.size, q);
				stat->time++;	/* Set */
			} else {
				break;
			}
		}
		/* data[j+1] = tmp */
		in->num._set(&in->num, q + in->num.size, tmp);
		stat->time++;	/* Set */
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
movq %rsp, %r15
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
incl 0x4(%rsi)
cmpl $0x2, 0x28(%rdi)
jb 0x30bf
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rcx
movl $0x1, %eax
movl $0x2, %r12d
movl %eax, -0x30(%rbp)
movslq (%r14), %r13
addq %rcx, %r13
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x18(%r14)
movslq (%r14), %rax
movq %r13, -0x38(%rbp)
subq %rax, %r13
movl %r12d, -0x2c(%rbp)
incl (%rbx)
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x8(%r14)
testl %eax, %eax
jns 0x3097
movslq (%r14), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %r13, %rdx
callq *0x18(%r14)
incl (%rbx)
movslq (%r14), %rax
subq %rax, %r13
decl %r12d
cmpl $0x1, %r12d
jg 0x3063
movslq (%r14), %rsi
addq %r13, %rsi
movq %r14, %rdi
movq %r15, %rdx
callq *0x18(%r14)
incl (%rbx)
movl -0x30(%rbp), %eax
incl %eax
movl -0x2c(%rbp), %r12d
incl %r12d
cmpl 0x28(%r14), %eax
movq -0x38(%rbp), %rcx
jb 0x303f
xorl %eax, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/sort.c
// Function: tt_sort_heap
static int tt_sort_heap(struct tt_sort_input *in, struct tt_sort_stat *stat)
{
	struct tt_heap heap = {
		.num	= in->num,
		.data	= in->data,
		.cap	= in->count,
		.htype	= TT_HEAP_MAX,
	};

	int ret = tt_heap_init(&heap);
	if (ret)
		return ret;

	/* Build heap */
	tt_heap_build(&heap, heap.cap);

	void *head = heap.data;
	heap.__heaplen--;
	void *end = sort_ptr(&heap, heap.__heaplen);
	for (; heap.__heaplen >= 1; heap.__heaplen--) {
		/* NOTE: Heap length is __heaplen+1 */
		/* Swap [0] with [__heaplen] */
		heap.num.swap(&heap.num, head, end);
		end -= heap.num.size;
		/* [__heaplen] is OK, let's heapify [0] ~ [__heaplen-1] */
		tt_heap_heapify(&heap, 0);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movq %rsp, %rax
movaps %xmm1, 0x10(%rax)
movaps %xmm0, (%rax)
movq 0x20(%rdi), %rcx
movq %rcx, 0x20(%rax)
movl 0x28(%rdi), %ecx
movl %ecx, 0x28(%rax)
movq $0x0, 0x2c(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rax)
movq %rax, %rdi
callq 0x3c27
movl %eax, %ebp
testl %eax, %eax
jne 0x3333
movl 0x28(%rsp), %r14d
movl %r14d, 0x30(%rsp)
cmpl $0x2, %r14d
jb 0x32ec
shrl %r14d
incl %r14d
movq %rsp, %rbx
leal -0x2(%r14), %esi
movq %rbx, %rdi
callq *0x38(%rsp)
decl %r14d
cmpl $0x1, %r14d
jg 0x32d8
movq 0x20(%rsp), %rbx
movl 0x30(%rsp), %r14d
decl %r14d
movl %r14d, 0x30(%rsp)
je 0x3331
movq %rsp, %r15
imull (%r15), %r14d
addq %rbx, %r14
xorl %ebp, %ebp
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x10(%rsp)
movslq (%rsp), %rax
subq %rax, %r14
movq %r15, %rdi
xorl %esi, %esi
callq *0x38(%rsp)
decl 0x30(%rsp)
jne 0x330c
jmp 0x3333
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_init
int tt_stack_init(struct tt_stack *stack)
{
	if (stack->cap) {
		/* Allocate fixed array */
		stack->_data = malloc(stack->esize * stack->cap);
		if (!stack->_data)
			return TT_ENOMEM;
		stack->_top = stack->_data;
		stack->_push = tt_stack_push_array;
		stack->_pop = tt_stack_pop_array;
		tt_debug("Stack created, max elements = %u", stack->cap);
	} else {
		/* XXX: Allocate tt_list struct before element,
		 * the stack element only ensures 8-bytes alignment
		 */
		tt_assert(sizeof(struct tt_list) % 8 == 0);
		/* Initialize list head */
		tt_list_init(&stack->_head);
		stack->_push = tt_stack_push_list;
		stack->_pop = tt_stack_pop_list;
		tt_debug("Dynamic stack created");
	}

	stack->_count = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
testl %ebp, %ebp
je 0x369c
movl 0x4(%rbx), %edi
imull %ebp, %edi
callq 0x1120
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x36e3
movq %rax, 0x18(%rbx)
leaq 0x80(%rip), %rax        # 0x36ef
movq %rax, 0x20(%rbx)
leaq 0xbb(%rip), %rax        # 0x3735
movq %rax, 0x28(%rbx)
leaq 0x1ef5(%rip), %rsi      # 0x557a
leaq 0x1efc(%rip), %rdx      # 0x5588
movl $0x3, %edi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x296e
jmp 0x36d8
leaq 0x10(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
leaq 0xd1(%rip), %rax        # 0x3780
movq %rax, 0x20(%rbx)
leaq 0x12b(%rip), %rax       # 0x37e5
movq %rax, 0x28(%rbx)
leaq 0x1eb5(%rip), %rsi      # 0x557a
leaq 0x1edd(%rip), %rdx      # 0x55a9
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
jmp 0x36e8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_push_array
static int tt_stack_push_array(struct tt_stack *stack, const void *e)
{
	if (stack->_count >= stack->cap) {
		tt_debug("Overflow");
		return TT_EOVERFLOW;
	}
	memcpy(stack->_top, e, stack->esize);
	stack->_top += stack->esize;

	stack->_count++;
	return 0;
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %eax
cmpl (%rdi), %eax
jae 0x3714
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x4(%rbx), %edx
callq 0x1100
movl 0x4(%rbx), %eax
addq %rax, 0x18(%rbx)
incl 0x8(%rbx)
xorl %eax, %eax
jmp 0x3733
leaq 0x1ec2(%rip), %rsi      # 0x55dd
leaq 0x1ecf(%rip), %rdx      # 0x55f1
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_pop_array
static int tt_stack_pop_array(struct tt_stack *stack, void *e)
{
	if (stack->_count == 0) {
		tt_debug("Underflow");
		return TT_EUNDERFLOW;
	}
	stack->_top -= stack->esize;
	memcpy(e, stack->_top, stack->esize);

	stack->_count--;
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x8(%rdi)
je 0x375f
movq %rdi, %rbx
movl 0x4(%rdi), %edx
movq 0x18(%rdi), %rax
subq %rdx, %rax
movq %rax, 0x18(%rdi)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1100
decl 0x8(%rbx)
xorl %eax, %eax
jmp 0x377e
leaq 0x1e94(%rip), %rsi      # 0x55fa
leaq 0x1ea0(%rip), %rdx      # 0x560d
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_push_list
static int tt_stack_push_list(struct tt_stack *stack, const void *e)
{
	void *se = malloc(sizeof(struct tt_list) + stack->esize);
	if (!se)
		return TT_EOVERFLOW;
	memcpy(se + sizeof(struct tt_list), e, stack->esize);
	tt_list_add(se, &stack->_head);

	stack->_count++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
leaq 0x10(%r12), %rdi
callq 0x1120
testq %rax, %rax
je 0x37d4
movq %rax, %r15
movq %rax, %rdi
addq $0x10, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1100
leaq 0x10(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %r15, 0x10(%rbx)
movq %rax, 0x8(%r15)
movq %rcx, (%r15)
movq %r15, 0x8(%rcx)
incl 0x8(%rbx)
xorl %eax, %eax
jmp 0x37d9
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_pop_list
static int tt_stack_pop_list(struct tt_stack *stack, void *e)
{
	if (stack->_count == 0) {
		tt_debug("Underflow");
		return TT_EUNDERFLOW;
	}
	void *top = stack->_head.prev;
	memcpy(e, top + sizeof(struct tt_list), stack->esize);
	tt_list_del(top);
	free(top);

	stack->_count--;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
je 0x382c
movq %rdi, %rbx
movq 0x10(%rdi), %r14
leaq 0x10(%r14), %rax
movl 0x4(%rdi), %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1100
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
callq 0x1030
decl 0x8(%rbx)
xorl %eax, %eax
jmp 0x384b
leaq 0x1de4(%rip), %rsi      # 0x5617
leaq 0x1dd3(%rip), %rdx      # 0x560d
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/stack.c
// Function: tt_stack_free
void tt_stack_free(struct tt_stack *stack)
{
	if (stack->cap) {
		/* Free the array */
		free(stack->_data);
		stack->_data = NULL;
	} else {
		/* Free the list */
		struct tt_list *pos, *tmp;
		tt_list_for_each_safe(pos, tmp, &stack->_head)
			free(pos);
	}

	tt_debug("Stack destroyed");
	stack->_count = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpl $0x0, (%rdi)
je 0x3875
movq (%r14), %rdi
callq 0x1030
movq $0x0, (%r14)
jmp 0x388f
movq 0x18(%rbx), %rdi
cmpq %r14, %rdi
je 0x388f
movq 0x8(%rdi), %r15
callq 0x1030
movq %r15, %rdi
cmpq %r14, %r15
jne 0x387e
leaq 0x1d29(%rip), %rsi      # 0x55bf
leaq 0x1d30(%rip), %rdx      # 0x55cd
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_init
int tt_queue_init(struct tt_queue *queue)
{
	if (queue->cap) {
		/* Allocate fixed array */
		queue->_data = malloc(queue->esize * queue->cap);
		if (!queue->_data)
			return TT_ENOMEM;
		queue->_qhead = queue->_qtail = queue->_data;
		queue->_enque = tt_queue_enque_array;
		queue->_deque = tt_queue_deque_array;
		tt_debug("Queue created, max elements = %u", queue->cap);
	} else {
		/* XXX: Allocate tt_list struct before element,
		 * the queue element only ensures 8-bytes alignment
		 */
		tt_assert(sizeof(struct tt_list) % 8 == 0);
		/* Initialize list head */
		tt_list_init(&queue->_head);
		queue->_enque = tt_queue_enque_list;
		queue->_deque = tt_queue_deque_list;
		tt_debug("Dynamic queue created");
	}

	queue->_count = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %ebp
testl %ebp, %ebp
je 0x3918
movl 0x4(%rbx), %edi
imull %ebp, %edi
callq 0x1120
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x395f
movq %rax, 0x20(%rbx)
movq %rax, 0x18(%rbx)
leaq 0x80(%rip), %rax        # 0x396b
movq %rax, 0x28(%rbx)
leaq 0xd2(%rip), %rax        # 0x39c8
movq %rax, 0x30(%rbx)
leaq 0x1d28(%rip), %rsi      # 0x5629
leaq 0x1d2f(%rip), %rdx      # 0x5637
movl $0x3, %edi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x296e
jmp 0x3954
leaq 0x10(%rbx), %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
leaq 0xff(%rip), %rax        # 0x3a2a
movq %rax, 0x28(%rbx)
leaq 0x159(%rip), %rax       # 0x3a8f
movq %rax, 0x30(%rbx)
leaq 0x1ce8(%rip), %rsi      # 0x5629
leaq 0x1d10(%rip), %rdx      # 0x5658
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0x0, 0x8(%rbx)
xorl %eax, %eax
jmp 0x3964
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_enque_array
static int tt_queue_enque_array(struct tt_queue *queue, const void *e)
{
	if (queue->_count >= queue->cap) {
		tt_debug("Overflow");
		return TT_EOVERFLOW;
	}
	memcpy(queue->_qtail, e, queue->esize);
	queue->_qtail += queue->esize;
	/* Wrap to head */
	if (queue->_qtail >= queue->_data + queue->cap * queue->esize)
		queue->_qtail = queue->_data;

	queue->_count++;
	return 0;
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %eax
cmpl (%rdi), %eax
jae 0x39a7
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl 0x4(%rbx), %edx
callq 0x1100
movl 0x4(%rbx), %eax
movl (%rbx), %ecx
imull %eax, %ecx
addq 0x20(%rbx), %rax
movq 0x10(%rbx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
cmovaeq %rdx, %rax
movq %rax, 0x20(%rbx)
incl 0x8(%rbx)
xorl %eax, %eax
jmp 0x39c6
leaq 0x1cde(%rip), %rsi      # 0x568c
leaq 0x1c3c(%rip), %rdx      # 0x55f1
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_deque_array
static int tt_queue_deque_array(struct tt_queue *queue, void *e)
{
	if (queue->_count == 0) {
		tt_debug("Underflow");
		return TT_EUNDERFLOW;
	}
	memcpy(e, queue->_qhead, queue->esize);
	queue->_qhead += queue->esize;
	/* Wrap to head */
	if (queue->_qhead >= queue->_data + queue->cap * queue->esize)
		queue->_qhead = queue->_data;

	queue->_count--;
	return 0;
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x8(%rdi)
je 0x3a09
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movl 0x4(%rdi), %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1100
movl 0x4(%rbx), %eax
movl (%rbx), %ecx
imull %eax, %ecx
addq 0x18(%rbx), %rax
movq 0x10(%rbx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
cmovaeq %rdx, %rax
movq %rax, 0x18(%rbx)
decl 0x8(%rbx)
xorl %eax, %eax
jmp 0x3a28
leaq 0x1c91(%rip), %rsi      # 0x56a1
leaq 0x1bf6(%rip), %rdx      # 0x560d
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_enque_list
static int tt_queue_enque_list(struct tt_queue *queue, const void *e)
{
	void *qe = malloc(sizeof(struct tt_list) + queue->esize);
	if (!qe)
		return TT_EOVERFLOW;
	memcpy(qe + sizeof(struct tt_list), e, queue->esize);
	tt_list_add(qe, &queue->_head);

	queue->_count++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
leaq 0x10(%r12), %rdi
callq 0x1120
testq %rax, %rax
je 0x3a7e
movq %rax, %r15
movq %rax, %rdi
addq $0x10, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1100
leaq 0x10(%rbx), %rax
movq 0x10(%rbx), %rcx
movq %r15, 0x10(%rbx)
movq %rax, 0x8(%r15)
movq %rcx, (%r15)
movq %r15, 0x8(%rcx)
incl 0x8(%rbx)
xorl %eax, %eax
jmp 0x3a83
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_deque_list
static int tt_queue_deque_list(struct tt_queue *queue, void *e)
{
	if (queue->_count == 0) {
		tt_debug("Underflow");
		return TT_EUNDERFLOW;
	}
	void *qe = queue->_head.next;
	memcpy(e, qe + sizeof(struct tt_list), queue->esize);
	tt_list_del(qe);
	free(qe);

	queue->_count--;
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x0, 0x8(%rdi)
je 0x3ad6
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x10(%r14), %rax
movl 0x4(%rdi), %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1100
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq %r14, %rdi
callq 0x1030
decl 0x8(%rbx)
xorl %eax, %eax
jmp 0x3af5
leaq 0x1bd9(%rip), %rsi      # 0x56b6
leaq 0x1b29(%rip), %rdx      # 0x560d
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/queue.c
// Function: tt_queue_free
void tt_queue_free(struct tt_queue *queue)
{
	if (queue->cap) {
		/* Free the array */
		free(queue->_data);
		queue->_data = NULL;
	} else {
		/* Free the list */
		struct tt_list *pos, *tmp;
		tt_list_for_each_safe(pos, tmp, &queue->_head)
			free(pos);
	}

	tt_debug("Queue destroyed");
	queue->_count = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
cmpl $0x0, (%rdi)
je 0x3b1f
movq (%r14), %rdi
callq 0x1030
movq $0x0, (%r14)
jmp 0x3b39
movq 0x18(%rbx), %rdi
cmpq %r14, %rdi
je 0x3b39
movq 0x8(%rdi), %r15
callq 0x1030
movq %r15, %rdi
cmpq %r14, %r15
jne 0x3b28
leaq 0x1b2e(%rip), %rsi      # 0x566e
leaq 0x1b35(%rip), %rdx      # 0x567c
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movl $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/heap.c
// Function: tt_heap_adjust
int tt_heap_adjust(struct tt_heap *heap, int index, const void *v)
{
	tt_assert(index < heap->__heaplen);
	/* Verify new value
	 * max-heap: increase, min-heap: decrease
	 */
	int d = heap->num.cmp(&heap->num, heap_ptr(heap, index), v);
	if (d == 0)
		return 0;
	if ((heap->htype == TT_HEAP_MAX && d > 0) ||
			(heap->htype == TT_HEAP_MIN && d < 0)) {
		tt_error("Invalid new value");
		return TT_EINVAL;
	}

	heap->_adjust(heap, index);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl %esi, 0x30(%rdi)
jbe 0x3bd7
movl %esi, %ebp
movq %rdi, %rbx
movslq (%rdi), %rax
movslq %esi, %rsi
imulq %rax, %rsi
addq 0x20(%rdi), %rsi
callq *0x8(%rdi)
xorl %r14d, %r14d
testl %eax, %eax
je 0x3bcf
movl 0x2c(%rbx), %ecx
testl %ecx, %ecx
sete %dl
testl %eax, %eax
setg %sil
testb %dl, %sil
jne 0x3ba8
cmpl $0x1, %ecx
setne %cl
testl %eax, %eax
setns %al
orb %cl, %al
jne 0x3bc7
leaq 0x1b1b(%rip), %rsi      # 0x56ca
leaq 0x1b35(%rip), %rdx      # 0x56eb
xorl %edi, %edi
xorl %eax, %eax
callq 0x296e
movl $0xfffffffe, %r14d      # imm = 0xFFFFFFFE
jmp 0x3bcf
movq %rbx, %rdi
movl %ebp, %esi
callq *0x40(%rbx)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x15c1
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/heap.c
// Function: tt_heap_extract
int tt_heap_extract(struct tt_heap *heap, void *v)
{
	if (heap->__heaplen == 0)
		return TT_EUNDERFLOW;
	heap->num._set(&heap->num, v, heap->data);

	heap->__heaplen--;
	if (heap->__heaplen) {
		heap->num._set(&heap->num, heap->data,
				heap_ptr(heap, heap->__heaplen));
		tt_heap_heapify(heap, 0);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x30(%rdi)
je 0x3c15
movq %rdi, %rbx
movq 0x20(%rdi), %rdx
callq *0x18(%rdi)
movl 0x30(%rbx), %edx
decl %edx
movl %edx, 0x30(%rbx)
je 0x3c1c
movq 0x20(%rbx), %rsi
imull (%rbx), %edx
addq %rsi, %rdx
movq %rbx, %rdi
callq *0x18(%rbx)
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
jmp 0x3c1e
movl $0xfffffffc, %ebp       # imm = 0xFFFFFFFC
jmp 0x3c1e
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/heap.c
// Function: tt_heap_init
int tt_heap_init(struct tt_heap *heap)
{
	int ret = _tt_key_select(&heap->num);
	if (ret)
		return ret;

	if (heap->htype == TT_HEAP_MIN) {
		tt_debug("Min-heap initialized");
		heap->_heapify = tt_heap_heapify_min;
		heap->_adjust = tt_heap_adjust_min;
	} else {
		tt_debug("Max-heap initialized");
		heap->_heapify = tt_heap_heapify_max;
		heap->_adjust = tt_heap_adjust_max;
	}

	heap->__heaplen = 0;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2b44
movl %eax, %ebp
testl %eax, %eax
jne 0x3c9a
cmpl $0x1, 0x2c(%rbx)
leaq 0x1ac3(%rip), %rax      # 0x570a
leaq 0x1ad1(%rip), %rdx      # 0x571f
cmoveq %rax, %rdx
leaq 0x4e(%rip), %rax        # 0x3ca7
leaq 0x10e(%rip), %r14       # 0x3d6e
cmoveq %rax, %r14
leaq 0xf7(%rip), %rax        # 0x3d62
leaq 0x1c7(%rip), %r15       # 0x3e39
cmoveq %rax, %r15
leaq 0x1a80(%rip), %rsi      # 0x56fd
xorl %ebp, %ebp
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
movq %r14, 0x38(%rbx)
movq %r15, 0x40(%rbx)
movl $0x0, 0x30(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/heap.c
// Function: tt_heap_heapify_max
static inline void tt_heap_heapify_internal(
		struct tt_heap *heap, int index,
		int (*cmp)(const struct tt_key *, const void *, const void*))
{
	while (index < heap->__heaplen / 2) {
		/* Compare and swap with [2*index+1], [2*index+2] */
		void *iptr = heap_ptr(heap, index);
		index = index * 2 + 1;	/* Left child */
		void *lptr = heap_ptr(heap, index);
		void *rptr = lptr + heap->num.size;

		void *swaptr = iptr;
		if (cmp(&heap->num, swaptr, lptr) < 0)
			swaptr = lptr;
		if (index < heap->__heaplen - 1 &&
				cmp(&heap->num, swaptr, rptr) < 0) {
			swaptr = rptr;
			index++;	/* Right child */
		}
		if (swaptr != iptr)
			heap->num.swap(&heap->num, iptr, swaptr);
		else
			break;
	}
}

// Assembly:
movl 0x30(%rdi), %eax
shrl %eax
cmpl %esi, %eax
jbe 0x3e38
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r13d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rbx), %rax
movslq (%rbx), %r14
movl %r14d, %ecx
imull %r13d, %ecx
movslq %ecx, %r15
addq %rax, %r15
movq %r13, 0x10(%rsp)
leal 0x1(,%r13,2), %ebp
movl %r14d, %ecx
imull %ebp, %ecx
movslq %ecx, %r13
addq %rax, %r13
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x8(%rsp)
movq %r13, %r12
testl %eax, %eax
js 0x3ddc
movq %r15, %r12
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, %ebp
jae 0x3e08
addq %r14, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq *0x8(%rsp)
testl %eax, %eax
jns 0x3e08
movq 0x10(%rsp), %rax
addl %eax, %eax
addl $0x2, %eax
movl %eax, %ebp
movq %r13, %r12
movl %ebp, %r13d
cmpq %r15, %r12
je 0x3e2a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rbx)
movl 0x30(%rbx), %eax
shrl %eax
cmpl %eax, %r13d
jb 0x3d98
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/heap.c
// Function: tt_heap_adjust_internal
static inline void tt_heap_adjust_internal(
		struct tt_heap *heap, int index,
		int (*cmp)(const struct tt_key *, const void *, const void*))
{
	/* Buffer for one element */
	char tmp[heap->num.size] _tt_align(8);	/* C99 VLA, huha! */
	void *v = heap_ptr(heap, index);
	heap->num._set(&heap->num, tmp, v);

	while (index > 0) {
		int parent = (index - 1) / 2;
		void *pv = heap_ptr(heap, parent);
		if (cmp(&heap->num, tmp, pv) <= 0)
			break;
		heap->num._set(&heap->num, v, pv);
		v = pv;
		index = parent;
	}

	heap->num._set(&heap->num, v, tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, -0x40(%rbp)
movl %esi, %r14d
movq %rdi, %rbx
movl (%rdi), %eax
movq %rsp, %rsi
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %rsi
movq %rsi, %rsp
imull %r14d, %eax
movslq %eax, %rdx
addq 0x20(%rdi), %rdx
movq %rsi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
callq *0x18(%rdi)
testl %r14d, %r14d
jle 0x3ee0
leal -0x1(%r14), %r12d
shrl %r12d
movslq (%rbx), %rax
movq %r12, %r13
imulq %rax, %r13
addq 0x20(%rbx), %r13
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq *-0x40(%rbp)
movl %eax, %r15d
testl %eax, %eax
jle 0x3ecf
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
callq *0x18(%rbx)
movq %r13, -0x30(%rbp)
jmp 0x3ed6
movq -0x30(%rbp), %r13
movl %r14d, %r12d
movl %r12d, %r14d
testl %r15d, %r15d
jg 0x3e8e
jmp 0x3ee4
movq -0x30(%rbp), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq -0x38(%rbp), %rdx
callq *0x18(%rbx)
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_bintree_init
void tt_bintree_init(struct tt_bintree *tree)
{
	if (!tree->ops) {
		tt_debug("Red-Black tree initialized");
		tree->ops = &tt_rbtree_ops;
	} else {
		tt_debug("Binary tree initialized");
	}

	if (!tree->knum.swap)
		tree->knum.swap = tt_bintree_swap_dummy;
	_tt_key_select(&tree->knum);

	tree->_root = NULL;
	tree->_count = 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
je 0x3f27
leaq 0x1822(%rip), %rsi      # 0x5734
leaq 0x1846(%rip), %rdx      # 0x575f
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
jmp 0x3f4c
leaq 0x1806(%rip), %rsi      # 0x5734
leaq 0x180f(%rip), %rdx      # 0x5744
movl $0x3, %edi
xorl %eax, %eax
callq 0x296e
leaq 0x4190(%rip), %rax      # 0x80d8
movq %rax, 0x20(%rbx)
cmpq $0x0, 0x10(%rbx)
jne 0x3f5e
leaq 0x1d(%rip), %rax        # 0x3f77
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2b44
movq $0x0, 0x28(%rbx)
movl $0x0, 0x30(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_bintree_free_internal
static void tt_bintree_free_internal(struct tt_bintree_node *node)
{
	if (node) {
		tt_bintree_free_internal(node->left);
		tt_bintree_free_internal(node->right);
		free(node);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x3fd3
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x3faf
movq 0x20(%rbx), %rdi
callq 0x3faf
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_min
static inline struct tt_bintree_node *tt_rbtree_min(
		struct tt_bintree_node *node)
{
	if (node) {
		while (node->left)
			node = node->left;
	}
	return node;
}

// Assembly:
testq %rdi, %rdi
je 0x3fe6
movq %rdi, %rax
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x3fd9
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_max
static inline struct tt_bintree_node *tt_rbtree_max(
		struct tt_bintree_node *node)
{
	if (node) {
		while (node->right)
			node = node->right;
	}
	return node;
}

// Assembly:
testq %rdi, %rdi
je 0x3ffb
movq %rdi, %rax
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x3fee
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_search
static struct tt_bintree_node *tt_rbtree_search(
		const struct tt_bintree *tree, const void *key)
{
	struct tt_bintree_node *node = tree->_root;
	while (node) {
		int c = tree->knum.cmp(&tree->knum, key, node->key);
		if (c == 0)
			break;
		else if (c < 0)
			node = node->left;
		else
			node = node->right;
	}
	return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rbx
testq %rbx, %rbx
je 0x4035
movq (%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *0x8(%r15)
testl %eax, %eax
je 0x402f
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
movq 0x18(%rbx,%rcx,8), %rbx
testl %eax, %eax
jne 0x400d
jmp 0x4037
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_walk_in
static int tt_rbtree_walk_in(const struct tt_bintree_node *node, void *context,
		bool (*walk)(const void *key, const void *v, void *context))
{
	while (node) {
		if (tt_rbtree_walk_in(node->left, context, walk))
			return TT_ESTOP;
		if (!walk(node->key, node->data, context))
			return TT_ESTOP;
		node = node->right;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x44f3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x5, %ebp
movq 0x18(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x44ad
testl %eax, %eax
jne 0x44f5
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %r14, %rdx
callq *%rbx
testb %al, %al
je 0x44f5
movq 0x20(%r15), %r15
testq %r15, %r15
jne 0x44c7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_rotate_left
static void tt_rbtree_rotate_left(struct tt_bintree *tree,
		struct tt_bintree_node *x)
{
	struct tt_bintree_node *y = x->right;
	x->right = y->left;
	if (y->left)
		y->left->parent = x;
	y->parent = x->parent;
	if (!x->parent)
		tree->_root = y;
	else if (x == x->parent->left)
		x->parent->left = y;
	else
		x->parent->right = y;
	y->left = x;
	x->parent = y;
}

// Assembly:
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x20(%rsi)
testq %rcx, %rcx
je 0x4517
movq %rsi, 0x10(%rcx)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x453a
leaq 0x18(%rcx), %rdx
leaq 0x20(%rcx), %rdi
cmpq %rsi, 0x18(%rcx)
cmoveq %rdx, %rdi
jmp 0x453e
addq $0x28, %rdi
movq %rax, (%rdi)
movq %rsi, 0x18(%rax)
movq %rax, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/cyb70289[P]tt/src/common/tree.c
// Function: tt_rbtree_rotate_right
static void tt_rbtree_rotate_right(struct tt_bintree *tree,
		struct tt_bintree_node *y)
{
	struct tt_bintree_node *x = y->left;
	y->left = x->right;
	if (x->right)
		x->right->parent = y;
	x->parent = y->parent;
	if (!y->parent)
		tree->_root = x;
	else if (y == y->parent->left)
		y->parent->left = x;
	else
		y->parent->right = x;
	x->right = y;
	y->parent = x;
}

// Assembly:
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rsi)
testq %rcx, %rcx
je 0x455f
movq %rsi, 0x10(%rcx)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x4582
leaq 0x18(%rcx), %rdx
leaq 0x20(%rcx), %rdi
cmpq %rsi, 0x18(%rcx)
cmoveq %rdx, %rdi
jmp 0x4586
addq $0x28, %rdi
movq %rax, (%rdi)
movq %rsi, 0x20(%rax)
movq %rax, 0x10(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_capacity
dhara_sector_t dhara_map_capacity(const struct dhara_map *m)
{
	const dhara_sector_t cap = dhara_journal_capacity(&m->journal);
	const dhara_sector_t reserve = cap / (m->gc_ratio + 1);
	const dhara_sector_t safety_margin =
		DHARA_MAX_RETRIES << m->journal.nand->log2_ppb;

	if (reserve + safety_margin >= cap)
		return 0;

	return cap - reserve - safety_margin;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x21c3
movl %eax, %esi
movzbl 0x38(%rbx), %ecx
incl %ecx
xorl %edx, %edx
divl %ecx
movq (%rbx), %rcx
movb 0x1(%rcx), %cl
movl $0x8, %edx
shll %cl, %edx
xorl %ecx, %ecx
addl %eax, %edx
subl %edx, %esi
cmovbl %ecx, %esi
movl %esi, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: trace_path
static int trace_path(struct dhara_map *m, dhara_sector_t target,
		      dhara_page_t *loc, uint8_t *new_meta,
		      dhara_error_t *err)
{
	uint8_t meta[DHARA_META_SIZE];
	int depth = 0;
	dhara_page_t p = dhara_journal_root(&m->journal);

	if (new_meta)
		meta_set_id(new_meta, target);

	if (p == DHARA_PAGE_NONE)
		goto not_found;

	if (dhara_journal_read_meta(&m->journal, p, meta, err) < 0)
		return -1;

	while (depth < DHARA_RADIX_DEPTH) {
		const dhara_sector_t id = meta_get_id(meta);

		if (id == DHARA_SECTOR_NONE)
			goto not_found;

		if ((target ^ id) & d_bit(depth)) {
			if (new_meta)
				meta_set_alt(new_meta, depth, p);

			p = meta_get_alt(meta, depth);
			if (p == DHARA_PAGE_NONE) {
				depth++;
				goto not_found;
			}

			if (dhara_journal_read_meta(&m->journal, p,
						    meta, err) < 0)
				return -1;
		} else {
			if (new_meta)
				meta_set_alt(new_meta, depth,
					meta_get_alt(meta, depth));
		}

		depth++;
	}

	if (loc)
		*loc = p;

	return 0;

not_found:
	if (new_meta) {
		while (depth < DHARA_RADIX_DEPTH)
			meta_set_alt(new_meta, depth++, DHARA_SECTOR_NONE);
	}

	dhara_set_error(err, DHARA_E_NOT_FOUND);
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rbp
movl %esi, %r13d
movq %rdi, %r12
movl 0x28(%rdi), %r15d
testq %rcx, %rcx
je 0x13a5
movl %r13d, (%r14)
cmpl $-0x1, %r15d
je 0x145f
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rcx
callq 0x2226
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testl %eax, %eax
js 0x14ba
movq %rbp, 0x8(%rsp)
xorl %ebp, %ebp
cmpl $0x1f, %ebp
ja 0x14ab
movl 0x10(%rsp), %edx
movl $0x2, %eax
cmpl $-0x1, %edx
je 0x144f
xorl %r13d, %edx
movl %ebp, %ecx
shll %cl, %edx
testl $0x80000000, %edx       # imm = 0x80000000
je 0x1431
movl %ebp, %ecx
testq %r14, %r14
je 0x1408
movl %r15d, 0x4(%r14,%rcx,4)
movl 0x14(%rsp,%rcx,4), %r15d
cmpl $-0x1, %r15d
je 0x1447
movq %r12, %rdi
movl %r15d, %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x2226
testl %eax, %eax
jns 0x1441
movl $0x1, %eax
jmp 0x144f
testq %r14, %r14
je 0x1441
movl %ebp, %eax
movl 0x14(%rsp,%rax,4), %ecx
movl %ecx, 0x4(%r14,%rax,4)
incl %ebp
xorl %eax, %eax
jmp 0x144f
incl %ebp
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x13d6
cmpl $0x2, %eax
je 0x1461
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
jmp 0x14ba
xorl %ebp, %ebp
testq %r14, %r14
setne %al
cmpl $0x20, %ebp
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1499
movl %ebp, %eax
shll $0x2, %ebp
incq %rax
movq %rax, %rcx
movslq %ebp, %rdx
leal 0x4(%rdx), %ebp
incq %rcx
movl $0xffffffff, 0x4(%r14,%rdx) # imm = 0xFFFFFFFF
cmpl $0x20, %eax
movq %rcx, %rax
jne 0x147f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x14ba
movl $0x6, (%rbx)
jmp 0x14ba
xorl %ecx, %ecx
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x14ba
movl %r15d, (%rax)
movl %ecx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_read
int dhara_map_read(struct dhara_map *m, dhara_sector_t s,
		   uint8_t *data, dhara_error_t *err)
{
	const struct dhara_nand *n = m->journal.nand;
	dhara_error_t my_err;
	dhara_page_t p;

	if (dhara_map_find(m, s, &p, &my_err) < 0) {
		if (my_err == DHARA_E_NOT_FOUND) {
			memset(data, 0xff, 1 << n->log2_page_size);
			return 0;
		}

		dhara_set_error(err, my_err);
		return -1;
	}

	return dhara_nand_read(n, p, 0, 1 << n->log2_page_size, data, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq (%rdi), %r15
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %r8
xorl %ecx, %ecx
callq 0x1379
testl %eax, %eax
js 0x1518
movl 0x8(%rsp), %esi
movb (%r15), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %r8
movq %r14, %r9
callq 0x3495
jmp 0x154c
movl 0xc(%rsp), %ecx
cmpl $0x6, %ecx
jne 0x153f
movb (%r15), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdx
movq %rbx, %rdi
movl $0xff, %esi
callq 0x1090
xorl %eax, %eax
jmp 0x154c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x154c
movl %ecx, (%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_write
int dhara_map_write(struct dhara_map *m, dhara_sector_t dst,
		    const uint8_t *data, dhara_error_t *err)
{
	for (;;) {
		uint8_t meta[DHARA_META_SIZE];
		dhara_error_t my_err;
		const dhara_sector_t old_count = m->count;

		if (prepare_write(m, dst, meta, err) < 0)
			return -1;

		if (!dhara_journal_enqueue(&m->journal, data, meta, &my_err))
			break;

		m->count = old_count;

		if (try_recover(m, my_err, err) < 0)
			return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movl 0x3c(%r15), %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x15ee
testl %eax, %eax
js 0x15be
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
leaq 0xc(%rsp), %rcx
callq 0x23f1
testl %eax, %eax
je 0x15c5
movl %r13d, 0x3c(%r15)
movl 0xc(%rsp), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x16a5
shrl $0x1f, %eax
jmp 0x15ca
movl $0x1, %eax
jmp 0x15ca
movl $0x2, %eax
testl %eax, %eax
je 0x1577
cmpl $0x1, %eax
jne 0x15da
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x15dc
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: prepare_write
static int prepare_write(struct dhara_map *m, dhara_sector_t dst,
			 uint8_t *meta, dhara_error_t *err)
{
	dhara_error_t my_err;

	if (auto_gc(m, err) < 0)
		return -1;

	if (trace_path(m, dst, NULL, meta, &my_err) < 0) {
		if (my_err != DHARA_E_NOT_FOUND) {
			dhara_set_error(err, my_err);
			return -1;
		}

		if (m->count >= dhara_map_capacity(m)) {
			dhara_set_error(err, DHARA_E_MAP_FULL);
			return -1;
		}

		m->count++;
	}

	ck_set_count(dhara_journal_cookie(&m->journal), m->count);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq %rcx, %rsi
callq 0x19b6
testl %eax, %eax
js 0x168f
xorl %r14d, %r14d
leaq 0xc(%rsp), %r8
movq %r15, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r12, %rcx
callq 0x1379
testl %eax, %eax
js 0x1639
movq 0x8(%r15), %rax
movl 0x3c(%r15), %ecx
movl %ecx, 0x10(%rax)
jmp 0x1695
movl 0xc(%rsp), %eax
cmpl $0x6, %eax
jne 0x167b
movl 0x3c(%r15), %ebp
movq %r15, %rdi
callq 0x21c3
movl %eax, %esi
movzbl 0x38(%r15), %ecx
incl %ecx
xorl %edx, %edx
divl %ecx
movq (%r15), %rcx
movb 0x1(%rcx), %cl
movl $0x8, %edx
shll %cl, %edx
xorl %ecx, %ecx
addl %eax, %edx
subl %edx, %esi
cmovbl %ecx, %esi
cmpl %esi, %ebp
jae 0x1684
incl 0x3c(%r15)
jmp 0x162c
testq %rbx, %rbx
je 0x168f
movl %eax, (%rbx)
jmp 0x168f
testq %rbx, %rbx
je 0x168f
movl $0x7, (%rbx)
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: try_recover
static int try_recover(struct dhara_map *m, dhara_error_t cause,
		       dhara_error_t *err)
{
	int restart_count = 0;

	if (cause != DHARA_E_RECOVER) {
		dhara_set_error(err, cause);
		return -1;
	}

	while (dhara_journal_in_recovery(&m->journal)) {
		dhara_page_t p = dhara_journal_next_recoverable(&m->journal);
		dhara_error_t my_err;
		int ret;

		if (p == DHARA_PAGE_NONE)
			ret = pad_queue(m, &my_err);
		else
			ret = raw_gc(m, p, &my_err);

		if (ret < 0) {
			if (my_err != DHARA_E_RECOVER) {
				dhara_set_error(err, my_err);
				return -1;
			}

			if (restart_count >= DHARA_MAX_RETRIES) {
				dhara_set_error(err, DHARA_E_TOO_BAD);
				return -1;
			}

			restart_count++;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
cmpl $0x4, %esi
jne 0x172b
movq %rdi, %r15
xorl %ebx, %ebx
leaq 0xc(%rsp), %r12
xorl %ebp, %ebp
testb $0x4, 0x12(%r15)
je 0x1738
movq %r15, %rdi
callq 0x2897
movq %r15, %rdi
cmpl $-0x1, %eax
je 0x16e8
movl %eax, %esi
movq %r12, %rdx
callq 0x1b23
jmp 0x16f0
movq %r12, %rsi
callq 0x1aaf
movb $0x1, %cl
testl %eax, %eax
jns 0x1720
movl 0xc(%rsp), %eax
cmpl $0x4, %eax
jne 0x1712
cmpl $0x8, %ebp
jl 0x171e
testq %r14, %r14
je 0x171a
movl $0x3, (%r14)
jmp 0x171a
testq %r14, %r14
je 0x171a
movl %eax, (%r14)
xorl %ecx, %ecx
jmp 0x1720
incl %ebp
testb %cl, %cl
jne 0x16c5
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1738
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x1738
movl %esi, (%r14)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_copy_page
int dhara_map_copy_page(struct dhara_map *m, dhara_page_t src,
			dhara_sector_t dst, dhara_error_t *err)
{
	for (;;) {
		uint8_t meta[DHARA_META_SIZE];
		dhara_error_t my_err;
		const dhara_sector_t old_count = m->count;

		if (prepare_write(m, dst, meta, err) < 0)
			return -1;

		if (!dhara_journal_copy(&m->journal, src, meta, &my_err))
			break;

		m->count = old_count;

		if (try_recover(m, my_err, err) < 0)
			return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movl 0x3c(%r15), %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x15ee
testl %eax, %eax
js 0x17af
movq %r15, %rdi
movl %r14d, %esi
movq %r12, %rdx
leaq 0xc(%rsp), %rcx
callq 0x2809
testl %eax, %eax
je 0x17b6
movl %r13d, 0x3c(%r15)
movl 0xc(%rsp), %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x16a5
shrl $0x1f, %eax
jmp 0x17bb
movl $0x1, %eax
jmp 0x17bb
movl $0x2, %eax
testl %eax, %eax
je 0x1768
cmpl $0x1, %eax
jne 0x17cb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x17cd
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_copy_sector
int dhara_map_copy_sector(struct dhara_map *m, dhara_sector_t src,
			  dhara_sector_t dst, dhara_error_t *err)
{
	dhara_error_t my_err;
	dhara_page_t p;

	if (dhara_map_find(m, src, &p, &my_err) < 0) {
		if (my_err == DHARA_E_NOT_FOUND)
			return dhara_map_trim(m, dst, err);

		dhara_set_error(err, my_err);
		return -1;
	}

	return dhara_map_copy_page(m, p, dst, err);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %r8
xorl %ecx, %ecx
callq 0x1379
testl %eax, %eax
js 0x1817
movl 0x8(%rsp), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x1747
jmp 0x183b
movl 0xc(%rsp), %ecx
cmpl $0x6, %ecx
jne 0x182f
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1844
jmp 0x183b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x183b
movl %ecx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: dhara_map_trim
int dhara_map_trim(struct dhara_map *m, dhara_sector_t s, dhara_error_t *err)
{
	for (;;) {
		dhara_error_t my_err;

		if (auto_gc(m, err) < 0)
			return -1;

		if (!try_delete(m, s, &my_err))
			break;

		if (try_recover(m, my_err, err) < 0)
			return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19b6
testl %eax, %eax
js 0x18ad
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
movq %r15, %rcx
leaq 0xc(%rsp), %r8
callq 0x1379
testl %eax, %eax
js 0x18b7
movl $0x20, %r12d
movl 0x10(%rsp,%r12,4), %r13d
cmpl $-0x1, %r13d
jne 0x18cd
decq %r12
jne 0x188f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x18d0
movl $0x1, %eax
jmp 0x198e
movl 0xc(%rsp), %eax
cmpl $0x6, %eax
je 0x1989
movl %eax, 0x8(%rsp)
jmp 0x1965
decl %r12d
testl %r12d, %r12d
js 0x1979
movq %r14, %rdi
movl %r13d, %esi
leaq 0xa0(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x2226
testl %eax, %eax
js 0x1965
movl 0xa0(%rsp), %eax
movl %eax, 0x10(%rsp)
leal (,%r12,4), %eax
cltq
movl $0xffffffff, 0x14(%rsp,%rax) # imm = 0xFFFFFFFF
cmpl $0x1e, %r12d
ja 0x1933
movl %r12d, %ecx
movl 0xa8(%rsp,%rcx,4), %edx
movl %edx, 0x18(%rsp,%rcx,4)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq $0x1f, %rdx
jne 0x191b
movl $0xffffffff, 0x14(%rsp,%rax) # imm = 0xFFFFFFFF
movq 0x8(%r14), %rax
movl 0x3c(%r14), %ecx
decl %ecx
movl %ecx, 0x10(%rax)
movq %r14, %rdi
movl %r13d, %esi
movq %r15, %rdx
leaq 0x8(%rsp), %rcx
callq 0x2809
testl %eax, %eax
js 0x1965
decl 0x3c(%r14)
jmp 0x1989
movl 0x8(%rsp), %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x16a5
shrl $0x1f, %eax
jmp 0x198e
movl $0x0, 0x3c(%r14)
movq %r14, %rdi
callq 0x23bc
movl $0x2, %eax
testl %eax, %eax
je 0x1862
cmpl $0x1, %eax
jne 0x19a2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x19a4
xorl %eax, %eax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/dlbeer[P]dhara/dhara/map.c
// Function: auto_gc
static int auto_gc(struct dhara_map *m, dhara_error_t *err)
{
	int i;

	if (dhara_journal_size(&m->journal) < dhara_map_capacity(m))
		return 0;

	for (i = 0; i <= m->gc_ratio; i++)
		if (dhara_map_gc(m, err) < 0)
			return -1;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x21ea
movl %eax, %r15d
movq %r14, %rdi
callq 0x21c3
movl %eax, %esi
movzbl 0x38(%r14), %ecx
incl %ecx
xorl %edx, %edx
divl %ecx
movq (%r14), %rcx
movb 0x1(%rcx), %cl
movl $0x8, %edx
shll %cl, %edx
xorl %ebp, %ebp
addl %eax, %edx
subl %edx, %esi
cmovbl %ebp, %esi
cmpl %esi, %r15d
jb 0x1a24
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bc3
testl %eax, %eax
js 0x1a1f
movzbl 0x38(%r14), %eax
incl %r15d
cmpl %eax, %r15d
jb 0x1a01
jmp 0x1a24
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq