LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_add_buf
int _tt_int_add_buf(_tt_word *int1, int msb1, const _tt_word *int2, int msb2)
{
	int i, carry = 0;

	for (i = 0; i < msb2; i++)
		int1[i] = add_int(int1[i], int2[i], &carry);
	for (; i < msb1; i++) {
		if (carry == 0)
			return msb1;
		int1[i]++;
		carry = !int1[i];
	}
	if (carry)
		int1[i++] = 1;

	return i;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x8844
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xc(%rsp), %rdx
callq 0x88e0
movq %rax, %rdx
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x87f6
jmp 0x8846
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x88a1
cmpl $0x0, 0xc(%rsp)
jne 0x8861
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x88cd
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x8846
cmpl $0x0, 0xc(%rsp)
je 0x88c5
movq 0x28(%rsp), %rax
movl 0x10(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x10(%rsp)
movslq %ecx, %rcx
movq $0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_sub_buf
int _tt_int_sub_buf(_tt_word *int1, int msb1, const _tt_word *int2, int msb2)
{
	int i, borrow = 0;

	for (i = 0; i < msb2; i++)
		int1[i] = sub_int(int1[i], int2[i], &borrow);
	for (; i < msb1; i++) {
		if (borrow == 0)
			return msb1;
		borrow = !int1[i];
		int1[i]--;
	}
	while (i > 1 && int1[i-1] == 0)
		i--;

	return i;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x89b4
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xc(%rsp), %rdx
callq 0x8a70
movq %rax, %rdx
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x8966
jmp 0x89b6
movl 0x10(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x8a14
cmpl $0x0, 0xc(%rsp)
jne 0x89d4
movl 0x24(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x8a5d
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x89b6
jmp 0x8a16
xorl %eax, %eax
cmpl $0x1, 0x10(%rsp)
movb %al, 0xb(%rsp)
jle 0x8a3e
movq 0x28(%rsp), %rax
movl 0x10(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
sete %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x8a48
jmp 0x8a55
movl 0x10(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x8a16
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_cmp_buf
int _tt_int_cmp_buf(const _tt_word *int1, int msb1,
		const _tt_word *int2, int msb2)
{
	if (msb1 > msb2)
		return 1;
	else if (msb1 < msb2)
		return -1;

	for (int i = msb1-1; i >= 0; i--) {
		if (int1[i] > int2[i])
			return 1;
		else if (int1[i] < int2[i])
			return -1;
	}

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x24(%rsp), %eax
jle 0x8af9
movl $0x1, -0x4(%rsp)
jmp 0x8b8a
movl -0x14(%rsp), %eax
cmpl -0x24(%rsp), %eax
jge 0x8b0d
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x8b8a
jmp 0x8b0f
movl -0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rsp)
cmpl $0x0, -0x28(%rsp)
jl 0x8b82
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
movslq -0x28(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jbe 0x8b49
movl $0x1, -0x4(%rsp)
jmp 0x8b8a
movq -0x10(%rsp), %rax
movslq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rsp), %rcx
movslq -0x28(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x8b71
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x8b8a
jmp 0x8b73
jmp 0x8b75
movl -0x28(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rsp)
jmp 0x8b1a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_get_msb
int _tt_int_get_msb(const _tt_word *ui, int len)
{
	while (len) {
		if (ui[len-1])
			return len;
		len--;
	}
	return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0x8bcd
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x8bc0
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x8bd5
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x8b99
movl $0x1, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_mul_buf
int _tt_int_mul_buf(_tt_word *intr, const _tt_word *int1, int msb1,
		const _tt_word *int2, int msb2)
{
	/* mul_buf_xxx cannot treat 0 correctly */
	if ((msb1 == 1 && int1[0] == 0) || (msb2 == 1 && int2[0] == 0))
		return 1;

	int msbmin, msbmax;
	if (msb1 > msb2) {
		msbmax = msb1;
		msbmin = msb2;
	} else {
		msbmax = msb2;
		msbmin = msb1;
	}

	/* Use classic algorithm when input size below crosspoint */
	if (msbmin < KARA_CROSS)
		return mul_buf_classic(intr, int1, msb1, int2, msb2);

	/* Allocate working buffer for Karatsuba algorithm */
	/* recursive calls = (int)(log2(msbmax) - log2(KARA_CROSS)) + 2; */
	const int recurse = 33 - __builtin_clz((msbmax / KARA_CROSS) + 1);
	const int worksz = msbmax * 4 + recurse * (recurse + 9);
	void *workbuf = malloc(worksz * _tt_word_sz);
	if (workbuf == NULL)
		return TT_ENOMEM;

	int ret = mul_buf_kara(intr, int1, msb1, int2, msb2, workbuf);

	free(workbuf);
	return ret;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
cmpl $0x1, 0x3c(%rsp)
jne 0x8c0e
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x8c20
cmpl $0x1, 0x2c(%rsp)
jne 0x8c2d
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x8c2d
movl $0x1, 0x54(%rsp)
jmp 0x8d1f
movl 0x3c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jle 0x8c49
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
jmp 0x8c59
movl 0x2c(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x28(%rsp)
cmpl $0x10, 0x28(%rsp)
jge 0x8c86
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
callq 0x8d30
movl %eax, 0x54(%rsp)
jmp 0x8d1f
movl 0x24(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
addl $0x1, %eax
bsrl %eax, %ecx
xorl $0x1f, %ecx
movl $0x21, %eax
subl %ecx, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
shll $0x2, %eax
movl 0x20(%rsp), %ecx
movl 0x20(%rsp), %edx
addl $0x9, %edx
imull %edx, %ecx
addl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
shll $0x3, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8ce7
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x8d1f
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movl 0x2c(%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x90c0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1030
movl 0xc(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: add_sub_ints
static int add_sub_ints(struct tt_int *dst, const struct tt_int *src1,
		const struct tt_int *src2, int sub)
{
	int ret = 0;

	/* Zero dst if not overlap with src1 and src2 */
	if (dst != src1 && dst != src2)
		_tt_int_zero(dst);

	int sign1 = src1->sign;
	int sign2 = src2->sign;
	if (sub)
		sign2 = !sign2;

	if (sign1 == sign2) {
		dst->sign = sign1;
		ret = add_ints_abs(dst, src1, src2);
	} else {
		int cmp12 = tt_int_cmp_abs(src1, src2);
		if (cmp12 >= 0) {
			dst->sign = sign1;
			ret = sub_ints_abs(dst, src1, src2);
		} else {
			dst->sign = sign2;
			ret = sub_ints_abs(dst, src2, src1);
		}
	}

	return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0xa7c1
movq 0x30(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0xa7c1
movq 0x30(%rsp), %rdi
callq 0x6a60
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0xa7f1
cmpl $0x0, 0x10(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0xa820
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb490
movl %eax, 0x18(%rsp)
jmp 0xa884
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xafe0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jl 0xa85f
movl 0x14(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb6a0
movl %eax, 0x18(%rsp)
jmp 0xa882
movl 0x10(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xb6a0
movl %eax, 0x18(%rsp)
jmp 0xa884
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_mul
int tt_int_mul(struct tt_int *dst, const struct tt_int *src1,
		const struct tt_int *src2)
{
	if (_tt_int_is_zero(src1) || _tt_int_is_zero(src2)) {
		_tt_int_zero(dst);
		return 0;
	}

	/* Allocate result buffer */
	_tt_word *r = calloc(src1->msb + src2->msb, _tt_word_sz);
	if (!r)
		return TT_ENOMEM;

	const int sign = src1->sign ^ src2->sign;
	int msb = _tt_int_mul_buf(r, src1->buf, src1->msb,
			src2->buf, src2->msb);
	/* TODO: drop memcpy by replacing dst->buf with r directly */
	if (dst->_max < msb) {
		int ret = _tt_int_realloc(dst, msb);
		if (ret)
			return ret;
	}
	memcpy(dst->buf, r, msb*_tt_word_sz);
	memset(dst->buf + msb, 0, (dst->_max - msb)*_tt_word_sz);
	dst->msb = msb;
	dst->sign = sign;

	free(r);
	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xaa40
testb $0x1, %al
jne 0xa8f1
movq 0x18(%rsp), %rdi
callq 0xaa40
testb $0x1, %al
jne 0xa8f1
jmp 0xa908
movq 0x28(%rsp), %rdi
callq 0x6a60
movl $0x0, 0x34(%rsp)
jmp 0xaa29
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
addl 0x8(%rcx), %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x1110
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xa93f
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xaa29
movq 0x20(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
xorl (%rcx), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movl 0x8(%rax), %r8d
callq 0x8be0
movl %eax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x8(%rsp), %eax
jge 0xa9b5
movq 0x28(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x68d0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xa9b3
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xaa29
jmp 0xa9b5
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %eax
shll $0x3, %eax
movslq %eax, %rdx
callq 0x1140
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
subl 0x8(%rsp), %eax
shll $0x3, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x10e0
movl 0x8(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x1030
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: tt_int_cmp
int tt_int_cmp(const struct tt_int *src1, const struct tt_int *src2)
{
	int ret;

	if (src1->sign != src2->sign) {
		if (_tt_int_is_zero(src1) && _tt_int_is_zero(src2))
			return 0;
		ret = src2->sign - src1->sign;
	} else {
		ret = tt_int_cmp_abs(src1, src2);
		if (src1->sign)
			ret = -ret;
	}

	return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0xb07c
movq 0x18(%rsp), %rdi
callq 0xaa40
testb $0x1, %al
jne 0xb04e
jmp 0xb068
movq 0x10(%rsp), %rdi
callq 0xaa40
testb $0x1, %al
jne 0xb05e
jmp 0xb068
movl $0x0, 0x24(%rsp)
jmp 0xb0ad
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
subl (%rcx), %eax
movl %eax, 0xc(%rsp)
jmp 0xb0a5
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xafe0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
je 0xb0a3
xorl %eax, %eax
subl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xb0a5
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: get_words
static int get_words(const _tt_word *ui, int len)
{
	while (len) {
		if (ui[len-1])
			return len;
		len--;
	}
	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0xb31d
movq -0x10(%rsp), %rax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb310
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0xb325
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xb2e9
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/basic.c
// Function: guess_quotient
static _tt_word guess_quotient(const _tt_word *src1, int msb1,
		const _tt_word *src2, int msb2)
{
	if (_tt_int_cmp_buf(src1, msb1, src2, msb2) < 0)
		return 0;
	else if (msb1 == msb2)
		return 1;

	_tt_word_double dividend = src1[msb1-1];
	dividend <<= _tt_word_bits;
	dividend |= src1[msb1-2];

	_tt_word q = (_tt_word)(dividend / src2[msb2-1]);
	tt_assert_fa(q <= _tt_word_top_bit);
	return q;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x8ad0
cmpl $0x0, %eax
jge 0xb370
movq $0x0, 0x40(%rsp)
jmp 0xb478
movl 0x34(%rsp), %eax
cmpl 0x24(%rsp), %eax
jne 0xb388
movq $0x1, 0x40(%rsp)
jmp 0xb478
jmp 0xb38a
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
decl %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rdx, %rax
shlq $0x3f, %rax
shldq $0x3f, %rdx, %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %ecx
addl $-0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
orq %rdx, %rax
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
decl %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x11a80
movq %rax, 0x8(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, 0x8(%rsp)
setbe %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xb46c
xorl %edi, %edi
leaq 0x13490(%rip), %rsi     # 0x1e8dc
leaq 0x6c8b(%rip), %rdx      # 0x120de
leaq 0x1343a(%rip), %rcx     # 0x1e894
movl $0x22c, %r8d            # imm = 0x22C
movb $0x0, %al
callq 0xe010
callq 0x1060
jmp 0xb46e
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/gcd.c
// Function: tt_int_gcd
int tt_int_gcd(struct tt_int *g, const struct tt_int *a, const struct tt_int *b)
{
	if (_tt_int_is_zero(a))
		return copy_abs(g, b);
	else if (_tt_int_is_zero(b))
		return copy_abs(g, a);

	/* Copy int buffer */
	void *buf = malloc((a->msb+b->msb)*_tt_word_sz);
	if (!buf)
		return TT_ENOMEM;
	_tt_word *_a = buf;
	_tt_word *_b = _a + a->msb;
	memcpy(_a, a->buf, a->msb*_tt_word_sz);
	memcpy(_b, b->buf, b->msb*_tt_word_sz);

	int ret = gcd_binary(g, _a, a->msb, _b, b->msb);

	free(buf);
	return ret;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xbe70
testb $0x1, %al
jne 0xbd43
jmp 0xbd5b
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xbeb0
movl %eax, 0x44(%rsp)
jmp 0xbe5b
movq 0x28(%rsp), %rdi
callq 0xbe70
testb $0x1, %al
jne 0xbd6b
jmp 0xbd83
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xbeb0
movl %eax, 0x44(%rsp)
jmp 0xbe5b
jmp 0xbd85
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x28(%rsp), %rcx
addl 0x8(%rcx), %eax
shll $0x3, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xbdba
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xbe5b
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
shll $0x3, %eax
movslq %eax, %rdx
callq 0x1140
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
shll $0x3, %eax
movslq %eax, %rdx
callq 0x1140
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %r8d
callq 0xbf00
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1030
movl 0xc(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/gcd.c
// Function: copy_abs
static int copy_abs(struct tt_int *dst, const struct tt_int *src)
{
	if (!dst)
		return 0;

	int ret = _tt_int_copy(dst, src);
	dst->sign = 0;

	return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xbed0
movl $0x0, 0x24(%rsp)
jmp 0xbef6
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x69c0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/gcd.c
// Function: gcd_naive
static _tt_word gcd_naive(_tt_word a, _tt_word b)
{
	while (b) {
		_tt_word r = a % b;
		a = b;
		b = r;
	}

	return a;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xca7b
movq -0x8(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0xca4a
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/gcd.c
// Function: to_odd
static _tt_word *to_odd(_tt_word *a, int *msb, uint *shift)
{
	*shift = 0;

	while (*a == 0) {
		a++;
		(*msb)--;
		(*shift) += _tt_word_bits;
	}

	int zc = _tt_int_word_ctz(*a);
	if (zc) {
		*msb = _tt_int_shift_buf(a, *msb, -zc);
		(*shift) += zc;
	}

	return a;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xcae1
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x3f, %ecx
movl %ecx, (%rax)
jmp 0xcaae
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x6b10
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0xcb26
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
xorl %edx, %edx
subl 0xc(%rsp), %edx
callq 0x6d10
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/gcd.c
// Function: _ctz
static uint __ctz(const _tt_word *a)
{
	uint z = 0;

	while (*a == 0) {
		a++;
		z += _tt_word_bits;
	}

	return z + _tt_int_word_ctz(*a);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xcb67
movq 0x10(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x3f, %eax
movl %eax, 0xc(%rsp)
jmp 0xcb41
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x6b10
movl %eax, %ecx
movl 0x8(%rsp), %eax
addl %ecx, %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/mod.c
// Function: tt_int_mod_inv
int tt_int_mod_inv(struct tt_int *m,
		const struct tt_int *a, const struct tt_int *b)
{
	struct tt_int *n = tt_int_alloc();

	int ret = tt_int_extgcd(NULL, m, n, a, b);
	tt_int_free(n);

	return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x6800
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
xorl %eax, %eax
movl %eax, %edi
callq 0xc140
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rdi
callq 0x68b0
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: tt_int_isprime_buf
bool _tt_int_isprime_buf(const _tt_word *ui, int msb)
{
	if (msb == 1 && ui[0] < BIT(31))
		return isprime_naive(ui[0]);

	if ((ui[0] & 0x1) == 0)
		return false;

	if (!maybe_prime(ui, msb))
		return false;

	int bits = (msb - 1) * _tt_word_bits;
	bits += _tt_int_word_bits(ui[msb-1]);
	return isprime_miller_rabin(ui, msb, ml_rounds(bits));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jne 0xcf3d
movq 0x18(%rsp), %rax
movl $0x80000000, %ecx       # imm = 0x80000000
cmpq %rcx, (%rax)
jae 0xcf3d
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl %eax, %edi
callq 0xcfe0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xcfcc
movq 0x18(%rsp), %rax
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xcf56
movb $0x0, 0x27(%rsp)
jmp 0xcfcc
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xd080
testb $0x1, %al
jne 0xcf6f
movb $0x0, 0x27(%rsp)
jmp 0xcfcc
movl 0x14(%rsp), %eax
subl $0x1, %eax
imull $0x3f, %eax, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6aa0
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %edi
callq 0xd560
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl %eax, %edx
callq 0xd100
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: isprime_naive
static bool isprime_naive(uint p)
{
	if (p == 2 || p == 3)
		return true;
	if (p < 2 || p % 2 == 0 || p % 3 == 0)
		return false;

	uint i = 5;
	while (i*i <= p) {
		if (p % i == 0 || p % (i+2) == 0)
			return false;
		i += 6;
	}

	return true;
}

// Assembly:
movl %edi, -0x8(%rsp)
cmpl $0x2, -0x8(%rsp)
je 0xcff2
cmpl $0x3, -0x8(%rsp)
jne 0xcff9
movb $0x1, -0x1(%rsp)
jmp 0xd078
cmpl $0x2, -0x8(%rsp)
jb 0xd01e
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd01e
movl -0x8(%rsp), %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0xd025
movb $0x0, -0x1(%rsp)
jmp 0xd078
movl $0x5, -0xc(%rsp)
movl -0xc(%rsp), %eax
imull -0xc(%rsp), %eax
cmpl -0x8(%rsp), %eax
ja 0xd073
movl -0x8(%rsp), %eax
xorl %edx, %edx
divl -0xc(%rsp)
cmpl $0x0, %edx
je 0xd05f
movl -0x8(%rsp), %eax
movl -0xc(%rsp), %ecx
addl $0x2, %ecx
xorl %edx, %edx
divl %ecx
cmpl $0x0, %edx
jne 0xd066
movb $0x0, -0x1(%rsp)
jmp 0xd078
movl -0xc(%rsp), %eax
addl $0x6, %eax
movl %eax, -0xc(%rsp)
jmp 0xd02d
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: maybe_prime
static bool maybe_prime(const _tt_word *ui, int msb)
{
	for (int i = 1; i < PRIMES_COUNT; i++) {
		if (divisable(ui, msb, _primes[i], _inverse[i]))
			return false;
	}
	return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl $0x1, (%rsp)
cmpl $0x76c, (%rsp)          # imm = 0x76C
jge 0xd0e3
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
movslq (%rsp), %rcx
leaq 0xcaef(%rip), %rax      # 0x19ba0
movzwl (%rax,%rcx,2), %edx
movslq (%rsp), %rcx
leaq 0xd9c0(%rip), %rax      # 0x1aa80
movq (%rax,%rcx,8), %rcx
callq 0xd5e0
testb $0x1, %al
jne 0xd0cf
jmp 0xd0d6
movb $0x0, 0x17(%rsp)
jmp 0xd0e8
jmp 0xd0d8
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xd094
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: ml_rounds
static int ml_rounds(int bits)
{
	static const struct {
		int bits;
		int rounds;
	} b2r[] = {
		{ 1300, 2 }, { 850, 3 }, { 650, 4 }, { 550, 5 }, { 450, 6 },
		{ 400, 7 }, { 350, 8 }, { 300, 9 }, { 250, 12 }, { 200, 15 },
		{ 150, 18 }, { 0, 27 },
	};

	for (int i = 0; i < ARRAY_SIZE(b2r); i++) {
		if (bits >= b2r[i].bits)
			return b2r[i].rounds;
	}
	return b2r[0].rounds;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movslq -0xc(%rsp), %rax
cmpq $0xc, %rax
jae 0xd5b1
movl -0x8(%rsp), %eax
movslq -0xc(%rsp), %rdx
leaq 0x11059(%rip), %rcx     # 0x1e5e0
cmpl (%rcx,%rdx,8), %eax
jl 0xd5a2
movslq -0xc(%rsp), %rcx
leaq 0x11048(%rip), %rax     # 0x1e5e0
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x4(%rsp)
jmp 0xd5b9
jmp 0xd5a4
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xd56c
movl $0x2, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: divisable
static bool divisable(const _tt_word *ui, int msb, uint prime, _tt_word inverse)
{
	_tt_word x, q;
	uint b = 0;

	for (int i = 0; i < msb; i++) {
		if (b <= ui[i]) {
			x = ui[i] - b;
			b = 0;
		} else {
			x = ~(b - ui[i]) + 1;
			x &= ~_tt_word_top_bit;
			b = 1;
		}

		q = inverse * x;
		q &= ~_tt_word_top_bit;

		b += ((_tt_word_double)q * prime - x) >> _tt_word_bits;
	}
	return b == 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl $0x0, -0x30(%rsp)
movl -0x30(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0xd6df
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0x30(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
ja 0xd648
movq -0x8(%rsp), %rax
movslq -0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rsp), %ecx
subq %rcx, %rax
movq %rax, -0x20(%rsp)
movl $0x0, -0x2c(%rsp)
jmp 0xd683
movl -0x2c(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0x30(%rsp), %rdx
subq (%rcx,%rdx,8), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl $0x1, -0x2c(%rsp)
movq -0x18(%rsp), %rax
movq -0x20(%rsp), %rcx
imulq %rcx, %rax
movq %rax, -0x28(%rsp)
movb -0x21(%rsp), %al
andb $0x7f, %al
movb %al, -0x21(%rsp)
movq -0x28(%rsp), %rax
movl -0x10(%rsp), %ecx
mulq %rcx
movq -0x20(%rsp), %rcx
subq %rcx, %rax
sbbq $0x0, %rdx
movl %edx, %ecx
shrq $0x3f, %rax
movl %eax, %edx
movl %edx, %eax
leal (%rax,%rcx,2), %ecx
movl -0x2c(%rsp), %eax
addl %ecx, %eax
movl %eax, -0x2c(%rsp)
movl -0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rsp)
jmp 0xd602
cmpl $0x0, -0x2c(%rsp)
sete %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/src/apn/integer/prime.c
// Function: pick_rand
static int pick_rand(_tt_word *r, const _tt_word *n, int msbn)
{
	int msbr;

	/* r -> [0, 2n-1] */
	for (int i = 0; i < msbn; i++) {
		r[i] = _tt_rand() & ~BIT(31);
#ifdef _TT_LP64_
		r[i] <<= 32;
		r[i] |= _tt_rand();
#endif
	}
	const _tt_word mask = (1ULL << _tt_int_word_bits(n[msbn-1])) - 1;
	r[msbn-1] &= mask;
	msbr = _tt_int_get_msb(r, msbn);

	/* r -> [0, n-1] */
	if (_tt_int_cmp_buf(r, msbr, n, msbn) >= 0)
		msbr = _tt_int_sub_buf(r, msbr, n, msbn);

	/* r -> [3, n-1] */
	while (msbr == 1 && r[0] < 3)
		r[0] = _tt_rand() & ~BIT(31);

	/* r -> [2, n-2] */
	const _tt_word one = 1;
	msbr = _tt_int_sub_buf(r, msbr, &one, 1);

	return msbr;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xd76e
callq 0xeb40
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %edx
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
shlq $0x20, %rdx
movq %rdx, (%rax,%rcx,8)
callq 0xeb40
movl %eax, %eax
movl %eax, %edx
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xd70a
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6aa0
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rax
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
andq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x8b90
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x8ad0
cmpl $0x0, %eax
jl 0xd800
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x8940
movl %eax, 0x20(%rsp)
jmp 0xd802
xorl %eax, %eax
cmpl $0x1, 0x20(%rsp)
movb %al, 0x7(%rsp)
jne 0xd81f
movq 0x30(%rsp), %rax
cmpq $0x3, (%rax)
setb %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xd829
jmp 0xd841
callq 0xeb40
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
movl %eax, %ecx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
jmp 0xd802
movq $0x1, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
leaq 0x8(%rsp), %rdx
movl $0x1, %ecx
callq 0x8940
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/debug.c
// Function: ir_debug_fmt
void ir_debug_fmt(const char *fmt, struct ir_stmt *stmt)
{
	struct ir_operand *cop[3] =
	    { stmt->result, stmt->arg1, stmt->arg2 };
	int len = strlen(fmt);
	if (stmt->type != stmt_label) printf("\t");
	for (int i = 0; i < len; i++) {
		if (fmt[i] == '$' && (i + 1) < len) {
			char c = fmt[i + 1];
			if (c >= '0' && c < '3')
				ir_operand_debug(cop[fmt[i + 1] - '0']);
			else if (c == 'l') printf("%d", stmt->label);
			i++;
		} else if (fmt[i] == '@' && (i + 1) < len) {
			char c = fmt[i + 1];
			if (c >= '0' && c < '3')
				ir_operand_size_debug(cop[fmt[i + 1] - '0']);
			i++;
		} else {
			printf("%c", fmt[i]);
		}
 	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2050
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
je 0x2607
leaq 0x9b9d(%rip), %rdi      # 0xc19d
movb $0x0, %al
callq 0x2060
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x2747
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0x26af
movl -0x38(%rbp), %eax
addl $0x1, %eax
cmpl -0x34(%rbp), %eax
jge 0x26af
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rbp)
movsbl -0x39(%rbp), %eax
cmpl $0x30, %eax
jl 0x2681
movsbl -0x39(%rbp), %eax
cmpl $0x33, %eax
jge 0x2681
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cltq
movq -0x30(%rbp,%rax,8), %rdi
callq 0x2750
jmp 0x26a1
movsbl -0x39(%rbp), %eax
cmpl $0x6c, %eax
jne 0x269f
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
leaq 0x9b0b(%rip), %rdi      # 0xc1a3
movb $0x0, %al
callq 0x2060
jmp 0x26a1
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2737
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x40, %eax
jne 0x271b
movl -0x38(%rbp), %eax
addl $0x1, %eax
cmpl -0x34(%rbp), %eax
jge 0x271b
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x3a(%rbp)
movsbl -0x3a(%rbp), %eax
cmpl $0x30, %eax
jl 0x2710
movsbl -0x3a(%rbp), %eax
cmpl $0x33, %eax
jge 0x2710
movq -0x8(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cltq
movq -0x30(%rbp,%rax,8), %rdi
callq 0x2820
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2735
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %esi
leaq 0x9a71(%rip), %rdi      # 0xc19f
movb $0x0, %al
callq 0x2060
jmp 0x2737
jmp 0x2739
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x260e
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/debug.c
// Function: ir_operand_debug
void ir_operand_debug(struct ir_operand *oper)
{
	if (!oper) return;
	switch (oper->type) {
		case oper_reg: printf("R%d", oper->val.virt_reg); 	break;
		case oper_sym:
			if (!oper->val.sym) break;
			if (oper->val.sym->offset)
				printf("fp-%ld", oper->val.sym->offset);
			else printf("_%s", oper->val.sym->identifier);
			break;
		case oper_cnum: printf("#%ld", oper->val.constant); 	break;
		default: break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2768
jmp 0x2811
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x278e
jmp 0x2777
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x27a5
jmp 0x2781
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x27f7
jmp 0x280f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
leaq 0x9a06(%rip), %rdi      # 0xc1a2
movb $0x0, %al
callq 0x2060
jmp 0x2811
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x27b2
jmp 0x2811
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
je 0x27db
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rsi
leaq 0x99d4(%rip), %rdi      # 0xc1a6
movb $0x0, %al
callq 0x2060
jmp 0x27f5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x99bf(%rip), %rdi      # 0xc1ad
movb $0x0, %al
callq 0x2060
jmp 0x2811
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x99ab(%rip), %rdi      # 0xc1b1
movb $0x0, %al
callq 0x2060
jmp 0x2811
jmp 0x2811
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/debug.c
// Function: ir_operand_size_debug
void ir_operand_size_debug(struct ir_operand *oper)
{
	if (!oper) return;
	/*print size*/
	if (oper->size==0)
		printf("n");
	else if (oper->size==1)
		printf("b");
	else if (oper->size==2)
		printf("w");
	else if (oper->size==4)
		printf("dw");
	else if (oper->size==8)
		printf("qw");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2838
jmp 0x28c0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2852
leaq 0xa1ab(%rip), %rdi      # 0xc9f4
movb $0x0, %al
callq 0x2060
jmp 0x28c0
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x286c
leaq 0x9953(%rip), %rdi      # 0xc1b6
movb $0x0, %al
callq 0x2060
jmp 0x28be
movq -0x8(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x2886
leaq 0x993c(%rip), %rdi      # 0xc1b9
movb $0x0, %al
callq 0x2060
jmp 0x28bc
movq -0x8(%rbp), %rax
cmpl $0x4, 0x4(%rax)
jne 0x28a0
leaq 0x9921(%rip), %rdi      # 0xc1b8
movb $0x0, %al
callq 0x2060
jmp 0x28ba
movq -0x8(%rbp), %rax
cmpl $0x8, 0x4(%rax)
jne 0x28b8
leaq 0x990a(%rip), %rdi      # 0xc1bb
movb $0x0, %al
callq 0x2060
jmp 0x28ba
jmp 0x28bc
jmp 0x28be
jmp 0x28c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/debug.c
// Function: ir_debug
void ir_debug(struct ir_stmt *head)
{
	struct ir_stmt *stmt = head;
	int ln = 0;
	while (stmt) {
		printf("%2d: ", ++ln);
		ir_stmt_debug(stmt);
		printf("\n");
		stmt = stmt->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x292e
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
leaq 0x985e(%rip), %rdi      # 0xc160
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rdi
callq 0x2570
leaq 0x9ad6(%rip), %rdi      # 0xc3ef
movb $0x0, %al
callq 0x2060
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x28eb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/debug.c
// Function: symbol_table_debug
void symbol_table_debug(struct symbol_table *scope)
{
	if (!scope)
		return;
	for (int i = 0; i < scope->num_syms; i++) {
		printf("%s: ", scope->syms[i]->identifier);
		print_type(scope->syms[i]->type);
		if ((i + 1) < scope->num_syms)
			printf(", ");
		else
			printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2958
jmp 0x29e3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x29e3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rsi
leaq 0x9893(%rip), %rdi      # 0xc219
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdi
callq 0xb460
movl -0xc(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x29c5
leaq 0x9802(%rip), %rdi      # 0xc1be
movb $0x0, %al
callq 0x2060
jmp 0x29d3
leaq 0x9a23(%rip), %rdi      # 0xc3ef
movb $0x0, %al
callq 0x2060
jmp 0x29d5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x295f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: bb_init
struct bb *bb_init(struct ir_stmt *s, struct ir_stmt **next)
{
	struct bb *blk = malloc(sizeof(struct bb));

	blk->succ = NULL, blk->pred = NULL;
	blk->nsucc = 0, blk->npred = 0;

	blk->use = NULL, blk->def = NULL;
	blk->nuse = 0, blk->ndef = 0;

	blk->graph = NULL;
	blk->nvert = 0;

	blk->in = NULL, blk->out = NULL;
	blk->nin = 0, blk->nout = 0;
	blk->visited = 0;

	blk->blk = s;
	int len = 1;
	/*Basic blocks can start at labels but must end at a jump or any label not at the start*/
	while (s) {
		if (s->type == stmt_cgoto || s->type == stmt_ugoto) {
			break;
		}
		if (s->type == stmt_label && len != 1) {
			/*Do not include this*/
			s = s->prev;
			len--;
			break;
		}
		len++;
		s = s->next;
	}
	*next = s ? s->next : NULL;
	blk->lst = s;
	blk->len = len;

	bb_set(blk);

	return blk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xa0, %edi
callq 0x20e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x78(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x80(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x90(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x88(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x98(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x9c(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3353
movq -0x8(%rbp), %rax
cmpl $0x4, (%rax)
je 0x3314
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x3316
jmp 0x3353
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x333c
cmpl $0x1, -0x1c(%rbp)
je 0x333c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3353
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x32fb
cmpq $0x0, -0x8(%rbp)
je 0x3368
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3370
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x3370
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0x33b0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: bb_free
void bb_free(struct bb *blk)
{
	if (!blk) return;
	for (int i = 0; i < blk->nvert; i++)
		vertex_free(blk->graph[i]);
	free(blk->graph);
	free(blk->succ);
	free(blk->pred);
	free(blk->use);
	free(blk->def);
	free(blk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3855
jmp 0x38d2
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x3888
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x53c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x385c
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: bb_get_treg
int bb_get_treg(struct bb *blk, int reg)
{
	for (int i = 0; i < blk->nvert; i++) {
		if (blk->graph[i]->ocolor == reg) return i;
	}
	blk->nvert++;
	if (!blk->graph) blk->graph = malloc(sizeof(struct vertex*));
	else blk->graph = realloc(blk->graph, sizeof(struct vertex*)*blk->nvert);
	struct vertex *v = vertex_init();
	v->ocolor = reg;
	blk->graph[blk->nvert-1] = v;
	return blk->nvert-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x3931
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x3924
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x39c2
jmp 0x3926
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x38f6
movq -0x10(%rbp), %rax
movl 0x78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x3960
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
jmp 0x3984
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x78(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x70(%rax)
movb $0x0, %al
callq 0x52a0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x78(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: bb_addpred
void bb_addpred(struct bb *blk, struct bb *pred)
{
	blk->npred++;
	if (!blk->pred) blk->pred = malloc(sizeof(struct bb*));
	else blk->pred = realloc(blk->pred, blk->npred * sizeof(struct bb*));
	blk->pred[blk->npred-1] = pred;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x3a0f
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
jmp 0x3a33
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x3c(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: bb_addsucc
void bb_addsucc(struct bb *blk, struct bb *succ)
{
	blk->nsucc++;
	if (!blk->succ) blk->succ = malloc(sizeof(struct bb*));
	else blk->succ = realloc(blk->succ, blk->nsucc * sizeof(struct bb*));
	blk->succ[blk->nsucc-1] = succ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x3a9f
movl $0x8, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3ac3
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x38(%rax), %rsi
shlq $0x3, %rsi
callq 0x20f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x38(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Mithreindeir[P]ewcc/src/live.c
// Function: intarr_add
void intarr_add(int **arr, int *num, int val)
{
	int n = *num, *array = *arr;
	n++;
	if (n == 1) {
		array = malloc(sizeof(int));
	} else {
		array = realloc(array, sizeof(int) * n);
	}

	array[n - 1] = val;

	*num = n;
	*arr = array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jne 0x3b86
movl $0x4, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
jmp 0x3b9b
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rsi
shlq $0x2, %rsi
callq 0x20f0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)