LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_script
int mkfn_script(char *script, int nscripts)
{
	/* fill mkfn_scripts (if unspecified) in the first call */
	if (!mkfn_scripts) {
		if (nscripts == 1 || !script)
			return 1;
		if (!strcmp("DFLT", script))
			mkfn_scripts = "DFLT";
		else
			mkfn_scripts = "latn";
	}
	if (!strcmp("list", mkfn_scripts))
		printf("%s\n", script ? script : "");
	if (strchr(script, ' '))
		*strchr(script, ' ') = '\0';
	return !!strstr(mkfn_scripts, script);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x3279d(%rip)     # 0x6fb38
jne 0x3d3d8
cmpl $0x1, %esi
sete %cl
testq %rbx, %rbx
sete %dl
movl $0x1, %eax
orb %cl, %dl
jne 0x3d431
leaq 0x5ca7(%rip), %r14      # 0x43060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d140
testl %eax, %eax
leaq 0x5c98(%rip), %rax      # 0x43065
cmoveq %r14, %rax
movq %rax, 0x32760(%rip)     # 0x6fb38
movq 0x32759(%rip), %rsi     # 0x6fb38
leaq 0x5c84(%rip), %rdi      # 0x4306a
callq 0x3d140
testl %eax, %eax
jne 0x3d402
testq %rbx, %rbx
leaq 0x6311(%rip), %rdi      # 0x4370a
cmovneq %rbx, %rdi
callq 0x3d070
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3d0b0
testq %rax, %rax
je 0x3d417
movb $0x0, (%rax)
movq 0x3271a(%rip), %rdi     # 0x6fb38
movq %rbx, %rsi
callq 0x3d1c0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_lang
int mkfn_lang(char *lang, int nlangs)
{
	if (!mkfn_langs)
		return 1;
	if (!lang)
		lang = "";
	if (!strcmp("list", mkfn_langs))
		printf("%s\n", lang);
	if (strchr(lang, ' '))
		*strchr(lang, ' ') = '\0';
	return !!strstr(mkfn_langs, lang);
}

// Assembly:
movq 0x32700(%rip), %rsi     # 0x6fb40
testq %rsi, %rsi
je 0x3d49d
pushq %rbx
testq %rdi, %rdi
leaq 0x62ba(%rip), %rbx      # 0x4370a
cmovneq %rdi, %rbx
leaq 0x5c0f(%rip), %rdi      # 0x4306a
callq 0x3d140
testl %eax, %eax
jne 0x3d46c
movq %rbx, %rdi
callq 0x3d070
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3d0b0
testq %rax, %rax
je 0x3d481
movb $0x0, (%rax)
movq 0x326b8(%rip), %rdi     # 0x6fb40
movq %rbx, %rsi
callq 0x3d1c0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
popq %rbx
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_font
int mkfn_font(char *font)
{
	static int idx;			/* font index */
	idx++;
	if (!mkfn_subfont)
		return idx == 1;
	if (!strcmp("list", mkfn_subfont))
		printf("%s\n", font);
	if (mkfn_subfont[0] && isdigit((unsigned char) mkfn_subfont[0]))
		if (atoi(mkfn_subfont) == idx)
			return 1;
	return !strcmp(mkfn_subfont, font);
}

// Assembly:
movl 0x3269f(%rip), %eax     # 0x6fb48
leal 0x1(%rax), %ecx
movl %ecx, 0x32696(%rip)     # 0x6fb48
movq 0x32697(%rip), %rsi     # 0x6fb50
testq %rsi, %rsi
je 0x3d527
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5b9d(%rip), %rdi      # 0x4306a
callq 0x3d140
testl %eax, %eax
jne 0x3d4de
movq %rbx, %rdi
callq 0x3d070
movq 0x3266b(%rip), %r14     # 0x6fb50
movzbl (%r14), %r15d
testq %r15, %r15
je 0x3d510
callq 0x3d1d0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
je 0x3d510
movq %r14, %rdi
callq 0x3d190
movb $0x1, %cl
cmpl 0x3263a(%rip), %eax     # 0x6fb48
je 0x3d520
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d140
testl %eax, %eax
sete %cl
popq %rbx
popq %r14
popq %r15
jmp 0x3d52c
testl %eax, %eax
sete %cl
movzbl %cl, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_featrank
int mkfn_featrank(char *scrp, char *feat)
{
	static char **order;
	int i;
	if (!order || strcmp(scrp, order[0])) {
		order = NULL;
		for (i = 0; i < LEN(scriptorder); i++)
			if (!strcmp(scrp, scriptorder[i][0]))
				order = scriptorder[i];
	}
	if (order && strstr(order[1], feat))
		return strstr(order[1], feat) - order[1];
	return 1000;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x32613(%rip), %rax     # 0x6fb58
testq %rax, %rax
je 0x3d559
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3d140
testl %eax, %eax
je 0x3d596
movq $0x0, 0x325f4(%rip) # 0x6fb58
xorl %r15d, %r15d
leaq 0x2cba2(%rip), %r12     # 0x6a110
movq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x3d140
testl %eax, %eax
jne 0x3d589
leaq (%r12,%r15), %rax
movq %rax, 0x325cf(%rip)     # 0x6fb58
addq $0x10, %r15
cmpq $0x1e0, %r15            # imm = 0x1E0
jne 0x3d56e
movq 0x325bb(%rip), %rax     # 0x6fb58
movl $0x3e8, %ebp            # imm = 0x3E8
testq %rax, %rax
je 0x3d5c0
movq 0x8(%rax), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d1c0
testq %rax, %rax
je 0x3d5c0
subl %r14d, %eax
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/mkfn.c
// Function: mkfn_header
void mkfn_header(char *fontname)
{
	if (mkfn_dry)
		return;
	if (mkfn_trname)
		printf("name %s\n", mkfn_trname);
	if (mkfn_psname)
		printf("fontname %s\n", mkfn_psname);
	if (!mkfn_psname && fontname && fontname[0])
		printf("fontname %s\n", fontname);
	if (mkfn_path)
		printf("fontpath %s\n", mkfn_path);
	trfn_header();
	if (mkfn_special)
		printf("special\n");
	trfn_cdefs();
}

// Assembly:
cmpl $0x0, 0x3258e(%rip)     # 0x6fb60
je 0x3d5d5
retq
pushq %rbx
movq %rdi, %rbx
movq 0x32588(%rip), %rsi     # 0x6fb68
testq %rsi, %rsi
je 0x3d5f3
leaq 0x5a87(%rip), %rdi      # 0x43073
xorl %eax, %eax
callq 0x3d0c0
movq 0x32576(%rip), %rsi     # 0x6fb70
testq %rsi, %rsi
je 0x3d60d
leaq 0x5a69(%rip), %rdi      # 0x4306f
xorl %eax, %eax
callq 0x3d0c0
testq %rbx, %rbx
je 0x3d632
cmpq $0x0, 0x32556(%rip)     # 0x6fb70
jne 0x3d632
cmpb $0x0, (%rbx)
je 0x3d632
leaq 0x5a47(%rip), %rdi      # 0x4306f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3d0c0
movq 0x3253f(%rip), %rsi     # 0x6fb78
testq %rsi, %rsi
je 0x3d64c
leaq 0x5a37(%rip), %rdi      # 0x4307c
xorl %eax, %eax
callq 0x3d0c0
callq 0x3e278
cmpl $0x0, 0x32528(%rip)     # 0x6fb80
je 0x3d666
leaq 0x6071(%rip), %rdi      # 0x436d2
callq 0x3d070
popq %rbx
jmp 0x3e2bb
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_init
void trfn_init(void)
{
	int i;
	sbuf_char = sbuf_make();
	tab_agl = tab_alloc(LEN(agl));
	for (i = 0; i < LEN(agl); i++)
		tab_put(tab_agl, agl[i][0], agl[i][1]);
	tab_alts = tab_alloc(LEN(alts));
	for (i = 0; i < LEN(alts); i++)
		tab_put(tab_alts, alts[i][0], alts[i] + 1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3e4fc
movq %rax, 0x318b5(%rip)     # 0x6fba0
movl $0x10b9, %edi           # imm = 0x10B9
callq 0x3e748
movq %rax, 0x358b4(%rip)     # 0x73bb0
movl $0x8, %ebx
leaq 0x19078(%rip), %r14     # 0x57380
movq 0x358a1(%rip), %rdi     # 0x73bb0
movq -0x8(%rbx,%r14), %rsi
movq (%rbx,%r14), %rdx
callq 0x3e7e7
addq $0x10, %rbx
cmpq $0x10b98, %rbx          # imm = 0x10B98
jne 0x3e308
movl $0x161, %edi            # imm = 0x161
callq 0x3e748
movq %rax, 0x3186d(%rip)     # 0x6fba8
xorl %ebx, %ebx
leaq 0x2bfac(%rip), %r14     # 0x6a2f0
movq 0x3185d(%rip), %rdi     # 0x6fba8
leaq (%rbx,%r14), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rsi
callq 0x3e7e7
addq $0x40, %rbx
cmpq $0x5840, %rbx           # imm = 0x5840
jne 0x3e344
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/trfn.c
// Function: trfn_done
void trfn_done(void)
{
	sbuf_free(sbuf_char);
	tab_free(tab_alts);
	if (tab_agl)
		tab_free(tab_agl);
}

// Assembly:
pushq %rax
movq 0x31827(%rip), %rdi     # 0x6fba0
callq 0x3e5ac
movq 0x31823(%rip), %rdi     # 0x6fba8
callq 0x3e7c0
movq 0x3581f(%rip), %rdi     # 0x73bb0
testq %rdi, %rdi
je 0x3e39c
popq %rax
jmp 0x3e7c0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/trfn.c
// Function: utf8put
static void utf8put(char **d, int c)
{
	int l = 0;
	if (c > 0xffff) {
		*(*d)++ = 0xf0 | (c >> 18);
		l = 3;
	} else if (c > 0x7ff) {
		*(*d)++ = 0xe0 | (c >> 12);
		l = 2;
	} else if (c > 0x7f) {
		*(*d)++ = 0xc0 | (c >> 6);
		l = 1;
	} else {
		*(*d)++ = c > 0 ? c : ' ';
	}
	while (l--)
		*(*d)++ = 0x80 | ((c >> (l * 6)) & 0x3f);
	**d = '\0';
}

// Assembly:
cmpl $0x10000, %esi          # imm = 0x10000
jl 0x3e3c0
movl %esi, %eax
shrl $0x12, %eax
orb $-0x10, %al
movq (%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb %al, (%rcx)
movl $0x3, %eax
jmp 0x3e403
cmpl $0x800, %esi            # imm = 0x800
jl 0x3e3e2
movl %esi, %eax
shrl $0xc, %eax
orb $-0x20, %al
movq (%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rdi)
movb %al, (%rcx)
movl $0x2, %eax
jmp 0x3e403
movq (%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
cmpl $0x80, %esi
jl 0x3e438
movl %esi, %ecx
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rax)
movl $0x1, %eax
xorl %ecx, %ecx
testb %cl, %cl
jne 0x3e431
leal (%rax,%rax,2), %ecx
leal -0x6(,%rcx,2), %ecx
movl %esi, %edx
sarl %cl, %edx
andb $0x3f, %dl
orb $-0x80, %dl
movq (%rdi), %r8
leaq 0x1(%r8), %r9
addl $-0x6, %ecx
movq %r9, (%rdi)
movb %dl, (%r8)
decl %eax
jne 0x3e413
movq (%rdi), %rax
movb $0x0, (%rax)
retq
testl %esi, %esi
movl $0x20, %ecx
cmovgl %esi, %ecx
movb %cl, (%rax)
xorl %eax, %eax
movb $0x1, %cl
jmp 0x3e405
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/trfn.c
// Function: hexval
static int hexval(char *s, int len)
{
	char *digs = HEXDIGS;
	int n = 0;
	int i;
	for (i = 0; i < len; i++) {
		if (s[i] && strchr(digs, s[i]))
			n = n * 16 + (strchr(digs, s[i]) - digs);
		else
			break;
	}
	return i < 4 ? -1 : n;
}

// Assembly:
testl %esi, %esi
jle 0x3e4ab
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r12d
xorl %r15d, %r15d
leaq 0x52ec(%rip), %r14      # 0x43752
xorl %ebp, %ebp
movsbl (%rbx,%r15), %esi
testl %esi, %esi
je 0x3e496
movl $0x11, %edx
movq %r14, %rdi
callq 0x3d110
testq %rax, %rax
je 0x3e496
shll $0x4, %ebp
subl %r14d, %ebp
addl %eax, %ebp
incq %r15
cmpq %r15, %r12
jne 0x3e468
movl %r12d, %r15d
cmpl $0x4, %r15d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
jne 0x3e526
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3e536
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rbx
movl %esi, 0xc(%rdi)
movslq %esi, %rdi
callq 0x3d170
movq %rax, (%r14)
movslq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x3e562
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3d160
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d030
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addl %ebx, %ecx
incl %ecx
cmpl %eax, %ecx
jl 0x3e63f
movl %eax, %esi
addl %eax, %esi
addl %ebx, %eax
incl %eax
cmpl %eax, %esi
cmovlel %eax, %esi
addl $0x7f, %esi
andl $-0x80, %esi
movq %r14, %rdi
callq 0x3e536
movslq 0x8(%r14), %rdi
addq (%r14), %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x3d160
addl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x420, %edi            # imm = 0x420
callq 0x3d170
movq %rax, %rbx
movl $0x420, %edx            # imm = 0x420
movq %rax, %rdi
xorl %esi, %esi
callq 0x3d0f0
movslq %ebp, %r14
leaq (,%r14,8), %r15
movq %r15, %rdi
callq 0x3d170
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3d170
movq %rax, 0x8(%rbx)
shlq $0x2, %r14
movq %r14, %rdi
callq 0x3d170
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %rdi
movl $0x400, %edx            # imm = 0x400
movl $0xff, %esi
callq 0x3d0f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3d030
movq 0x8(%rbx), %rdi
callq 0x3d030
movq 0x18(%rbx), %rdi
callq 0x3d030
movq %rbx, %rdi
popq %rbx
jmp 0x3d030
// File: /workspace/github_c_makefile_star2_O1/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:
movq (%rdi), %rax
movslq 0x10(%rdi), %rcx
movq %rsi, (%rax,%rcx,8)
movq 0x8(%rdi), %rax
movq %rdx, (%rax,%rcx,8)
movzbl (%rsi), %eax
movl 0x20(%rdi,%rax,4), %eax
movq 0x18(%rdi), %rdx
movl %eax, (%rdx,%rcx,4)
movl 0x10(%rdi), %eax
movzbl (%rsi), %ecx
movl %eax, 0x20(%rdi,%rcx,4)
incl %eax
movl %eax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl (%rsi), %eax
movl 0x20(%rdi,%rax,4), %eax
testl %eax, %eax
js 0x3e864
movq %rsi, %r15
movq %rdi, %r14
movb 0x1(%rsi), %bpl
movq (%rdi), %r12
xorl %ebx, %ebx
movl %eax, %r13d
movq (%r12,%r13,8), %rsi
cmpb 0x1(%rsi), %bpl
jne 0x3e856
movq %r15, %rdi
callq 0x3d140
testl %eax, %eax
je 0x3e868
movq 0x18(%r14), %rax
movl (%rax,%r13,4), %eax
testl %eax, %eax
jns 0x3e83d
jmp 0x3e870
xorl %ebx, %ebx
jmp 0x3e870
movq 0x8(%r14), %rax
movq (%rax,%r13,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x3ef3c
callq 0x3d1d0
cmpb $0x3b, %bpl
je 0x3ef3c
movq (%rax), %rcx
movsbq %bpl, %rdx
movzwl (%rcx,%rdx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
jne 0x3ef3c
movb %bpl, (%r14)
incq %r14
movb 0x1(%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x3ef11
callq 0x3d1d0
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
cmpq $0x3b, %rcx
je 0x3ef47
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
jne 0x3ef47
movb $0x0, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x8(%rdi), %r15
movzwl 0x4(%r15), %eax
testw %ax, %ax
je 0x412d6
movq %rsi, %rbx
movq %rdi, %r14
rolw $0x8, %ax
addq $0xc, %r15
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %r13d
movl $0x4, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3d050
testl %eax, %eax
jne 0x412c9
movl 0x8(%r15), %r12d
bswapl %r12d
addq (%r14), %r12
testl %eax, %eax
je 0x412d9
addq $0x10, %r15
decq %r13
jne 0x412ab
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
callq 0x3e4fc
movq %rax, %rbx
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
callq 0x3d120
testl %eax, %eax
jle 0x41388
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x3e609
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r14, %rsi
callq 0x3d120
testl %eax, %eax
jg 0x41368
movq %rbx, %rdi
callq 0x3e571
movq %rax, %rbx
movl (%rax), %eax
bswapl %eax
cmpl $0x10000, %eax          # imm = 0x10000
je 0x413b2
cmpl $0x74746366, %eax       # imm = 0x74746366
je 0x413c2
movl $0x1, %r14d
cmpl $0x4f54544f, %eax       # imm = 0x4F54544F
jne 0x413f3
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3ef70
movl %eax, %r14d
jmp 0x413f3
movl 0x8(%rbx), %eax
bswapl %eax
testl %eax, %eax
jle 0x413f0
movl %eax, %r15d
xorl %r14d, %r14d
xorl %r12d, %r12d
movl 0xc(%rbx,%r12,4), %esi
bswapl %esi
addq %rbx, %rsi
movq %rbx, %rdi
callq 0x3ef70
incq %r12
cmpq %r12, %r15
jne 0x413d4
jmp 0x413f3
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, 0x4(%rsp)
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rbx
movl $0x0, (%rbx)
xorl %r13d, %r13d
cmpl %ebp, %r13d
jge 0x41471
movl (%rsp), %r12d
movq %r14, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq 0x415d2
movl %eax, %r15d
addl %r13d, %r15d
cmpl $0xc, (%rsp)
jne 0x41460
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x415d2
addl %eax, %r15d
addl $0x4b0, (%rsp)          # imm = 0x4B0
movl %r15d, %r13d
movl 0x4(%rsp), %eax
cmpl %eax, (%rsp)
movq %rsp, %rbx
jne 0x41425
jmp 0x41474
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
cmpl $0x186, %esi            # imm = 0x186
jg 0x41520
movslq %ebp, %rax
leaq 0x27c96(%rip), %rcx     # 0x691a0
movq (%rcx,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d060
movq %rdi, %r14
addl $0xfffffe79, %ebp       # imm = 0xFFFFFE79
movl %ebp, %esi
callq 0x41486
movl %eax, %r15d
leaq 0x2e656(%rip), %rax     # 0x6fb90
cmpl $0x0, (%rax)
setne %al
cmpl $0x40, %r15d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
je 0x415c8
cmpl $0x3f, %r15d
movl $0x3f, %eax
cmovll %r15d, %eax
movzwl (%r14), %esi
movzbl 0x2(%r14), %ecx
xorl %edx, %edx
testl %ecx, %ecx
je 0x41593
imull %ecx, %ebp
movl %ecx, %edi
movslq %ebp, %r8
addq %r14, %r8
addq $0x3, %r8
xorl %r9d, %r9d
movslq %edx, %r10
shlq $0x8, %r10
movzbl (%r8,%r9), %edx
orq %r10, %rdx
incq %r9
cmpq %r9, %rdi
jne 0x4157c
rolw $0x8, %si
movzwl %si, %esi
incl %esi
imull %ecx, %esi
addq %rsi, %r14
leaq (%rdx,%r14), %rsi
addq $0x2, %rsi
movslq %eax, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3d160
movb $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3d229
jmp 0x4154e
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: cff_op
static int cff_op(void *tab, int off, int *val)
{
	int b0 = U8(tab, off);
	int i;
	if (b0 >= 32 && b0 <= 246) {
		*val = b0 - 139;
		return 1;
	}
	if (b0 >= 247 && b0 <= 250) {
		*val = (b0 - 247) * 256 + U8(tab, off + 1) + 108;
		return 2;
	}
	if (b0 >= 251 && b0 <= 254) {
		*val = -(b0 - 251) * 256 - U8(tab, off + 1) - 108;
		return 2;
	}
	if (b0 == 28) {
		*val = (U8(tab, off + 1) << 8) | U8(tab, off + 2);
		return 3;
	}
	if (b0 == 29) {
		*val = (U8(tab, off + 1) << 24) | (U8(tab, off + 2) << 16) |
			(U8(tab, off + 3) << 8) | U8(tab, off + 4);
		return 5;
	}
	if (b0 == 30) {
		for (i = 1; i < 32; i++) {
			int nib = U8(tab, off + i);
			if ((nib & 0x0f) == 0x0f || (nib & 0xf0) == 0xf0)
				break;
		}
		*val = 0;
		return i + 1;
	}
	*val = b0;
	return 1;
}

// Assembly:
movslq %esi, %rcx
movzbl (%rdi,%rcx), %eax
leal -0x20(%rax), %esi
cmpb $-0x2a, %sil
ja 0x415ef
addl $0xffffff75, %eax       # imm = 0xFFFFFF75
movl %eax, (%rdx)
movl $0x1, %eax
retq
leal 0x9(%rax), %esi
cmpb $0x3, %sil
ja 0x41609
shll $0x8, %eax
movzbl 0x1(%rdi,%rcx), %ecx
addl %ecx, %eax
addl $0xffff096c, %eax       # imm = 0xFFFF096C
jmp 0x41623
leal 0x5(%rax), %esi
cmpb $0x3, %sil
ja 0x4162b
shll $0x8, %eax
movzbl 0x1(%rdi,%rcx), %ecx
orl %eax, %ecx
movl $0xfa94, %eax           # imm = 0xFA94
subl %ecx, %eax
movl %eax, (%rdx)
movl $0x2, %eax
retq
cmpl $0x1c, %eax
je 0x41680
cmpl $0x1d, %eax
je 0x41672
cmpl $0x1e, %eax
jne 0x415e7
addq %rcx, %rdi
movl $0x1, %eax
movzbl (%rdi,%rax), %ecx
movl %ecx, %esi
notl %esi
testb $0xf, %sil
je 0x41669
andl $-0x10, %ecx
cmpl $0xf0, %ecx
je 0x41669
incq %rax
cmpq $0x20, %rax
jne 0x41642
movl $0x20, %eax
movl $0x0, (%rdx)
incl %eax
retq
movl 0x1(%rdi,%rcx), %eax
bswapl %eax
movl %eax, (%rdx)
movl $0x5, %eax
retq
movzwl 0x1(%rdi,%rcx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, (%rdx)
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, (%rdi)
leaq 0x10(%rdi), %rdx
leaq 0x17e2(%rip), %rcx      # 0x43060
cmovneq %rdi, %rcx
leaq 0x5b2357(%rip), %r14    # 0x5f3be0
leaq 0x134ca(%rip), %rsi     # 0x54d5a
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d1a0
cmpb $0x0, 0x8(%rbx)
je 0x418ca
addq $0x8, %rbx
movq %r14, %rdi
callq 0x3d0a0
addq %rax, %r14
leaq 0x134a6(%rip), %rsi     # 0x54d5c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d1a0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: otf_gsubtype1
static void otf_gsubtype1(struct otf *otf, void *sub, char *feat, struct gctx *ctx)
{
	int *cov;
	int fmt = U16(sub, 0);
	int ncov;
	int i;
	cov = coverage(sub + U16(sub, 2), &ncov);
	if (fmt == 1) {
		for (i = 0; i < ncov; i++) {
			int dst = cov[i] + S16(sub, 4);
			if (dst >= glyph_n || dst < 0)
				continue;
			printf("gsub %s %d", feat, 2 + gctx_len(ctx, 1));
			gctx_backtrack(ctx);
			printf(" -%s +%s", glyph_name[cov[i]], glyph_name[dst]);
			gctx_lookahead(ctx, 1);
			printf("\n");
		}
	}
	if (fmt == 2) {
		int n = U16(sub, 4);
		for (i = 0; i < n; i++) {
			printf("gsub %s %d", feat, 2 + gctx_len(ctx, 1));
			gctx_backtrack(ctx);
			printf(" -%s +%s", glyph_name[cov[i]],
				glyph_name[U16(sub, 6 + 2 * i)]);
			gctx_lookahead(ctx, 1);
			printf("\n");
		}
	}
	free(cov);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movzwl (%rdi), %r12d
movl %r12d, %ebp
rolw $0x8, %bp
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edi
addq %r14, %rdi
leaq 0x4(%rsp), %rsi
callq 0x420fd
movq %rax, %r15
cmpw $0x2, %bp
je 0x419fc
movzwl %bp, %eax
cmpl $0x1, %eax
jne 0x41ab6
movw %r12w, 0x2(%rsp)
cmpl $0x0, 0x4(%rsp)
jle 0x419ec
xorl %ebp, %ebp
movzwl 0x4(%r14), %eax
rolw $0x8, %ax
movslq (%r15,%rbp,4), %r12
movswl %ax, %r13d
addl %r12d, %r13d
sets %al
cmpl 0x32274(%rip), %r13d    # 0x73bc4
setge %cl
orb %al, %cl
jne 0x419db
testq %rbx, %rbx
je 0x41979
movl 0xc0(%rbx), %eax
movl 0xc8(%rbx), %ecx
addl 0xc4(%rbx), %eax
leal (%rcx,%rax), %edx
incl %edx
jmp 0x4197e
movl $0x2, %edx
leaq 0x133db(%rip), %rdi     # 0x54d60
leaq 0x5b2254(%rip), %rsi    # 0x5f3be0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x421d5
shlq $0x6, %r12
leaq 0x3222a(%rip), %rax     # 0x73bd0
addq %rax, %r12
movl %r13d, %edx
shlq $0x6, %rdx
addq %rax, %rdx
leaq 0x133b1(%rip), %rdi     # 0x54d6b
movq %r12, %rsi
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x42249
movl $0xa, %edi
callq 0x3d040
incq %rbp
movslq 0x4(%rsp), %rax
cmpq %rax, %rbp
jl 0x41932
movzwl 0x2(%rsp), %eax
cmpl $0x200, %eax            # imm = 0x200
jne 0x41ab6
movzwl 0x4(%r14), %eax
testw %ax, %ax
je 0x41ab6
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %r12d
leaq 0x321ab(%rip), %r13     # 0x73bd0
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x41a45
movl 0xc0(%rbx), %eax
movl 0xc8(%rbx), %ecx
addl 0xc4(%rbx), %eax
leal (%rcx,%rax), %edx
incl %edx
jmp 0x41a4a
movl $0x2, %edx
leaq 0x1330f(%rip), %rdi     # 0x54d60
leaq 0x5b2188(%rip), %rsi    # 0x5f3be0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x421d5
movslq (%r15,%rbp,4), %rsi
shlq $0x6, %rsi
movzwl 0x6(%r14,%rbp,2), %eax
rolw $0x8, %ax
addq %r13, %rsi
movzwl %ax, %edx
shll $0x6, %edx
addq %r13, %rdx
leaq 0x132df(%rip), %rdi     # 0x54d6b
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x42249
movl $0xa, %edi
callq 0x3d040
incq %rbp
cmpq %rbp, %r12
jne 0x41a27
movq %r15, %rdi
callq 0x3d030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpw $0x100, (%rdi)          # imm = 0x100
jne 0x41c2e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edi
addq %r15, %rdi
xorl %esi, %esi
callq 0x420fd
movq %rax, 0x8(%rsp)
movzwl 0x4(%r15), %eax
testw %ax, %ax
je 0x41c16
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x10(%rsp)
leaq 0x3209d(%rip), %r14     # 0x73bd0
xorl %r12d, %r12d
movq %r15, (%rsp)
movzwl 0x6(%r15,%r12,2), %eax
rolw $0x8, %ax
movzwl %ax, %r13d
movzwl (%r15,%r13), %eax
testw %ax, %ax
je 0x41c04
addq (%rsp), %r13
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %ebp
xorl %r15d, %r15d
testq %rbx, %rbx
je 0x41b8e
movl 0xc0(%rbx), %eax
movl 0xc8(%rbx), %ecx
addl 0xc4(%rbx), %eax
leal (%rcx,%rax), %edx
incl %edx
jmp 0x41b93
movl $0x2, %edx
leaq 0x131c6(%rip), %rdi     # 0x54d60
leaq 0x5b203f(%rip), %rsi    # 0x5f3be0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x421d5
movq 0x8(%rsp), %rax
movslq (%rax,%r12,4), %rsi
shlq $0x6, %rsi
movzwl 0x2(%r13,%r15,2), %eax
rolw $0x8, %ax
addq %r14, %rsi
movzwl %ax, %edx
shll $0x6, %edx
addq %r14, %rdx
leaq 0x13191(%rip), %rdi     # 0x54d6b
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x42249
movl $0xa, %edi
callq 0x3d040
incq %r15
cmpq %r15, %rbp
jne 0x41b70
incq %r12
cmpq 0x10(%rsp), %r12
movq (%rsp), %r15
jne 0x41b3a
movq 0x8(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d030
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: otf_gsubtype4
static void otf_gsubtype4(struct otf *otf, void *sub, char *feat, struct gctx *ctx)
{
	int fmt = U16(sub, 0);
	int *cov;
	int n, i, j, k;
	if (fmt != 1)
		return;
	cov = coverage(sub + U16(sub, 2), NULL);
	n = U16(sub, 4);
	for (i = 0; i < n; i++) {
		void *set = sub + U16(sub, 6 + 2 * i);
		int nset = U16(set, 0);
		for (j = 0; j < nset; j++) {
			void *lig = set + U16(set, 2 + 2 * j);
			int nlig = U16(lig, 2);
			printf("gsub %s %d", feat, nlig + 1 + gctx_len(ctx, nlig));
			gctx_backtrack(ctx);
			printf(" -%s", glyph_name[cov[i]]);
			for (k = 0; k < nlig - 1; k++)
				printf(" -%s", glyph_name[U16(lig, 4 + 2 * k)]);
			printf(" +%s", glyph_name[U16(lig, 0)]);
			gctx_lookahead(ctx, nlig);
			printf("\n");
		}
	}
	free(cov);
}

// Assembly:
cmpw $0x100, (%rdi)          # imm = 0x100
jne 0x41e21
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edi
addq %r14, %rdi
xorl %esi, %esi
callq 0x420fd
movq %rax, 0x10(%rsp)
movzwl 0x4(%r14), %eax
testw %ax, %ax
je 0x41e09
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x20(%rsp)
leaq 0x31f3b(%rip), %r13     # 0x73bd0
xorl %r12d, %r12d
movq %rbx, 0x28(%rsp)
movq %r14, 0x8(%rsp)
movzwl 0x6(%r14,%r12,2), %eax
rolw $0x8, %ax
movzwl %ax, %edx
movzwl (%r14,%rdx), %eax
testw %ax, %ax
je 0x41df6
addq 0x8(%rsp), %rdx
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x30(%rsp)
xorl %r14d, %r14d
movq %r12, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movzwl 0x2(%rdx,%r14,2), %eax
rolw $0x8, %ax
movzwl %ax, %r15d
movzwl 0x2(%rdx,%r15), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
testq %rbx, %rbx
je 0x41d1d
movl 0xc0(%rbx), %eax
subl %ebp, %eax
addl 0xc4(%rbx), %eax
addl 0xc8(%rbx), %eax
jmp 0x41d1f
xorl %eax, %eax
addq %rdx, %r15
leal 0x1(%rbp), %edx
addl %eax, %edx
leaq 0x13032(%rip), %rdi     # 0x54d60
leaq 0x5b1eab(%rip), %rsi    # 0x5f3be0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x421d5
movq 0x10(%rsp), %rax
movslq (%rax,%r12,4), %rsi
shlq $0x6, %rsi
addq %r13, %rsi
leaq 0x1301f(%rip), %rbx     # 0x54d7a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3d0c0
movq %rbp, 0x18(%rsp)
cmpw $0x2, %bp
jb 0x41da3
movq %rbx, %rbp
movq 0x18(%rsp), %rax
leal -0x1(%rax), %ebx
xorl %r12d, %r12d
movzwl 0x4(%r15,%r12,2), %eax
rolw $0x8, %ax
movzwl %ax, %esi
shll $0x6, %esi
addq %r13, %rsi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r12
cmpq %r12, %rbx
jne 0x41d7e
movzwl (%r15), %eax
rolw $0x8, %ax
movzwl %ax, %esi
shll $0x6, %esi
addq %r13, %rsi
leaq 0x12fb4(%rip), %rdi     # 0x54d6f
xorl %eax, %eax
callq 0x3d0c0
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x42249
movl $0xa, %edi
callq 0x3d040
incq %r14
cmpq 0x30(%rsp), %r14
movq 0x40(%rsp), %r12
movq 0x38(%rsp), %rdx
jne 0x41ce7
incq %r12
cmpq 0x20(%rsp), %r12
movq 0x8(%rsp), %r14
jne 0x41ca2
movq 0x10(%rsp), %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d030
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %eax
movq %r8, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movzwl 0x6(%rdi), %edx
rolw $0x8, %dx
movzwl %dx, %ebp
addq %rdi, %rbp
movzwl 0x2(%rsi), %esi
movzwl 0x4(%r12), %r14d
cmpw $-0x1, %si
movq %rcx, (%rsp)
je 0x41ea0
rolw $0x8, %si
movzwl %si, %esi
leaq (%rsi,%rsi,2), %rsi
leaq 0x2(,%rsi,2), %rsi
addq %rbp, %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %rbx, %r8
movl %eax, %r9d
callq 0x41f8a
testw %r14w, %r14w
je 0x41f10
rolw $0x8, %r14w
addq $0x2, %rbp
cmpw $0x2, %r14w
movl $0x1, %ecx
cmovael %r14d, %ecx
movq %rbx, 0x10(%rsp)
movzwl %cx, %ecx
movq %rcx, 0x8(%rsp)
movq %r12, %rbx
movq (%rsp), %r12
xorl %r14d, %r14d
movzwl 0x6(%rbx,%r14,2), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (,%rcx,2), %rsi
addq %rbp, %rsi
movq %r13, %rdi
movq %r15, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r8
movl %eax, %r9d
callq 0x41f8a
incq %r14
cmpq %r14, 0x8(%rsp)
jne 0x41ed4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3d140
movl %eax, %ebp
testl %eax, %eax
jne 0x41f7f
leaq 0x10(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d530
movl %eax, %ebp
leaq 0x10(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d530
cmpl %eax, %ebp
jne 0x41f65
movl 0x18(%rbx), %ebp
subl 0x18(%r14), %ebp
jmp 0x41f7f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d530
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d530
subl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: otf_featrec
static int otf_featrec(struct otf *otf, void *gtab, void *featrec,
			char *stag, char *ltag,
			struct otflookup *lookups, int lookups_n)
{
	void *feats = gtab + U16(gtab, 6);
	void *feat = feats + U16(featrec, 4);
	char ftag[8] = "";
	int n = U16(feat, 2);
	int i, j;
	memcpy(ftag, featrec, 4);
	for (i = 0; i < n; i++) {
		int lookup = U16(feat, 4 + 2 * i);	/* lookup index */
		/* do not store features common to all languages in a script */
		for (j = 0; j < lookups_n; j++)
			if (lookups[j].lookup == lookup && !lookups[j].lang[0])
				if (!strcmp(lookups[j].scrp, stag) &&
						!strcmp(lookups[j].feat, ftag))
					break;
		if (j == lookups_n) {
			strcpy(lookups[j].feat, ftag);
			strcpy(lookups[j].scrp, stag);
			strcpy(lookups[j].lang, ltag);
			lookups[j].lookup = U16(feat, 4 + 2 * i);
			lookups_n++;
		}
	}
	return lookups_n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %r14d
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movzwl 0x6(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ebx
addq %rdi, %rbx
movzwl 0x4(%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movq $0x0, 0x10(%rsp)
movzwl 0x2(%rcx,%rbx), %eax
movl (%rsi), %edx
movl %edx, 0x10(%rsp)
testw %ax, %ax
je 0x420eb
addq %rcx, %rbx
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x30(%rsp)
movq %r8, 0x18(%rsp)
leaq 0x10(%r8), %rax
movq %rax, 0x28(%rsp)
xorl %r13d, %r13d
movq %rbx, 0x8(%rsp)
movl $0x0, %r15d
testl %r14d, %r14d
jle 0x42077
movzwl 0x4(%rbx,%r13,2), %eax
rolw $0x8, %ax
movl %r14d, 0x4(%rsp)
movl %r14d, %r14d
movzwl %ax, %ebx
movq 0x28(%rsp), %rbp
xorl %r15d, %r15d
cmpl %ebx, 0x8(%rbp)
jne 0x4205e
cmpb $0x0, -0x8(%rbp)
jne 0x4205e
leaq -0x10(%rbp), %rdi
movq %r12, %rsi
callq 0x3d140
testl %eax, %eax
jne 0x4205e
movq %rbp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3d140
testl %eax, %eax
je 0x4206d
incq %r15
addq $0x1c, %rbp
cmpq %r15, %r14
jne 0x42032
movl %r14d, %r15d
movl 0x4(%rsp), %r14d
movq 0x8(%rsp), %rbx
cmpl %r14d, %r15d
jne 0x420dd
movl %r15d, %eax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rbx
addq %rax, %rbx
movq 0x18(%rsp), %r15
leaq (%r15,%rbx), %rbp
leaq (%r15,%rbx), %rdi
addq $0x10, %rdi
leaq 0x10(%rsp), %rsi
callq 0x3d060
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3d060
leaq (%r15,%rbx), %rbp
addq $0x8, %rbp
movq 0x8(%rsp), %rbx
movq %rbp, %rdi
movq 0x20(%rsp), %rsi
callq 0x3d060
movzwl 0x4(%rbx,%r13,2), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x10(%rbp)
incl %r14d
incq %r13
cmpq 0x30(%rsp), %r13
jne 0x4200a
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: coverage
static int *coverage(void *cov, int *ncov)
{
	int fmt = U16(cov, 0);
	int n = U16(cov, 2);
	int beg, end;
	int i, j;
	int *out = malloc(glyph_n * sizeof(*out));
	int cnt = 0;
	if (fmt == 1) {
		for (i = 0; i < n; i++)
			out[cnt++] = U16(cov, 4 + 2 * i);
	}
	if (fmt == 2) {
		for (i = 0; i < n; i++) {
			beg = U16(cov, 4 + 6 * i);
			end = U16(cov, 4 + 6 * i + 2);
			for (j = beg; j <= end; j++)
				out[cnt++] = j;
		}
	}
	if (ncov)
		*ncov = cnt;
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x2(%rdi), %ebp
movl %ebp, %eax
rolw $0x8, %ax
movzwl (%rdi), %r12d
movzwl %ax, %r15d
movl 0x31aa1(%rip), %edi     # 0x73bc4
shlq $0x2, %rdi
callq 0x3d170
xorl %ecx, %ecx
cmpl $0x100, %r12d           # imm = 0x100
jne 0x42160
testw %bp, %bp
je 0x42160
cmpl $0x1, %r15d
movl %r15d, %edx
adcl $0x0, %edx
xorl %ecx, %ecx
movzwl 0x4(%r14,%rcx,2), %esi
rolw $0x8, %si
movzwl %si, %esi
movl %esi, (%rax,%rcx,4)
incq %rcx
cmpq %rcx, %rdx
jne 0x42148
movzwl %r12w, %edx
cmpl $0x200, %edx            # imm = 0x200
jne 0x421c5
testw %bp, %bp
je 0x421c5
cmpl $0x1, %r15d
adcl $0x0, %r15d
xorl %edx, %edx
leaq (%rdx,%rdx,2), %rdi
movzwl 0x4(%r14,%rdi,2), %esi
rolw $0x8, %si
movzwl 0x6(%r14,%rdi,2), %edi
rolw $0x8, %di
cmpw %di, %si
ja 0x421bd
movzwl %di, %r8d
movzwl %si, %esi
movslq %ecx, %rcx
leaq (%rax,%rcx,4), %rdi
addl %r8d, %ecx
incl %ecx
incl %r8d
subl %esi, %ecx
movl %esi, (%rdi)
incl %esi
addq $0x4, %rdi
cmpl %esi, %r8d
jne 0x421b0
incq %rdx
cmpq %r15, %rdx
jne 0x4217b
testq %rbx, %rbx
je 0x421cc
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: gctx_backtrack
static void gctx_backtrack(struct gctx *ctx)
{
	int i;
	if (!ctx)
		return;
	for (i = 0; i < ctx->bn; i++)
		printf(" =@%d", ctx->bgrp[i]);
	for (i = 0; i < ctx->seqidx; i++)
		printf(" =@%d", ctx->igrp[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x42248
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc0(%rdi)
jle 0x42212
leaq 0x12b82(%rip), %r14     # 0x54d74
xorl %r15d, %r15d
movl (%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc0(%rbx), %rax
cmpq %rax, %r15
jl 0x421f5
cmpl $0x0, 0xcc(%rbx)
jle 0x42243
leaq 0x12b52(%rip), %r14     # 0x54d74
xorl %r15d, %r15d
movl 0x40(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xcc(%rbx), %rax
cmpq %rax, %r15
jl 0x42225
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: gctx_lookahead
static void gctx_lookahead(struct gctx *ctx, int patlen)
{
	int i;
	if (!ctx)
		return;
	for (i = ctx->seqidx + patlen; i < ctx->in; i++)
		printf(" =@%d", ctx->igrp[i]);
	for (i = 0; i < ctx->ln; i++)
		printf(" =@%d", ctx->lgrp[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x422cd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0xcc(%rdi), %r15
leal (%r15,%rsi), %eax
cmpl 0xc4(%rdi), %eax
jge 0x42294
movslq %esi, %rax
addq %rax, %r15
leaq 0x12afe(%rip), %r14     # 0x54d74
movl 0x40(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc4(%rbx), %rax
cmpq %rax, %r15
jl 0x42276
cmpl $0x0, 0xc8(%rbx)
jle 0x422c8
leaq 0x12ad0(%rip), %r14     # 0x54d74
xorl %r15d, %r15d
movl 0x80(%rbx,%r15,4), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %r15
movslq 0xc8(%rbx), %rax
cmpq %rax, %r15
jl 0x422a7
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: ggrp_make
static int ggrp_make(int *src, int n)
{
	int id = ggrp_find(src, n);
	int i;
	if (id >= 0)
		return id;
	id = ggrp_n++;
	ggrp_g[id] = malloc(n * sizeof(ggrp_g[id][0]));
	ggrp_len[id] = n;
	for (i = 0; i < n; i++)
		ggrp_g[id][i] = src[i];
	printf("ggrp %d %d", id, n);
	for (i = 0; i < n; i++)
		printf(" %s", glyph_name[src[i]]);
	printf("\n");
	return id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movslq 0x5b1906(%rip), %rbx    # 0x5f3bf0
movl %esi, %r12d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
jle 0x4233f
xorl %ecx, %ecx
leaq 0x5b5900(%rip), %rdx    # 0x5f7c00
leaq 0x5b18f9(%rip), %rsi    # 0x5f3c00
cmpl %ebp, (%rdx,%rcx,4)
jne 0x42333
testl %ebp, %ebp
jle 0x4232d
movq (%rsi,%rcx,8), %r8
xorl %edi, %edi
movl (%r14,%rdi,4), %r9d
cmpl (%r8,%rdi,4), %r9d
jne 0x4232f
incq %rdi
cmpq %rdi, %r12
jne 0x42316
movl %r12d, %edi
jmp 0x4232f
xorl %edi, %edi
cmpl %ebp, %edi
je 0x4233d
incq %rcx
cmpq %rbx, %rcx
jne 0x42307
jmp 0x4233f
movl %ecx, %eax
testl %eax, %eax
jns 0x423d7
leal 0x1(%rbx), %eax
movl %eax, 0x5b18a0(%rip)    # 0x5f3bf0
movslq %ebp, %rdi
shlq $0x2, %rdi
callq 0x3d170
leaq 0x5b189d(%rip), %rcx    # 0x5f3c00
movq %rax, (%rcx,%rbx,8)
leaq 0x5b5892(%rip), %rcx    # 0x5f7c00
movl %ebp, (%rcx,%rbx,4)
testl %ebp, %ebp
jle 0x42388
leaq (,%r12,4), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x3d160
leaq 0x129f0(%rip), %rdi     # 0x54d7f
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3d0c0
testl %ebp, %ebp
jle 0x423cb
leaq 0x3182b(%rip), %r13     # 0x73bd0
leaq 0x12a15(%rip), %r15     # 0x54dc1
xorl %ebp, %ebp
movslq (%r14,%rbp,4), %rsi
shlq $0x6, %rsi
addq %r13, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3d0c0
incq %rbp
cmpq %rbp, %r12
jne 0x423ae
movl $0xa, %edi
callq 0x3d040
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: valuerecord_small
static int valuerecord_small(int fmt, void *rec)
{
	int off = 0;
	int i;
	for (i = 0; i < 8; i++) {
		if (fmt & (1 << i)) {
			if (abs(uwid(S16(rec, off))) >= MAX(1, mkfn_kmin))
				return 0;
			off += 2;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x2d78e(%rip), %rax     # 0x6fb88
movl (%rax), %eax
cmpl $0x2, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
btl %r15d, %ebp
jae 0x42438
movslq %r12d, %rax
movzwl (%rbx,%rax), %eax
rolw $0x8, %ax
movswl %ax, %edi
callq 0x412e6
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %r14d, %ecx
jae 0x42448
addl $0x2, %r12d
incl %r15d
cmpl $0x8, %r15d
jne 0x4240f
movl $0x1, %eax
jmp 0x4244a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: valuerecord_print
static void valuerecord_print(int fmt, void *rec)
{
	int vals[8] = {0};
	int off = 0;
	int i;
	for (i = 0; i < 8; i++) {
		if (fmt & (1 << i)) {
			vals[i] = uwid(S16(rec, off));
			off += 2;
		}
	}
	if (fmt)
		printf(":%+d%+d%+d%+d", vals[0], vals[1], vals[2], vals[3]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
xorl %r12d, %r12d
btl %r15d, %ebx
jae 0x42497
movslq %r12d, %r12
movzwl (%r14,%r12), %eax
rolw $0x8, %ax
movswl %ax, %edi
callq 0x412e6
movl %eax, (%rsp,%r15,4)
addl $0x2, %r12d
incq %r15
cmpq $0x8, %r15
jne 0x42475
testl %ebx, %ebx
je 0x424cd
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0xc(%rsp), %r8d
leaq 0x1290a(%rip), %rdi     # 0x54dc5
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3d0c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: classdef
static int classdef(void *tab, int *gl, int *cls)
{
	int fmt = U16(tab, 0);
	int ngl = 0;
	int i, j;
	if (fmt == 1) {
		int beg = U16(tab, 2);
		ngl = U16(tab, 4);
		for (i = 0; i < ngl; i++) {
			gl[i] = beg + i;
			cls[i] = U16(tab, 6 + 2 * i);
		}
	}
	if (fmt == 2) {
		int n = U16(tab, 2);
		for (i = 0; i < n; i++) {
			int beg = U16(tab, 4 + 6 * i);
			int end = U16(tab, 4 + 6 * i + 2);
			for (j = beg; j <= end; j++) {
				gl[ngl] = j;
				cls[ngl] = U16(tab, 4 + 6 * i + 4);
				ngl++;
			}
		}
	}
	return ngl;
}

// Assembly:
movzwl (%rdi), %ecx
xorl %eax, %eax
cmpl $0x100, %ecx            # imm = 0x100
jne 0x42539
movzwl 0x4(%rdi), %r8d
movl %r8d, %eax
rolw $0x8, %ax
movzwl %ax, %eax
testw %r8w, %r8w
je 0x42539
movzwl 0x2(%rdi), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
cmpl $0x1, %eax
movl %eax, %r9d
adcl $0x0, %r9d
xorl %r10d, %r10d
leal (%r8,%r10), %r11d
movl %r11d, (%rsi,%r10,4)
movzwl 0x6(%rdi,%r10,2), %r11d
rolw $0x8, %r11w
movzwl %r11w, %r11d
movl %r11d, (%rdx,%r10,4)
incq %r10
cmpq %r10, %r9
jne 0x42516
movzwl %cx, %ecx
cmpl $0x200, %ecx            # imm = 0x200
jne 0x425e8
movzwl 0x2(%rdi), %ecx
testw %cx, %cx
je 0x425e8
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
rolw $0x8, %cx
cmpw $0x2, %cx
movl $0x1, %r8d
cmovael %ecx, %r8d
movzwl %r8w, %ecx
xorl %r8d, %r8d
leaq (%r8,%r8), %r9
leaq (%r9,%r9,2), %r11
movzwl 0x4(%rdi,%r11), %r10d
rolw $0x8, %r10w
movzwl 0x6(%rdi,%r11), %r9d
rolw $0x8, %r9w
cmpw %r9w, %r10w
ja 0x425da
movzwl %r9w, %r9d
movzwl 0x8(%rdi,%r11), %r11d
rolw $0x8, %r11w
movzwl %r10w, %r10d
movzwl %r11w, %r11d
movslq %eax, %r14
leaq (%rsi,%r14,4), %rbx
leaq (%rdx,%r14,4), %r14
subl %r10d, %r9d
incl %r9d
xorl %r15d, %r15d
leal (%r10,%r15), %ebp
movl %ebp, (%rbx,%r15,4)
movl %r11d, (%r14,%r15,4)
incq %r15
cmpl %r15d, %r9d
jne 0x425c3
addl %r15d, %eax
incq %r8
cmpq %rcx, %r8
jne 0x42574
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aligrudi[P]neatmkfn/otf.c
// Function: ggrp_class
static int ggrp_class(int *src, int *cls, int nsrc, int id)
{
	int *g = malloc(nsrc * sizeof(g[0]));
	int n = 0;
	int i;
	int grp;
	for (i = 0; i < nsrc; i++)
		if (cls[i] == id)
			g[n++] = src[i];
	qsort(g, n, sizeof(g[0]), (void *) intcmp);
	grp = ggrp_make(g, n);
	free(g);
	return grp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %r13
leaq (,%r13,4), %rdi
callq 0x3d170
movq %rax, %rbx
testl %r13d, %r13d
jle 0x4263a
movl %r12d, %eax
xorl %edx, %edx
xorl %ecx, %ecx
cmpl %ebp, (%r14,%rdx,4)
jne 0x42630
movl (%r15,%rdx,4), %esi
movslq %ecx, %rdi
incl %ecx
movl %esi, (%rbx,%rdi,4)
incq %rdx
cmpq %rdx, %rax
jne 0x4261e
jmp 0x4263c
xorl %ecx, %ecx
movslq %ecx, %r14
leaq -0x378(%rip), %rcx      # 0x422ce
movl $0x4, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3d080
movq %rbx, %rdi
movl %r14d, %esi
callq 0x422d3
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3d030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq