// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/inter.cpp
// Function: mg_gchain_gen(void*, void*, asg_t const*, int, unsigned long const*, mg_lchain_t const*, mg128_t const*, unsigned int, int, int)
mg_gchains_t *mg_gchain_gen(void *km_dst, void *km, const asg_t *g, int32_t n_u, const uint64_t *u, const mg_lchain_t *lc, const mg128_t *a,
							uint32_t hash, int32_t min_gc_cnt, int32_t min_gc_score)
{
	mg_gchains_t *gc;
	mg_llchain_t *tmp;
	int32_t i, j, k, st, n_g, n_a, s_tmp, n_tmp, m_tmp;
	KCALLOC(km_dst, gc, 1);
	// count the number of gchains and remaining anchors
	// filter out low-quality g_chains
	for (i = 0, st = 0, n_g = n_a = 0; i < n_u; ++i) {
		///nui: how many linear chaisn in i-th g_chain
		int32_t m = 0, nui = (int32_t)u[i];
		for (j = 0; j < nui; ++j) m += lc[st + j].cnt; // m is the number of anchors in this gchain
		if (m >= min_gc_cnt && (int64_t)(u[i]>>32) >= min_gc_score)
			++n_g, n_a += m;
		st += nui;
	}
	if (n_g == 0) return gc;

	// preallocate
	gc->km = km_dst;
	gc->n_gc = n_g, gc->n_a = n_a;
	KCALLOC(km_dst, gc->gc, n_g);///all graph chains
	KMALLOC(km_dst, gc->a, n_a);///all anchors, aka minimizers

	// core loop
	tmp = 0; s_tmp = n_tmp = m_tmp = 0;
	for (i = k = 0, st = 0, n_a = 0; i < n_u; ++i) {
		int32_t n_a0 = n_a, m = 0, nui = (int32_t)u[i]; ///nui: how many linear chaisn in i-th g_chain
		for (j = 0; j < nui; ++j) m += lc[st + j].cnt; ///how many minizers in i-th g_chain
		if (m >= min_gc_cnt && (int64_t)(u[i]>>32) >= min_gc_score) {
			mg_llchain_t *q;
			uint32_t h = hash;

			gc->gc[k].score = u[i]>>32; ///chain score
			gc->gc[k].off = s_tmp; ///all minimizers of k-th chain: gc->a[gc->gc[k].off, )

			for (j = 0; j < nui; ++j) {///how many linear chains
				const mg_lchain_t *p = &lc[st + j];
				h += __ac_Wang_hash(p->qs) + __ac_Wang_hash(p->re) + __ac_Wang_hash(p->v);
			}
			gc->gc[k].hash = __ac_Wang_hash(h);///hash key for the k-th graph chain

			if (n_tmp == m_tmp) KEXPAND(km, tmp, m_tmp);
			// copy the first lchain to gc->a[] and tmp[] (aka, gc->lc[])
			// for the first lchain, it is easy and we just copy all its anchors
			copy_lchain(&tmp[n_tmp++], &lc[st], &n_a, gc->a, a); 
			///0-th lchain has been stored
			///process the remaining chains
			for (j = 1; j < nui; ++j) { 
				const mg_lchain_t *l0 = &lc[st + j - 1], *l1 = &lc[st + j];
				if (!l1->inner_pre) { // bridging two segments; if l0 and l1 are at different reference
					int32_t s, n_pathv;
					mg_path_dst_t dst;
					mg_pathv_t *p;
					memset(&dst, 0, sizeof(mg_path_dst_t));
					dst.v = l0->v ^ 1;
					assert(l1->dist_pre >= 0);
					dst.target_dist = l1->dist_pre;
					dst.target_hash = l1->hash_pre;///hash value of the whole path
					dst.check_hash = 1;
					p = mg_shortest_k(km, g, l1->v^1, 1, &dst, dst.target_dist, MG_MAX_SHORT_K, &n_pathv);
					if (n_pathv == 0 || dst.target_hash != dst.hash)
						fprintf(stderr, "%c[%d] -> %c[%d], dist=%d, target_dist=%d\n", "><"[(l1->v^1)&1], l1->v^1, "><"[(l0->v^1)&1], l0->v^1, dst.dist, dst.target_dist);
					assert(n_pathv > 0);
					assert(dst.target_hash == dst.hash);
					for (s = n_pathv - 2; s >= 1; --s) { // path found in a backward way, so we need to reverse it
						if (n_tmp == m_tmp) KEXPAND(km, tmp, m_tmp);
						q = &tmp[n_tmp++];
						q->off = q->cnt = q->score = 0;
						q->v = p[s].v^1; // when reversing a path, we also need to flip the orientation
					}
					kfree(km, p);
					if (n_tmp == m_tmp) KEXPAND(km, tmp, m_tmp);
					copy_lchain(&tmp[n_tmp++], l1, &n_a, gc->a, a);
				}
				else { // if both of them are at the same linear chain, just merge them
					#if 1
					int32_t k;
					mg_llchain_t *t = &tmp[n_tmp - 1];//the last lchain, have alread done
					assert(l0->v == l1->v);
					// a[].x: ref_id(31)rev(1)r_pos(32)
 					// a[].y: weight(8)query_id(8)flag(8)span(8)q_pos(32)
					for (k = 0; k < l1->cnt; ++k) {
						const mg128_t *ak = &a[l1->off + k];
						if ((int32_t)ak->x > l0->re && (int32_t)ak->y > l0->qe)//find colinear anchors
							break;
					}
					assert(k < l1->cnt);
					t->cnt += l1->cnt - k, t->score += l1->score;
					memcpy(&gc->a[n_a], &a[l1->off + k], (l1->cnt - k) * sizeof(mg128_t));
					n_a += l1->cnt - k;
					#else // don't use this block; for debugging only
					if (n_tmp == m_tmp) KEXPAND(km, tmp, m_tmp);
					copy_lchain(&tmp[n_tmp++], l1, &n_a, gc->a, a);
					#endif
				}
			}
			gc->gc[k].cnt = n_tmp - s_tmp;
			gc->gc[k].n_anchor = n_a - n_a0;
			++k, s_tmp = n_tmp;
		}
		st += nui;//nui: how many linear chains in this gchain
	}
	assert(n_a <= gc->n_a);

	gc->n_a = n_a;
	gc->n_lc = n_tmp;
	KMALLOC(km_dst, gc->lc, n_tmp);
	memcpy(gc->lc, tmp, n_tmp * sizeof(mg_llchain_t));
	kfree(km, tmp);

	mg_gchain_extra(g, gc);
	mg_gchain_sort_by_score(km, gc);
	return gc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %r13
movq %r8, 0x50(%rsp)
movl %ecx, %r12d
movq %rdx, 0x40(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, %r14
movl 0x138(%rsp), %ebx
movl $0x1, %esi
movl $0x40, %edx
callq 0x1e3590
movq %rax, 0x8(%rsp)
movslq %ebx, %rax
movq %rax, 0x38(%rsp)
movl %r12d, %eax
movq %rax, 0x48(%rsp)
testl %r12d, %r12d
jle 0x19dac6
leaq 0x4(%r13), %rcx
xorl %edx, %edx
xorl %esi, %esi
xorl %edi, %edi
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x50(%rsp), %r8
movq (%r8,%rsi,8), %r8
movl $0x0, %r9d
testl %r8d, %r8d
jle 0x19da8a
movslq %edi, %r9
movl %r8d, %r10d
andl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
leaq (%r9,%r9,4), %r9
leaq (%rcx,%r9,8), %r11
xorl %r9d, %r9d
movl (%r11), %ebp
addl %ebp, %ebp
sarl %ebp
addl %ebp, %r9d
addq $0x28, %r11
decq %r10
jne 0x19da77
cmpl 0x130(%rsp), %r9d
setge %r10b
movq %r8, %r11
shrq $0x20, %r11
cmpq 0x38(%rsp), %r11
setge %r11b
andb %r10b, %r11b
cmovel %edx, %r9d
addl %r9d, %ebx
movzbl %r11b, %r9d
addl %r9d, %eax
addl %r8d, %edi
incq %rsi
cmpq 0x48(%rsp), %rsi
jne 0x19da4b
jmp 0x19daca
xorl %ebx, %ebx
xorl %eax, %eax
testl %eax, %eax
movq 0x8(%rsp), %rbp
je 0x19e227
movq %r14, (%rbp)
movl %eax, 0x8(%rbp)
movl %ebx, 0x10(%rbp)
movslq %eax, %rsi
movl $0x48, %edx
movq %r14, %rdi
callq 0x1e3590
movq %rax, 0x18(%rbp)
movslq %ebx, %rsi
shlq $0x4, %rsi
movq %r14, 0x90(%rsp)
movq %r14, %rdi
callq 0x1e36fd
movq %rax, 0x28(%rbp)
testl %r12d, %r12d
jle 0x19e1b8
movq 0x120(%rsp), %rax
leaq 0x4(%r13), %rdi
leaq 0x14(%r13), %rcx
movq %rcx, 0x98(%rsp)
addq $0x8, %rax
movq %rax, 0xc0(%rsp)
xorl %r8d, %r8d
xorl %r11d, %r11d
xorl %r9d, %r9d
xorl %r10d, %r10d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl $0x0, 0x4(%rsp)
xorl %r12d, %r12d
movq %r13, 0xa8(%rsp)
movq %rdi, 0xa0(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%r8,8), %rcx
movl $0x0, %eax
movq %rcx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x19dba9
movslq %r10d, %rax
movq 0x10(%rsp), %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rdx
xorl %eax, %eax
movl (%rdx), %esi
addl %esi, %esi
sarl %esi
addl %esi, %eax
addq $0x28, %rdx
decq %rcx
jne 0x19db98
cmpl 0x130(%rsp), %eax
jl 0x19e1a0
movq 0x10(%rsp), %rax
movq %rax, %rcx
shrq $0x20, %rcx
cmpq 0x38(%rsp), %rcx
jl 0x19e1a5
movq %r8, 0xb8(%rsp)
movq %rax, %rsi
movq 0x18(%rbp), %rax
movl %r9d, 0x2c(%rsp)
movslq %r9d, %rdx
leaq (%rdx,%rdx,8), %rdx
movl %ecx, 0x14(%rax,%rdx,8)
movl %ebx, 0x24(%rsp)
movq %rdx, 0x30(%rsp)
movl %ebx, 0x8(%rax,%rdx,8)
movl %r10d, 0x28(%rsp)
movslq %r10d, %rbx
movl 0x128(%rsp), %edi
testl %esi, %esi
jle 0x19dcf6
movq 0x10(%rsp), %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rbx,%rbx,4), %rdx
movq 0x98(%rsp), %rsi
leaq (%rsi,%rdx,8), %rdx
movl (%rdx), %esi
movl %esi, %r8d
shll $0xf, %r8d
notl %r8d
addl %esi, %r8d
movl %r8d, %esi
shrl $0xa, %esi
xorl %r8d, %esi
leal (%rsi,%rsi,8), %esi
movl %esi, %r8d
shrl $0x6, %r8d
xorl %esi, %r8d
movl %r8d, %r9d
shll $0xb, %r9d
notl %r9d
addl %r8d, %r9d
movl %r9d, %esi
shrl $0x10, %esi
xorl %r9d, %esi
addl %edi, %esi
movl -0xc(%rdx), %edi
movl -0x4(%rdx), %r8d
movl %r8d, %r9d
shll $0xf, %r9d
notl %r9d
addl %r8d, %r9d
movl %r9d, %r8d
shrl $0xa, %r8d
xorl %r9d, %r8d
leal (%r8,%r8,8), %r8d
movl %r8d, %r9d
shrl $0x6, %r9d
xorl %r8d, %r9d
movl %r9d, %r10d
shll $0xb, %r10d
notl %r10d
addl %r9d, %r10d
movl %r10d, %r8d
shrl $0x10, %r8d
xorl %r10d, %r8d
movl %edi, %r9d
shll $0xf, %r9d
notl %r9d
addl %edi, %r9d
movl %r9d, %edi
shrl $0xa, %edi
xorl %r9d, %edi
leal (%rdi,%rdi,8), %edi
movl %edi, %r9d
shrl $0x6, %r9d
xorl %edi, %r9d
movl %r9d, %r10d
shll $0xb, %r10d
notl %r10d
addl %r9d, %r10d
movl %r10d, %edi
shrl $0x10, %edi
xorl %r10d, %edi
addl %r8d, %edi
addl %esi, %edi
addq $0x28, %rdx
decq %rcx
jne 0x19dc2b
movl %edi, %ecx
shll $0xf, %ecx
notl %ecx
addl %edi, %ecx
movl %ecx, %edx
shrl $0xa, %edx
xorl %ecx, %edx
leal (%rdx,%rdx,8), %ecx
movl %ecx, %edx
shrl $0x6, %edx
xorl %ecx, %edx
movl %edx, %ecx
shll $0xb, %ecx
notl %ecx
addl %edx, %ecx
movl %ecx, %edx
shrl $0x10, %edx
xorl %ecx, %edx
movq 0x30(%rsp), %rcx
movl %edx, 0x38(%rax,%rcx,8)
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jne 0x19dd65
movl %eax, %ebp
sarl %ebp
addl %eax, %ebp
cmpl $0x4, %eax
movl $0x10, %eax
cmovll %eax, %ebp
movslq %ebp, %rdx
shlq $0x4, %rdx
movq 0x18(%rsp), %rdi
movq %r11, %rsi
callq 0x1e3800
movq %rax, %r11
movl %ebp, 0x4(%rsp)
movq 0x8(%rsp), %rcx
jmp 0x19dd68
movq %rbp, %rcx
movslq %r14d, %r15
incl %r14d
shlq $0x4, %r15
leaq (%rbx,%rbx,4), %rbx
movq %r13, %rbp
movl 0x4(%r13,%rbx,8), %edx
leal (%rdx,%rdx), %eax
movq %r12, 0xb0(%rsp)
movslq %r12d, %r12
movq %r12, %rdi
shlq $0x4, %rdi
addq 0x28(%rcx), %rdi
sarl %eax
movl %eax, 0x4(%r11,%r15)
movl 0x8(%r13,%rbx,8), %eax
movl %eax, 0x8(%r11,%r15)
movl 0x1c(%r13,%rbx,8), %eax
movl %eax, 0xc(%r11,%r15)
movslq (%r13,%rbx,8), %rsi
shlq $0x4, %rsi
addq 0x120(%rsp), %rsi
shlq $0x21, %rdx
sarq $0x21, %rdx
shlq $0x4, %rdx
movq %r11, %r13
callq 0x2160
movq %r13, %r11
movl %r12d, (%r13,%r15)
addl 0x4(%r13,%r15), %r12d
movq 0x10(%rsp), %rax
cmpl $0x2, %eax
jl 0x19e151
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0xc8(%rsp)
leaq (,%rbx,8), %rax
addq %rbp, %rax
movq %rax, 0x58(%rsp)
movl $0x1, %r10d
movq 0x8(%rsp), %rbp
leaq (%r10,%r10,4), %rbx
movq 0x58(%rsp), %rax
leaq (%rax,%rbx,8), %r13
movl 0x4(%r13), %ecx
testl %ecx, %ecx
movq %r10, 0xe0(%rsp)
js 0x19e040
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movl -0x20(%r13), %eax
xorl $0x1, %eax
movl %eax, 0x60(%rsp)
movl 0x20(%r13), %r9d
testl %r9d, %r9d
js 0x19e25b
movq %r11, %rbp
movq %r12, 0xd8(%rsp)
movl %r9d, 0x64(%rsp)
movl 0x24(%r13), %eax
movl %eax, 0x68(%rsp)
orb $0x40, 0x6f(%rsp)
movl 0x8(%r13), %edx
xorl $0x1, %edx
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl $0x1, %ecx
leaq 0x60(%rsp), %r8
leaq 0x20(%rsp), %rax
pushq %rax
pushq $0xf
callq 0x19a639
addq $0x10, %rsp
movq %rax, %rdx
cmpl $0x0, 0x20(%rsp)
je 0x19e126
movl 0x68(%rsp), %eax
cmpl 0x84(%rsp), %eax
jne 0x19e126
movl 0x20(%rsp), %r15d
testl %r15d, %r15d
jle 0x19e27a
movl 0x68(%rsp), %eax
cmpl 0x84(%rsp), %eax
movl 0x4(%rsp), %ecx
jne 0x19e299
movq %rbp, %rsi
cmpl $0x3, %r15d
movq %rdx, 0xd0(%rsp)
jl 0x19df7d
addl $-0x2, %r15d
movslq %r14d, %rbx
shlq $0x4, %rbx
orq $0xc, %rbx
leaq (%r15,%r15,2), %rax
incq %r15
leaq (%rdx,%rax,4), %rbp
cmpl %ecx, %r14d
jne 0x19df4f
movl %ecx, %r12d
sarl %r12d
addl %ecx, %r12d
cmpl $0x4, %ecx
movl $0x10, %eax
cmovll %eax, %r12d
movslq %r12d, %rdx
shlq $0x4, %rdx
movq 0x18(%rsp), %rdi
callq 0x1e3800
movq %rax, %rsi
movl %r12d, %ecx
movl $0x0, (%rsi,%rbx)
movq $0x0, -0xc(%rsi,%rbx)
movl (%rbp), %eax
xorl $0x1, %eax
movl %eax, -0x4(%rsi,%rbx)
incl %r14d
addq $0x10, %rbx
decq %r15
addq $-0xc, %rbp
cmpq $0x1, %r15
jg 0x19df1e
movl %ecx, 0x4(%rsp)
movq %rsi, %r15
movq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq 0xd0(%rsp), %rsi
callq 0x1e3632
movl 0x4(%rsp), %eax
cmpl %eax, %r14d
jne 0x19dfcc
movl %eax, %ebx
sarl %ebx
addl %eax, %ebx
cmpl $0x4, %eax
movl $0x10, %eax
cmovll %eax, %ebx
movslq %ebx, %rdx
shlq $0x4, %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1e3800
movq %rax, %r15
movl %ebx, 0x4(%rsp)
movq 0x8(%rsp), %rbp
movslq %r14d, %rbx
incl %r14d
shlq $0x4, %rbx
movl 0x4(%r13), %edx
leal (%rdx,%rdx), %ecx
movq 0xd8(%rsp), %r12
movslq %r12d, %rdi
shlq $0x4, %rdi
addq 0x28(%rbp), %rdi
sarl %ecx
movl %ecx, 0x4(%r15,%rbx)
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%r15,%rbx)
movl 0x1c(%r13), %ecx
movl %ecx, 0xc(%r15,%rbx)
movslq (%r13), %rsi
shlq $0x4, %rsi
addq 0x120(%rsp), %rsi
shlq $0x21, %rdx
sarq $0x21, %rdx
shlq $0x4, %rdx
callq 0x2160
movq %r15, %r11
movl %r12d, (%r15,%rbx)
movl 0x4(%r15,%rbx), %eax
jmp 0x19e108
movl -0x20(%r13), %eax
cmpl 0x8(%r13), %eax
jne 0x19e2b8
addl %ecx, %ecx
sarl %ecx
testl %ecx, %ecx
setg %dl
jle 0x19e23c
movslq %r14d, %rax
shlq $0x4, %rax
addq %r11, %rax
addq $-0x10, %rax
movslq (%r13), %rsi
movl -0x18(%r13), %edi
movl %ecx, %ecx
shlq $0x4, %rsi
addq 0xc0(%rsp), %rsi
xorl %ebx, %ebx
cmpl -0x8(%rsi), %edi
jge 0x19e091
movl -0x10(%r13), %r8d
cmpl (%rsi), %r8d
jl 0x19e0a8
incq %rbx
cmpq %rcx, %rbx
setb %dl
addq $0x10, %rsi
cmpq %rbx, %rcx
jne 0x19e083
jmp 0x19e23c
testb $0x1, %dl
je 0x19e23c
addl 0x4(%rax), %ecx
subl %ebx, %ecx
movl %ecx, 0x4(%rax)
movl 0x1c(%r13), %ecx
addl %ecx, 0xc(%rax)
movslq %r12d, %rdi
shlq $0x4, %rdi
addq 0x28(%rbp), %rdi
movl (%r13), %eax
addl %ebx, %eax
movslq %eax, %rsi
shlq $0x4, %rsi
addq 0x120(%rsp), %rsi
movl 0x4(%r13), %edx
shlq $0x21, %rdx
sarq $0x21, %rdx
subq %rbx, %rdx
shlq $0x4, %rdx
movq %r11, %r15
callq 0x2160
movq %r15, %r11
movl 0x4(%r13), %eax
addl %eax, %eax
sarl %eax
subl %ebx, %eax
addl %eax, %r12d
movq 0xe0(%rsp), %r10
incq %r10
cmpq 0xc8(%rsp), %r10
jne 0x19de1a
jmp 0x19e156
movq 0x58(%rsp), %rax
leaq (%rax,%rbx,8), %rsi
addq $-0x20, %rsi
movq %rdx, %rbx
leaq 0x8(%r13), %rdi
leaq 0x7c(%rsp), %rdx
leaq 0x64(%rsp), %rcx
callq 0x29e38
movq %rbx, %rdx
jmp 0x19ded0
movq 0x8(%rsp), %rbp
movl %r14d, %eax
subl 0x24(%rsp), %eax
movq 0x18(%rbp), %rcx
movq 0x30(%rsp), %rdx
movl %eax, 0xc(%rcx,%rdx,8)
movl %r12d, %eax
subl 0xb0(%rsp), %eax
movl %eax, 0x10(%rcx,%rdx,8)
movl 0x2c(%rsp), %r9d
incl %r9d
movl %r14d, %ebx
movq 0xa8(%rsp), %r13
movq 0xa0(%rsp), %rdi
movq 0xb8(%rsp), %r8
movl 0x28(%rsp), %r10d
movq 0x10(%rsp), %rax
addl %eax, %r10d
incq %r8
cmpq 0x48(%rsp), %r8
jne 0x19db69
jmp 0x19e1c1
xorl %r12d, %r12d
xorl %r14d, %r14d
xorl %r11d, %r11d
cmpl 0x10(%rbp), %r12d
jg 0x19e2d7
movq %r11, %rbx
movl %r12d, 0x10(%rbp)
movl %r14d, 0xc(%rbp)
movslq %r14d, %r13
shlq $0x4, %r13
movq 0x90(%rsp), %rdi
movq %r13, %rsi
callq 0x1e36fd
movq %rax, 0x20(%rbp)
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2160
movq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e3632
movq 0x40(%rsp), %rdi
movq %rbp, %rsi
callq 0x19d3a6
movq %r14, %rdi
movq %rbp, %rsi
callq 0x19d8cb
movq %rbp, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x95c36(%rip), %rdi     # 0x233e79
leaq 0x95741(%rip), %rsi     # 0x23398b
leaq 0x95b2b(%rip), %rcx     # 0x233d7c
movl $0x7fa, %edx            # imm = 0x7FA
callq 0x2110
leaq 0x95b08(%rip), %rdi     # 0x233d6a
leaq 0x95722(%rip), %rsi     # 0x23398b
leaq 0x95b0c(%rip), %rcx     # 0x233d7c
movl $0x7db, %edx            # imm = 0x7DB
callq 0x2110
leaq 0x95bc1(%rip), %rdi     # 0x233e42
leaq 0x95703(%rip), %rsi     # 0x23398b
leaq 0x95aed(%rip), %rcx     # 0x233d7c
movl $0x7e2, %edx            # imm = 0x7E2
callq 0x2110
leaq 0x95bae(%rip), %rdi     # 0x233e4e
leaq 0x956e4(%rip), %rsi     # 0x23398b
leaq 0x95ace(%rip), %rcx     # 0x233d7c
movl $0x7e3, %edx            # imm = 0x7E3
callq 0x2110
leaq 0x95bab(%rip), %rdi     # 0x233e6a
leaq 0x956c5(%rip), %rsi     # 0x23398b
leaq 0x95aaf(%rip), %rcx     # 0x233d7c
movl $0x7f2, %edx            # imm = 0x7F2
callq 0x2110
leaq 0x95ba7(%rip), %rdi     # 0x233e85
leaq 0x956a6(%rip), %rsi     # 0x23398b
leaq 0x95a90(%rip), %rcx     # 0x233d7c
movl $0x80a, %edx            # imm = 0x80A
callq 0x2110