LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: achar_map
static int achar_map(char *name)
{
	int i;
	for (i = 0; i < LEN(achars); i++) {
		struct achar *a = &achars[i];
		if (!strncmp(a->name, name, strlen(a->name))) {
			char *postfix = name + strlen(a->name);
			if (!*postfix)
				return a->c;
			if (!strcmp("isolated", postfix))
				return a->s ? a->s : a->c;
			if (!strcmp("initial", postfix))
				return a->i ? a->i : a->c;
			if (!strcmp("medial", postfix))
				return a->m ? a->m : a->c;
			if (!strcmp("final", postfix))
				return a->f ? a->f : a->c;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4f, %rax
jae 0x3eab5
movslq -0x14(%rbp), %rcx
leaq 0x31d94(%rip), %rax     # 0x706c0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3d080
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0x3d040
cmpl $0x0, %eax
jne 0x3eaa5
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3d080
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x3e9a9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eabc
movq -0x28(%rbp), %rsi
leaq 0x7e20(%rip), %rdi      # 0x467d4
callq 0x3d120
cmpl $0x0, %eax
jne 0x3e9e9
movq -0x20(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x3e9d4
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x3e9de
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eabc
movq -0x28(%rbp), %rsi
leaq 0x7de9(%rip), %rdi      # 0x467dd
callq 0x3d120
cmpl $0x0, %eax
jne 0x3ea29
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x3ea14
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0x3ea1e
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eabc
movq -0x28(%rbp), %rsi
leaq 0x7db1(%rip), %rdi      # 0x467e5
callq 0x3d120
cmpl $0x0, %eax
jne 0x3ea66
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x3ea54
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0x3ea5e
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eabc
movq -0x28(%rbp), %rsi
leaq 0x1575a(%rip), %rdi     # 0x541cb
callq 0x3d120
cmpl $0x0, %eax
jne 0x3eaa3
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x3ea91
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x50(%rbp)
jmp 0x3ea9b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3eabc
jmp 0x3eaa5
jmp 0x3eaa7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e913
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: ashape
static void ashape(char *str, char *ext)
{
	int s[NCHAR];
	char *src = str;
	int i, l;
	int bjoin = !strcmp(".medi", ext) || !strcmp(".fina", ext);
	int ejoin = !strcmp(".medi", ext) || !strcmp(".init", ext);
	for (l = 0; l < NCHAR && *src; l++)
		s[l] = utf8get(&src);
	for (i = 0; i < l; i++)
		s[i] = achar_shape(s[i], i > 0 || bjoin, i < l - 1 || ejoin);
	for (i = 0; i < l; i++)
		utf8put(&str, s[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7cb8(%rip), %rdi      # 0x467ab
callq 0x3d120
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
je 0x3eb1f
movq -0x10(%rbp), %rsi
leaq 0x7ca2(%rip), %rdi      # 0x467b1
callq 0x3d120
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x7c76(%rip), %rdi      # 0x467ab
callq 0x3d120
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x4a(%rbp)
je 0x3eb61
movq -0x10(%rbp), %rsi
leaq 0x7c66(%rip), %rdi      # 0x467b7
callq 0x3d120
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x4a(%rbp)
movb -0x4a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x40(%rbp)
xorl %eax, %eax
cmpl $0x8, -0x40(%rbp)
movb %al, -0x4b(%rbp)
jge 0x3eb8e
movq -0x38(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x4b(%rbp)
movb -0x4b(%rbp), %al
testb $0x1, %al
jne 0x3eb97
jmp 0x3ebb5
leaq -0x38(%rbp), %rdi
callq 0x3ec70
movl %eax, %ecx
movslq -0x40(%rbp), %rax
movl %ecx, -0x30(%rbp,%rax,4)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x3eb73
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x3ec33
movslq -0x3c(%rbp), %rax
movl -0x30(%rbp,%rax,4), %eax
movl %eax, -0x50(%rbp)
movb $0x1, %al
cmpl $0x0, -0x3c(%rbp)
movb %al, -0x4c(%rbp)
jg 0x3ebe4
cmpl $0x0, -0x44(%rbp)
setne %al
movb %al, -0x4c(%rbp)
movb -0x4c(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x58(%rbp)
movl -0x3c(%rbp), %ecx
movl -0x40(%rbp), %edx
subl $0x1, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x51(%rbp)
jl 0x3ec0b
cmpl $0x0, -0x48(%rbp)
setne %al
movb %al, -0x51(%rbp)
movl -0x58(%rbp), %esi
movl -0x50(%rbp), %edi
movb -0x51(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3ed70
movl %eax, %ecx
movslq -0x3c(%rbp), %rax
movl %ecx, -0x30(%rbp,%rax,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3ebbc
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x3ec5e
movslq -0x3c(%rbp), %rax
movl -0x30(%rbp,%rax,4), %esi
leaq -0x8(%rbp), %rdi
callq 0x3e640
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3ec3a
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: utf8get
static int utf8get(char **src)
{
	int result;
	int l = 1;
	char *s = *src;
	if (~((unsigned char) **src) & 0xc0)
		return (unsigned char) *(*src)++;
	while (l < 6 && (unsigned char) *s & (0x40 >> l))
		l++;
	result = (0x3f >> l) & (unsigned char) *s++;
	while (l--)
		result = (result << 6) | ((unsigned char) *s++ & 0x3f);
	*src = s;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
xorl $-0x1, %eax
andl $0xc0, %eax
cmpl $0x0, %eax
je 0x3ecbd
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ed60
jmp 0x3ecbf
xorl %eax, %eax
cmpl $0x6, -0x18(%rbp)
movb %al, -0x21(%rbp)
jge 0x3ece8
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl -0x18(%rbp), %ecx
movl $0x40, %edx
sarl %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x3ecf1
jmp 0x3ecfc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3ecbf
movl -0x18(%rbp), %ecx
movl $0x3f, %eax
sarl %cl, %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
andl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
je 0x3ed4f
movl -0x14(%rbp), %eax
shll $0x6, %eax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movzbl (%rcx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ed1d
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: achar_shape
static int achar_shape(int c, int pjoin, int njoin)
{
	int i;
	for (i = 0; i < LEN(achars); i++) {
		struct achar *a = &achars[i];
		if (a->c == c) {
			if (!pjoin && !njoin)
				return a->c;
			if (!pjoin && njoin)
				return a->i ? a->i : a->c;
			if (pjoin && njoin)
				return a->m ? a->m : a->c;
			if (pjoin && !njoin)
				return a->f ? a->f : a->c;
		}
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x4f, %rax
jae 0x3ee84
movslq -0x14(%rbp), %rcx
leaq 0x31923(%rip), %rax     # 0x706c0
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x3ee74
cmpl $0x0, -0xc(%rbp)
jne 0x3edd3
cmpl $0x0, -0x10(%rbp)
jne 0x3edd3
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ee8a
cmpl $0x0, -0xc(%rbp)
jne 0x3ee0a
cmpl $0x0, -0x10(%rbp)
je 0x3ee0a
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x3edf5
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x3edff
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ee8a
cmpl $0x0, -0xc(%rbp)
je 0x3ee3e
cmpl $0x0, -0x10(%rbp)
je 0x3ee3e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x3ee2c
movq -0x20(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0x3ee36
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ee8a
cmpl $0x0, -0xc(%rbp)
je 0x3ee72
cmpl $0x0, -0x10(%rbp)
jne 0x3ee72
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x3ee60
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x3ee6a
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3ee8a
jmp 0x3ee74
jmp 0x3ee76
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3ed84
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/trfn.c
// Function: utf8len
static int utf8len(int c)
{
	if (c > 0 && c <= 0x7f)
		return 1;
	if (c >= 0xfc)
		return 6;
	if (c >= 0xf8)
		return 5;
	if (c >= 0xf0)
		return 4;
	if (c >= 0xe0)
		return 3;
	if (c >= 0xc0)
		return 2;
	return c != 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x3eeac
cmpl $0x7f, -0x8(%rbp)
jg 0x3eeac
movl $0x1, -0x4(%rbp)
jmp 0x3ef15
cmpl $0xfc, -0x8(%rbp)
jl 0x3eebe
movl $0x6, -0x4(%rbp)
jmp 0x3ef15
cmpl $0xf8, -0x8(%rbp)
jl 0x3eed0
movl $0x5, -0x4(%rbp)
jmp 0x3ef15
cmpl $0xf0, -0x8(%rbp)
jl 0x3eee2
movl $0x4, -0x4(%rbp)
jmp 0x3ef15
cmpl $0xe0, -0x8(%rbp)
jl 0x3eef4
movl $0x3, -0x4(%rbp)
jmp 0x3ef15
cmpl $0xc0, -0x8(%rbp)
jl 0x3ef06
movl $0x2, -0x4(%rbp)
jmp 0x3ef15
cmpl $0x0, -0x8(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/sbuf.c
// Function: sbuf_buf
char *sbuf_buf(struct sbuf *sb)
{
	if (!sb->s)
		sbuf_extend(sb, 1);
	sb->s[sb->s_n] = '\0';
	return sb->s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3efd4
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3f000
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/sbuf.c
// Function: sbuf_extend
static void sbuf_extend(struct sbuf *sbuf, int newsz)
{
	char *s = sbuf->s;
	sbuf->s_sz = newsz;
	sbuf->s = malloc(sbuf->s_sz);
	if (sbuf->s_n)
		memcpy(sbuf->s, s, sbuf->s_n);
	free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdi
callq 0x3d150
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x3f05d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x3d140
movq -0x18(%rbp), %rdi
callq 0x3d030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/sbuf.c
// Function: sbuf_mem
void sbuf_mem(struct sbuf *sbuf, char *s, int len)
{
	if (sbuf->s_n + len + 1 >= sbuf->s_sz)
		sbuf_extend(sbuf, NEXTSZ(sbuf->s_sz, len + 1));
	memcpy(sbuf->s + sbuf->s_n, s, len);
	sbuf->s_n += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x3f1f5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
movl -0x14(%rbp), %edx
addl $0x1, %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x3f1d1
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x3f1dd
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x80, %esi
subl $0x1, %esi
andl $-0x80, %esi
callq 0x3f000
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x3d140
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/tab.c
// Function: tab_alloc
struct tab *tab_alloc(int sz)
{
	struct tab *tab = malloc(sizeof(*tab));
	int i;
	memset(tab, 0, sizeof(*tab));
	tab->keys = malloc(sz * sizeof(tab->keys[0]));
	tab->vals = malloc(sz * sizeof(tab->vals[0]));
	tab->next = malloc(sz * sizeof(tab->next[0]));
	for (i = 0; i < 256; i++)
		tab->head[i] = -1;
	return tab;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x420, %edi            # imm = 0x420
callq 0x3d150
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x420, %edx            # imm = 0x420
callq 0x3d0f0
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3d150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3d150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
callq 0x3d150
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x3f43b
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0xffffffff, 0x20(%rax,%rcx,4) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f417
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/tab.c
// Function: tab_free
void tab_free(struct tab *tab)
{
	free(tab->keys);
	free(tab->vals);
	free(tab->next);
	free(tab);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3d030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3d030
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3d030
movq -0x8(%rbp), %rdi
callq 0x3d030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/tab.c
// Function: tab_put
void tab_put(struct tab *tab, char *k, void *v)
{
	tab->keys[tab->n] = k;
	tab->vals[tab->n] = v;
	tab->next[tab->n] = tab->head[(unsigned char) k[0]];
	tab->head[(unsigned char) k[0]] = tab->n;
	tab->n++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl 0x20(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
movl %edx, 0x20(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/tab.c
// Function: tab_get
void *tab_get(struct tab *tab, char *k)
{
	int i = tab->head[(unsigned char) k[0]];
	while (i >= 0) {
		if (k[1] == tab->keys[i][1] && !strcmp(k, tab->keys[i]))
			return tab->vals[i];
		i = tab->next[i];
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
movl 0x20(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x3f5be
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jne 0x3f5aa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3d120
cmpl $0x0, %eax
jne 0x3f5aa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f5c6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f552
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/afm.c
// Function: afm_charfield
static char *afm_charfield(char *s, char *d)
{
	while (*s && !isspace(*s) && *s != ';')
		*d++ = *s++;
	while (isspace(*s) || *s == ';')
		s++;
	*d = '\0';
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x3fbe7
callq 0x3d1a0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x3fbe7
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3fbf0
jmp 0x3fc14
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x3fba0
jmp 0x3fc16
callq 0x3d1a0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
jne 0x3fc4c
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x3fc55
jmp 0x3fc63
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x3fc16
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_table
static void *otf_table(struct otf *otf, char *name)
{
	int nrecs = U16(otf->off, 4);
	int i;
	for (i = 0; i < nrecs; i++) {
		void *rec = otf->off + 12 + i * 16;	/* an otf table record */
		if (!strncmp(rec, name, 4))
			return otf->otf + U32(rec, 8);
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4021e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0xc, %rax
movl -0x20(%rbp), %ecx
shll $0x4, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x3d040
cmpl $0x0, %eax
jne 0x40211
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3d0e0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x40226
jmp 0x40213
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x401ae
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_name
static void otf_name(struct otf *otf, void *tab)
{
	char name[256];
	void *str = tab + U16(tab, 4);		/* storage area */
	int n = U16(tab, 2);			/* number of name records */
	int i;
	for (i = 0; i < n; i++) {
		void *rec = tab + 6 + 12 * i;
		int pid = U16(rec, 0);		/* platform id */
		int eid = U16(rec, 2);		/* encoding id */
		int lid = U16(rec, 4);		/* language id */
		int nid = U16(rec, 6);		/* name id */
		int len = U16(rec, 8);		/* string length */
		int off = U16(rec, 10);		/* string offset  */
		if (pid == 1 && eid == 0 && lid == 0 && nid == 6) {
			memcpy(name, str + off, len);
			name[len] = '\0';
			snprintf(otf->name, sizeof(otf->name), "%s", name);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movw %ax, %cx
movq -0x148(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x11c(%rbp)
movl $0x0, -0x120(%rbp)
movl -0x120(%rbp), %eax
cmpl -0x11c(%rbp), %eax
jge 0x403e7
movq -0x10(%rbp), %rax
addq $0x6, %rax
imull $0xc, -0x120(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x12c(%rbp)
movq -0x128(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x130(%rbp)
movq -0x128(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x134(%rbp)
movq -0x128(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x138(%rbp)
movq -0x128(%rbp), %rax
movzwl 0x8(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x13c(%rbp)
movq -0x128(%rbp), %rax
movzwl 0xa(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x140(%rbp)
cmpl $0x1, -0x12c(%rbp)
jne 0x403d1
cmpl $0x0, -0x130(%rbp)
jne 0x403d1
cmpl $0x0, -0x134(%rbp)
jne 0x403d1
cmpl $0x6, -0x138(%rbp)
jne 0x403d1
leaq -0x110(%rbp), %rdi
movq -0x118(%rbp), %rsi
movslq -0x140(%rbp), %rax
addq %rax, %rsi
movslq -0x13c(%rbp), %rdx
callq 0x3d140
movslq -0x13c(%rbp), %rax
movb $0x0, -0x110(%rbp,%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
leaq -0x110(%rbp), %rcx
movl $0x80, %esi
leaq 0x17860(%rip), %rdx     # 0x57c2a
movb $0x0, %al
callq 0x3d0c0
jmp 0x403d3
movl -0x120(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0x40295
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_cmap
static void otf_cmap(struct otf *otf, void *cmap)
{
	int nrecs = U16(cmap, 2);
	int i;
	for (i = 0; i < nrecs; i++) {
		void *rec = cmap + 4 + i * 8;	/* a cmap record */
		int plat = U16(rec, 0);
		int enc = U16(rec, 2);
		void *tab = cmap + U32(rec, 4);	/* a cmap subtable */
		int fmt = U16(tab, 0);
		if (plat == 3 && enc == 1 && fmt == 4)
			otf_cmap4(otf, tab);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x404c7
movq -0x10(%rbp), %rax
addq $0x4, %rax
movl -0x18(%rbp), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3d0e0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
cmpl $0x3, -0x24(%rbp)
jne 0x404b7
cmpl $0x1, -0x28(%rbp)
jne 0x404b7
cmpl $0x4, -0x34(%rbp)
jne 0x404b7
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x41070
jmp 0x404b9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4041a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_post
static void otf_post(struct otf *otf, void *post)
{
	void *post2;			/* version 2.0 header */
	void *index;			/* glyph name indices */
	void *names;			/* glyph names */
	int cname = 0;
	int i;
	if (U32(post, 0) != 0x20000)
		return;
	post2 = post + 32;
	glyph_n = U16(post2, 0);
	index = post2 + 2;
	names = index + 2 * glyph_n;
	for (i = 0; i < glyph_n; i++) {
		int idx = U16(index, 2 * i);
		if (idx < 258) {
			strcpy(glyph_name[i], macset[idx]);
		} else {
			memcpy(glyph_name[i], names + cname + 1,
				U8(names, cname));
			glyph_name[i][U8(names, cname)] = '\0';
			cname += U8(names, cname) + 1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3d0e0
cmpl $0x20000, %eax          # imm = 0x20000
je 0x404fe
jmp 0x4061e
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, 0x36305(%rip)     # 0x76824
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x362ef(%rip), %ecx     # 0x76824
shll %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl 0x362d3(%rip), %eax     # 0x76824
jge 0x4061e
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
shll %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
cmpl $0x102, -0x34(%rbp)     # imm = 0x102
jge 0x405a3
movslq -0x30(%rbp), %rax
leaq 0x362aa(%rip), %rdi     # 0x76830
shlq $0x6, %rax
addq %rax, %rdi
movslq -0x34(%rbp), %rcx
leaq 0x30da8(%rip), %rax     # 0x71340
movq (%rax,%rcx,8), %rsi
callq 0x3d050
jmp 0x4060e
movslq -0x30(%rbp), %rax
leaq 0x36282(%rip), %rdi     # 0x76830
shlq $0x6, %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %edx
callq 0x3d140
movslq -0x30(%rbp), %rcx
leaq 0x3624e(%rip), %rax     # 0x76830
shlq $0x6, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
addl $0x1, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x40610
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x40548
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_hmtx
static void otf_hmtx(struct otf *otf, void *hmtx)
{
	void *hhea = otf_table(otf, "hhea");
	int n;
	int i;
	n = U16(hhea, 34);
	for (i = 0; i < n; i++)
		glyph_wid[i] = U16(hmtx, i * 4);
	for (i = n; i < glyph_n; i++)
		glyph_wid[i] = glyph_wid[n - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16fac(%rip), %rsi     # 0x57ba7
callq 0x40180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x22(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x40c58
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %edx
movslq -0x20(%rbp), %rcx
leaq 0x475be6(%rip), %rax    # 0x4b6830
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x40c1e
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x35bbd(%rip), %eax     # 0x76824
jge 0x40c95
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x475bb7(%rip), %rax    # 0x4b6830
movl (%rax,%rcx,4), %edx
movslq -0x20(%rbp), %rcx
leaq 0x475ba9(%rip), %rax    # 0x4b6830
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x40c5e
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_kern
static void otf_kern(struct otf *otf, void *kern)
{
	int off = 4;
	int i, j;
	int n = U16(kern, 2);		/* number of kern subtables */
	for (i = 0; i < n; i++) {
		void *tab = kern + off;	/* a kern subtable */
		int cov = U16(tab, 4);
		off += U16(tab, 2);
		if ((cov >> 8) == 0 && (cov & 1)) {	/* format 0 */
			int npairs = U16(tab, 6);
			for (j = 0; j < npairs; j++) {
				int c1 = U16(tab, 14 + 6 * j);
				int c2 = U16(tab, 14 + 6 * j + 2);
				int val = S16(tab, 14 + 6 * j + 4);
				mkfn_kern(glyph_name[c1], glyph_name[c2],
					uwid(val));
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x40e97
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x2c(%rbp), %eax
sarl $0x8, %eax
cmpl $0x0, %eax
jne 0x40e87
movl -0x2c(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x40e87
movq -0x28(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x40e85
movq -0x28(%rbp), %rax
imull $0x6, -0x1c(%rbp), %ecx
addl $0xe, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
imull $0x6, -0x1c(%rbp), %ecx
addl $0xe, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
imull $0x6, -0x1c(%rbp), %ecx
addl $0xe, %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
cwtl
movl %eax, -0x3c(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x359f1(%rip), %rax     # 0x76830
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x359db(%rip), %rax     # 0x76830
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x3c(%rbp), %edi
callq 0x40ca0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl %eax, %edx
callq 0x3e430
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40dcd
jmp 0x40e87
jmp 0x40e89
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x40d51
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_feat
static void otf_feat(struct otf *otf)
{
	if (otf_table(otf, "GSUB"))
		otf_gsub(otf, otf_table(otf, "GSUB"));
	if (otf_table(otf, "GPOS"))
		otf_gpos(otf, otf_table(otf, "GPOS"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16cf5(%rip), %rsi     # 0x57bac
callq 0x40180
cmpq $0x0, %rax
je 0x40ee6
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16cd7(%rip), %rsi     # 0x57bac
callq 0x40180
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x41780
movq -0x8(%rbp), %rdi
leaq 0x16cc0(%rip), %rsi     # 0x57bb1
callq 0x40180
cmpq $0x0, %rax
je 0x40f20
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x16ca2(%rip), %rsi     # 0x57bb1
callq 0x40180
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x41aa0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_read
int otf_read(void)
{
	char *otf_buf = otf_input(0);
	unsigned tag = U32(otf_buf, 0);
	int n, i;
	if (tag == 0x00010000 || tag == 0x4F54544F)
		return otf_offsettable(otf_buf, otf_buf);
	if (tag != 0x74746366)
		return 1;
	/* OpenType Collections */
	n = U32(otf_buf, 8);
	for (i = 0; i < n; i++) {
		void *off = otf_buf + U32(otf_buf, 12 + i * 4);
		otf_offsettable(otf_buf, off);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %edi, %edi
callq 0x41000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x3d0e0
movl %eax, -0x14(%rbp)
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
je 0x40f63
cmpl $0x4f54544f, -0x14(%rbp) # imm = 0x4F54544F
jne 0x40f75
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3fd00
movl %eax, -0x4(%rbp)
jmp 0x40ff3
cmpl $0x74746366, -0x14(%rbp) # imm = 0x74746366
je 0x40f87
movl $0x1, -0x4(%rbp)
jmp 0x40ff3
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3d0e0
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x40fec
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0xc, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx), %edi
callq 0x3d0e0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3fd00
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40f9d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_input
static void *otf_input(int fd)
{
	struct sbuf *sb = sbuf_make();
	char buf[1 << 12];
	int nr = 0;
	while ((nr = read(fd, buf, sizeof(buf))) > 0)
		sbuf_mem(sb, buf, nr);
	return sbuf_done(sb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movl %edi, -0x4(%rbp)
callq 0x3ef80
movq %rax, -0x10(%rbp)
movl $0x0, -0x1014(%rbp)
movl -0x4(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x3d100
movl %eax, -0x1014(%rbp)
cmpl $0x0, %eax
jle 0x41058
movq -0x10(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
movl -0x1014(%rbp), %edx
callq 0x3f170
jmp 0x41021
movq -0x10(%rbp), %rdi
callq 0x3f070
addq $0x1020, %rsp           # imm = 0x1020
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: cffdict_get
static int cffdict_get(void *dict, int len, int key, int *args)
{
	int off = 0;
	int op = 0;
	int val = 0;
	/* operators: keys (one or two bytes); operands: values */
	while (off < len) {
		val = op;
		if (args) {
			memmove(args + 1, args + 0, 3 * sizeof(args[0]));
			args[0] = val;
		}
		off += cff_op(dict, off, &op);
		if (op == 12) {			/* two-byte operator */
			off += cff_op(dict, off, &op);
			op += 1200;
		}
		if (op == key)
			return val;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x41337
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x412e5
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq -0x20(%rbp), %rdx
movq (%rdx), %rcx
movl 0x8(%rdx), %edx
movl %edx, 0x8(%rax)
movq %rcx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x41520
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0xc, -0x28(%rbp)
jne 0x41322
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x41520
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x4b0, %eax            # imm = 0x4B0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x41332
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4133e
jmp 0x412ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: cff_char
static void cff_char(void *stridx, int id, char *dst)
{
	int len;
	if (id < 391) {
		strcpy(dst, stdset[id]);
		return;
	}
	id -= 391;
	len = cffidx_len(stridx, id);
	if (mkfn_warn && len >= GNLEN)
		fprintf(stderr, "neatmkfn: truncating glyph names (GNLEN is too small)\n");
	if (len >= GNLEN)
		len = GNLEN - 1;
	memcpy(dst, cffidx_get(stridx, id), len);
	dst[len] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x187, -0xc(%rbp)      # imm = 0x187
jge 0x41449
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x30715(%rip), %rax     # 0x71b50
movq (%rax,%rcx,8), %rsi
callq 0x3d050
jmp 0x414ca
movl -0xc(%rbp), %eax
subl $0x187, %eax            # imm = 0x187
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x413d0
movl %eax, -0x1c(%rbp)
leaq 0x31386(%rip), %rax     # 0x727f0
cmpl $0x0, (%rax)
je 0x4148d
cmpl $0x40, -0x1c(%rbp)
jl 0x4148d
movq 0x18b7c(%rip), %rax     # 0x59ff8
movq (%rax), %rdi
leaq 0x16696(%rip), %rsi     # 0x57b1c
movb $0x0, %al
callq 0x3d130
cmpl $0x40, -0x1c(%rbp)
jl 0x4149a
movl $0x3f, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x41350
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3d140
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: cff_int
static int cff_int(void *tab, int off, int sz)
{
	int i;
	int n = 0;
	for (i = 0; i < sz; i++)
		n = n * 256 + U8(tab, off + i);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4151b
movl -0x18(%rbp), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x414ec
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: lookuptag
static char *lookuptag(struct otflookup *lu)
{
	static char tag[16];
	sprintf(tag, "%s:%s", lu->feat, lu->scrp[0] ? lu->scrp : "DFLT");
	if (lu->lang[0])
		sprintf(strchr(tag, '\0'), ":%s", lu->lang);
	return tag;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x420ae
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x420bb
leaq 0x4017(%rip), %rax      # 0x460cc
movq %rax, -0x18(%rbp)
jmp 0x420bb
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x5b4776(%rip), %rdi    # 0x5f6840
leaq 0x15af1(%rip), %rsi     # 0x57bc2
movb $0x0, %al
callq 0x3d180
movq -0x8(%rbp), %rax
cmpb $0x0, 0x8(%rax)
je 0x42109
leaq 0x5b4757(%rip), %rdi    # 0x5f6840
xorl %esi, %esi
callq 0x3d0a0
movq %rax, %rdi
movq -0x8(%rbp), %rdx
addq $0x8, %rdx
leaq 0x15ac2(%rip), %rsi     # 0x57bc4
movb $0x0, %al
callq 0x3d180
leaq 0x5b4730(%rip), %rax    # 0x5f6840
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_gsubtype3
static void otf_gsubtype3(struct otf *otf, void *sub, char *feat, struct gctx *ctx)
{
	int *cov;
	int fmt = U16(sub, 0);
	int n, i, j;
	if (fmt != 1)
		return;
	cov = coverage(sub + U16(sub, 2), NULL);
	n = U16(sub, 4);
	for (i = 0; i < n; i++) {
		void *alt = sub + U16(sub, 6 + 2 * i);
		int nalt = U16(alt, 0);
		for (j = 0; j < nalt; j++) {
			printf("gsub %s %d", feat, 2 + gctx_len(ctx, 1));
			gctx_backtrack(ctx);
			printf(" -%s +%s", glyph_name[cov[i]],
				glyph_name[U16(alt, 2 + 2 * j)]);
			gctx_lookahead(ctx, 1);
			printf("\n");
		}
	}
	free(cov);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
je 0x423a5
jmp 0x42524
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movq -0x50(%rbp), %rdi
movzwl %ax, %eax
cltq
addq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x431f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x4251b
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
shll %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movw %ax, %cx
movq -0x58(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzwl (%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x44(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x44(%rbp), %eax
jge 0x4250b
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x43350
movq -0x68(%rbp), %rsi
movl %eax, %edx
addl $0x2, %edx
leaq 0x15750(%rip), %rdi     # 0x57bc8
movb $0x0, %al
callq 0x3d0b0
movq -0x20(%rbp), %rdi
callq 0x433a0
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movslq (%rax,%rcx,4), %rcx
leaq 0x34395(%rip), %rax     # 0x76830
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movl -0x38(%rbp), %ecx
shll %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movq -0x60(%rbp), %rsi
movzwl %ax, %eax
leaq 0x34364(%rip), %rdx     # 0x76830
shlq $0x6, %rax
addq %rax, %rdx
leaq 0x156f9(%rip), %rdi     # 0x57bd3
movb $0x0, %al
callq 0x3d0b0
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x43430
leaq 0x4284(%rip), %rdi      # 0x4677a
movb $0x0, %al
callq 0x3d0b0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x42446
jmp 0x4250d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x423ed
movq -0x28(%rbp), %rdi
callq 0x3d030
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_unsupported
static void otf_unsupported(char *sub, int type, int fmt)
{
	if (mkfn_warn) {
		fprintf(stderr, "neatmkfn: unsupported %s lookup %d", sub, type);
		if (fmt > 0)
			fprintf(stderr, " format %d", fmt);
		fprintf(stderr, "\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x2fa77(%rip), %rax     # 0x727f0
cmpl $0x0, (%rax)
je 0x42dd6
movq 0x17273(%rip), %rax     # 0x59ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq 0x14e5c(%rip), %rsi     # 0x57bf2
movb $0x0, %al
callq 0x3d130
cmpl $0x0, -0x10(%rbp)
jle 0x42dbe
movq 0x1724e(%rip), %rax     # 0x59ff8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
leaq 0x14e5e(%rip), %rsi     # 0x57c15
movb $0x0, %al
callq 0x3d130
movq 0x17233(%rip), %rax     # 0x59ff8
movq (%rax), %rdi
leaq 0x39ab(%rip), %rsi      # 0x4677a
movb $0x0, %al
callq 0x3d130
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: otf_lang
static int otf_lang(struct otf *otf, void *gtab, void *lang, char *stag, char *ltag,
		struct otflookup *lookups, int lookups_n)
{
	void *feats = gtab + U16(gtab, 6);
	int featidx = U16(lang, 2);
	int nfeat = U16(lang, 4);
	int i;
	if (featidx != 0xffff)
		lookups_n = otf_featrec(otf, gtab, feats + 2 + 6 * featidx,
				stag, ltag, lookups, lookups_n);
	for (i = 0; i < nfeat; i++)
		lookups_n = otf_featrec(otf, gtab, feats + 2 + 6 * U16(lang, 6 + 2 * i),
				stag, ltag, lookups, lookups_n);
	return lookups_n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x6(%rax), %edi
callq 0x3d090
movw %ax, %cx
movq -0x50(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movzwl 0x4(%rax), %edi
callq 0x3d090
movzwl %ax, %eax
movl %eax, -0x40(%rbp)
cmpl $0xffff, -0x3c(%rbp)    # imm = 0xFFFF
je 0x42e8e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq $0x2, %rdx
imull $0x6, -0x3c(%rbp), %eax
cltq
addq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x42fe0
movl %eax, 0x10(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x42f0d
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movl -0x44(%rbp), %ecx
shll %ecx
addl $0x6, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx), %edi
callq 0x3d090
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movzwl %ax, %eax
imull $0x6, %eax, %eax
cltq
addq %rax, %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x10(%rbp), %eax
movl %eax, (%rsp)
callq 0x42fe0
movl %eax, 0x10(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x42e95
movl 0x10(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aligrudi[P]neatmkfn/otf.c
// Function: lookupcmp
static int lookupcmp(void *v1, void *v2)
{
	struct otflookup *l1 = v1;
	struct otflookup *l2 = v2;
	if (strcmp(l1->scrp, l2->scrp))
		return strcmp(l1->scrp, l2->scrp);
	if (mkfn_featrank(l1->scrp, l1->feat) != mkfn_featrank(l1->scrp, l2->feat))
		return mkfn_featrank(l1->scrp, l1->feat) - mkfn_featrank(l1->scrp, l2->feat);
	return l1->lookup - l2->lookup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3d120
cmpl $0x0, %eax
je 0x42f64
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3d120
movl %eax, -0x4(%rbp)
jmp 0x42fd4
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x3d550
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x3d550
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
je 0x42fc3
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x3d550
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
callq 0x3d550
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x42fd4
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x28(%rbp), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)