// File: /workspace/github_cpp_makefile_star2_O3/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, %rbp
movq %r8, 0x60(%rsp)
movl %ecx, %r12d
movq %rdx, 0x48(%rsp)
movq %rsi, %r15
movq %rdi, %r13
movl $0x1, %esi
movl $0x40, %edx
callq 0x1edfb4
movq %rax, %r14
testl %r12d, %r12d
jle 0x1a6ed7
movslq 0x138(%rsp), %rax
movq %rax, 0x50(%rsp)
movl %r12d, %eax
movq %rax, 0x58(%rsp)
leaq 0x4(%rbp), %rax
movq %rax, 0x40(%rsp)
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x60(%rsp), %rdi
movq (%rdi,%rdx,8), %rdi
movl $0x0, %r8d
testl %edi, %edi
jle 0x1a6720
movslq %esi, %r8
movl %edi, %r9d
andl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
leaq (%r8,%r8,4), %r8
movq 0x40(%rsp), %r10
leaq (%r10,%r8,8), %r10
xorl %r8d, %r8d
movl (%r10), %r11d
addl %r11d, %r11d
sarl %r11d
addl %r11d, %r8d
addq $0x28, %r10
decq %r9
jne 0x1a670b
cmpl 0x130(%rsp), %r8d
setge %r9b
movq %rdi, %r10
shrq $0x20, %r10
cmpq 0x50(%rsp), %r10
setge %r10b
andb %r9b, %r10b
cmovel %ecx, %r8d
addl %r8d, %ebx
movzbl %r10b, %r8d
addl %r8d, %eax
addl %edi, %esi
incq %rdx
cmpq 0x58(%rsp), %rdx
jne 0x1a66db
testl %eax, %eax
je 0x1a6ed7
movq %r13, (%r14)
movl %eax, 0x8(%r14)
movl %ebx, 0x10(%r14)
movl %eax, %esi
movl $0x48, %edx
movq %r13, %rdi
callq 0x1edfb4
movq %rax, 0x18(%r14)
movslq %ebx, %rsi
shlq $0x4, %rsi
movq %r13, 0x68(%rsp)
movq %r13, %rdi
callq 0x1ee115
movq %rax, 0x28(%r14)
testl %r12d, %r12d
jle 0x1a6e71
movq %rbp, 0x78(%rsp)
leaq 0x10(%rbp), %rax
movq %rax, 0x70(%rsp)
movq 0x120(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x90(%rsp)
pcmpeqd %xmm2, %xmm2
xorl %ecx, %ecx
xorl %r10d, %r10d
movl $0x0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
xorl %r13d, %r13d
movq %r14, 0x18(%rsp)
movq %r15, 0x28(%rsp)
movq 0x60(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq (%rax,%rcx,8), %rcx
movl $0x0, %eax
movq %rcx, 0x10(%rsp)
testl %ecx, %ecx
jle 0x1a6846
movslq 0xc(%rsp), %rax
movq 0x10(%rsp), %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rax,%rax,4), %rax
movq 0x40(%rsp), %rdx
leaq (%rdx,%rax,8), %rdx
xorl %eax, %eax
movl (%rdx), %esi
addl %esi, %esi
sarl %esi
addl %esi, %eax
addq $0x28, %rdx
decq %rcx
jne 0x1a6835
cmpl 0x130(%rsp), %eax
jge 0x1a685e
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
jmp 0x1a6e5d
movq 0x10(%rsp), %rax
movq %rax, %rcx
shrq $0x20, %rcx
cmpq 0x50(%rsp), %rcx
jge 0x1a687b
movq 0x30(%rsp), %rcx
jmp 0x1a6e5d
movq %rax, %rsi
movq 0x18(%r14), %rax
movslq 0x20(%rsp), %rdx
leaq (%rdx,%rdx,8), %r11
movl %ecx, 0x14(%rax,%r11,8)
movl 0x8(%rsp), %ecx
movl %ecx, 0x8(%rax,%r11,8)
movslq 0xc(%rsp), %rbx
movl 0x128(%rsp), %edi
testl %esi, %esi
jle 0x1a6986
movq 0x10(%rsp), %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
leaq (%rbx,%rbx,4), %rdx
movq 0x70(%rsp), %rsi
leaq (%rsi,%rdx,8), %rdx
movl 0x128(%rsp), %esi
movq (%rdx), %xmm0
movdqa %xmm0, %xmm1
pslld $0xf, %xmm1
pxor %xmm2, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
psrld $0xa, %xmm0
pxor %xmm1, %xmm0
movdqa %xmm0, %xmm1
pslld $0x3, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
psrld $0x6, %xmm0
pxor %xmm1, %xmm0
movdqa %xmm0, %xmm1
pslld $0xb, %xmm1
pxor %xmm2, %xmm1
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
psrld $0x10, %xmm0
pxor %xmm1, %xmm0
movl -0x8(%rdx), %edi
movl %edi, %r8d
shll $0xf, %r8d
notl %r8d
addl %edi, %r8d
movl %r8d, %edi
shrl $0xa, %edi
xorl %r8d, %edi
leal (%rdi,%rdi,8), %edi
movl %edi, %r8d
shrl $0x6, %r8d
xorl %edi, %r8d
movl %r8d, %edi
shll $0xb, %edi
notl %edi
addl %r8d, %edi
movl %edi, %r8d
shrl $0x10, %r8d
xorl %edi, %r8d
pshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
movd %xmm1, %r9d
movd %xmm0, %edi
addl %esi, %edi
addl %r9d, %edi
addl %r8d, %edi
addq $0x28, %rdx
movl %edi, %esi
decq %rcx
jne 0x1a68cc
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
movl %edx, 0x38(%rax,%r11,8)
cmpl 0x4(%rsp), %ebp
movq %r11, 0x80(%rsp)
jne 0x1a69ed
movl %ebp, %ecx
sarl %ecx
addl %ebp, %ecx
cmpl $0x4, %ebp
movl $0x10, %eax
cmovll %eax, %ecx
movl %ecx, 0x4(%rsp)
movslq %ecx, %rdx
shlq $0x4, %rdx
movq %r15, %rdi
movq %r10, %rsi
callq 0x1ee21d
movq %rax, %r10
movslq %ebp, %r14
incl %ebp
shlq $0x4, %r14
leaq (%rbx,%rbx,4), %rbx
movq 0x78(%rsp), %r12
movl 0x4(%r12,%rbx,8), %edx
leal (%rdx,%rdx), %eax
movq %r13, 0x88(%rsp)
movslq %r13d, %r15
movq %r15, %rdi
shlq $0x4, %rdi
movq 0x18(%rsp), %rcx
addq 0x28(%rcx), %rdi
sarl %eax
movl %eax, 0x4(%r10,%r14)
movl 0x8(%r12,%rbx,8), %eax
movl %eax, 0x8(%r10,%r14)
movl 0x1c(%r12,%rbx,8), %eax
movl %eax, 0xc(%r10,%r14)
movslq (%r12,%rbx,8), %rsi
shlq $0x4, %rsi
addq 0x120(%rsp), %rsi
shlq $0x21, %rdx
sarq $0x21, %rdx
shlq $0x4, %rdx
movq %r10, %r13
callq 0x2160
movq %r13, %r10
movl %r15d, (%r13,%r14)
addl 0x4(%r13,%r14), %r15d
movq 0x10(%rsp), %rax
cmpl $0x2, %eax
jl 0x1a6e16
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, 0x98(%rsp)
leaq (%r12,%rbx,8), %rax
movq %rax, 0xa0(%rsp)
movl $0x1, %r9d
movq 0x18(%rsp), %r14
leaq (%r9,%r9,4), %rax
movq 0xa0(%rsp), %rcx
leaq (%rcx,%rax,8), %r13
movl 0x4(%r13), %edx
testl %edx, %edx
movq %r9, 0xb0(%rsp)
js 0x1a6cda
movq %r15, 0x38(%rsp)
leaq 0xc8(%rsp), %rax
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
movl -0x20(%r13), %eax
xorl $0x1, %eax
movl %eax, 0xb8(%rsp)
movl 0x20(%r13), %r9d
testl %r9d, %r9d
js 0x1a6f0b
movq %r10, %rbx
movl %r9d, 0xbc(%rsp)
movl 0x24(%r13), %eax
movl %eax, 0xc0(%rsp)
movl $0x40000000, 0xc4(%rsp) # imm = 0x40000000
movl 0x8(%r13), %edx
xorl $0x1, %edx
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movl $0x1, %ecx
leaq 0xb8(%rsp), %r8
leaq 0x24(%rsp), %rax
pushq %rax
pushq $0xf
callq 0x1a32bc
addq $0x10, %rsp
movq %rax, %r14
movl 0x24(%rsp), %r15d
testl %r15d, %r15d
je 0x1a6db1
movl 0xc0(%rsp), %eax
cmpl 0xdc(%rsp), %eax
jne 0x1a6db1
testl %r15d, %r15d
jle 0x1a6f49
movl 0xc0(%rsp), %eax
cmpl 0xdc(%rsp), %eax
movl 0x4(%rsp), %ecx
jne 0x1a6f2a
movq %rbx, %rsi
cmpl $0x3, %r15d
movq %r14, 0xa8(%rsp)
jb 0x1a6c17
addl $-0x2, %r15d
movslq %ebp, %rbx
shlq $0x4, %rbx
orq $0xc, %rbx
leaq (%r15,%r15,2), %rax
incq %r15
leaq (%r14,%rax,4), %r14
cmpl %ecx, %ebp
jne 0x1a6bea
movl %ecx, %r12d
sarl %r12d
addl %ecx, %r12d
cmpl $0x4, %ecx
movl $0x10, %eax
cmovll %eax, %r12d
movslq %r12d, %rdx
shlq $0x4, %rdx
movq 0x28(%rsp), %rdi
callq 0x1ee21d
movq %rax, %rsi
movl %r12d, %ecx
movl $0x0, (%rsi,%rbx)
movq $0x0, -0xc(%rsi,%rbx)
movl (%r14), %eax
xorl $0x1, %eax
movl %eax, -0x4(%rsi,%rbx)
incl %ebp
addq $0x10, %rbx
decq %r15
addq $-0xc, %r14
cmpq $0x1, %r15
jg 0x1a6bba
movl %ecx, 0x4(%rsp)
movq %rsi, %r12
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ee04f
movl 0x4(%rsp), %eax
cmpl %eax, %ebp
jne 0x1a6c65
movl %eax, %ebx
sarl %ebx
addl %eax, %ebx
cmpl $0x4, %eax
movl $0x10, %eax
cmovll %eax, %ebx
movslq %ebx, %rdx
shlq $0x4, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x1ee21d
movq %rax, %r12
movl %ebx, 0x4(%rsp)
movq 0x18(%rsp), %r14
movq 0x38(%rsp), %rsi
movslq %ebp, %rbx
incl %ebp
shlq $0x4, %rbx
movl 0x4(%r13), %edx
leal (%rdx,%rdx), %ecx
movslq %esi, %rdi
shlq $0x4, %rdi
addq 0x28(%r14), %rdi
sarl %ecx
movl %ecx, 0x4(%r12,%rbx)
movl 0x8(%r13), %ecx
movl %ecx, 0x8(%r12,%rbx)
movl 0x1c(%r13), %ecx
movl %ecx, 0xc(%r12,%rbx)
movslq (%r13), %rsi
shlq $0x4, %rsi
addq 0x120(%rsp), %rsi
shlq $0x21, %rdx
sarq $0x21, %rdx
shlq $0x4, %rdx
callq 0x2160
movq 0x38(%rsp), %r15
movq %r12, %r10
movl %r15d, (%r12,%rbx)
movl 0x4(%r12,%rbx), %eax
jmp 0x1a6d8f
movl -0x20(%r13), %eax
cmpl 0x8(%r13), %eax
jne 0x1a6f68
addl %edx, %edx
sarl %edx
testl %edx, %edx
jle 0x1a6eec
movslq %ebp, %rax
shlq $0x4, %rax
leaq (%rax,%r10), %rcx
addq $-0x10, %rcx
movslq (%r13), %rsi
movl %esi, %eax
movl -0x18(%r13), %edi
movl %edx, %edx
shlq $0x4, %rsi
addq 0x90(%rsp), %rsi
xorl %ebx, %ebx
cmpl -0x8(%rsi), %edi
jge 0x1a6d2b
movl -0x10(%r13), %r8d
cmpl (%rsi), %r8d
jl 0x1a6d3c
incq %rbx
addq $0x10, %rsi
cmpq %rbx, %rdx
jne 0x1a6d1d
jmp 0x1a6eec
addl 0x4(%rcx), %edx
subl %ebx, %edx
movl %edx, 0x4(%rcx)
movl 0x1c(%r13), %edx
addl %edx, 0xc(%rcx)
movslq %r15d, %rdi
shlq $0x4, %rdi
addq 0x28(%r14), %rdi
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 %r10, %r12
callq 0x2160
movq %r12, %r10
movl 0x4(%r13), %eax
addl %eax, %eax
sarl %eax
subl %ebx, %eax
addl %eax, %r15d
movq 0xb0(%rsp), %r9
incq %r9
cmpq 0x98(%rsp), %r9
pcmpeqd %xmm2, %xmm2
jne 0x1a6aa0
jmp 0x1a6e1f
movq 0xee228(%rip), %rax     # 0x294fe0
movq (%rax), %rdi
movl -0x20(%r13), %r9d
movl 0x8(%r13), %ecx
xorq $0x1, %rcx
movl %ecx, %eax
andl $0x1, %eax
leaq 0x9933c(%rip), %rsi     # 0x24010f
movsbl (%rax,%rsi), %edx
xorq $0x1, %r9
movl %r9d, %eax
andl $0x1, %eax
movsbl (%rax,%rsi), %r8d
movl 0xbc(%rsp), %r10d
movl 0xd4(%rsp), %r11d
leaq 0x992e7(%rip), %rsi     # 0x2400e4
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x22b0
addq $0x10, %rsp
movl 0x24(%rsp), %r15d
jmp 0x1a6b6e
movq 0x18(%rsp), %r14
pcmpeqd %xmm2, %xmm2
movl %ebp, %eax
subl 0x8(%rsp), %eax
movq 0x18(%r14), %rcx
movq 0x80(%rsp), %rdx
movl %eax, 0xc(%rcx,%rdx,8)
movl %r15d, %eax
subl 0x88(%rsp), %eax
movl %eax, 0x10(%rcx,%rdx,8)
incl 0x20(%rsp)
movl %r15d, %r13d
movl %ebp, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %r15
addl %eax, 0xc(%rsp)
incq %rcx
cmpq 0x58(%rsp), %rcx
jne 0x1a67fa
jmp 0x1a6e79
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r10d, %r10d
cmpl 0x10(%r14), %r13d
jg 0x1a6f87
movq %r10, %rbx
movl %r13d, 0x10(%r14)
movl %ebp, 0xc(%r14)
movslq %ebp, %r13
shlq $0x4, %r13
movq 0x68(%rsp), %rdi
movq %r13, %rsi
callq 0x1ee115
movq %rax, 0x20(%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2160
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1ee04f
movq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x1a601d
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a655a
movq %r14, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x99256(%rip), %rdi     # 0x240149
leaq 0x98d61(%rip), %rsi     # 0x23fc5b
leaq 0x9914b(%rip), %rcx     # 0x24004c
movl $0x7fa, %edx            # imm = 0x7FA
callq 0x2110
leaq 0x99128(%rip), %rdi     # 0x24003a
leaq 0x98d42(%rip), %rsi     # 0x23fc5b
leaq 0x9912c(%rip), %rcx     # 0x24004c
movl $0x7db, %edx            # imm = 0x7DB
callq 0x2110
leaq 0x991ed(%rip), %rdi     # 0x24011e
leaq 0x98d23(%rip), %rsi     # 0x23fc5b
leaq 0x9910d(%rip), %rcx     # 0x24004c
movl $0x7e3, %edx            # imm = 0x7E3
callq 0x2110
leaq 0x991c2(%rip), %rdi     # 0x240112
leaq 0x98d04(%rip), %rsi     # 0x23fc5b
leaq 0x990ee(%rip), %rcx     # 0x24004c
movl $0x7e2, %edx            # imm = 0x7E2
callq 0x2110
leaq 0x991cb(%rip), %rdi     # 0x24013a
leaq 0x98ce5(%rip), %rsi     # 0x23fc5b
leaq 0x990cf(%rip), %rcx     # 0x24004c
movl $0x7f2, %edx            # imm = 0x7F2
callq 0x2110
leaq 0x991c7(%rip), %rdi     # 0x240155
leaq 0x98cc6(%rip), %rsi     # 0x23fc5b
leaq 0x990b0(%rip), %rcx     # 0x24004c
movl $0x80a, %edx            # imm = 0x80A
callq 0x2110