LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/shadetabler.c
// Function: save_image
static void save_image(const char *filename, unsigned char *buffer, unsigned int width, unsigned int height, unsigned char *palette, unsigned int colors) {
	LodePNGState state;
	lodepng_state_init(&state);
	state.info_raw.colortype = LCT_PALETTE;
	state.info_raw.bitdepth = 8;
	state.info_png.color.colortype = LCT_PALETTE;
	state.info_png.color.bitdepth = 8;

	state.encoder.filter_palette_zero = 0;
	state.encoder.filter_strategy = LFS_ZERO;
	state.encoder.auto_convert = 0;
	state.encoder.force_palette = 1;

	unsigned char *p = palette;
	for (unsigned int i = 0; i < colors; i++) {
		lodepng_palette_add(&state.info_png.color, p[0], p[1], p[2], p[3]);
		lodepng_palette_add(&state.info_raw, p[0], p[1], p[2], p[3]);
		p += 4;
	}

	unsigned char *output_file_data;
	size_t output_file_size;
	unsigned int status = lodepng_encode(&output_file_data, &output_file_size, buffer, width, height, &state);
	if (status) {
		fprintf(stderr, "Can't encode image: %s\n", lodepng_error_text(status));
		goto error;
	}

	FILE *fp = fopen(filename, "wb");
	if (!fp) {
		fprintf(stderr, "Unable to write to %s\n", filename);
		goto error;
	}
	fwrite(output_file_data, 1, output_file_size, fp);
	fclose(fp);

error:
	lodepng_state_cleanup(&state);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %r9d, %ebp
movq %r8, %r12
movl %ecx, 0x4(%rsp)
movl %edx, (%rsp)
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x9fe1
movabsq $0x800000003, %rax      # imm = 0x800000003
movq %rax, 0x90(%rbx)
movq %rax, 0xc8(%rbx)
movl $0x0, 0x70(%rbx)
movq $0x0, 0x68(%rbx)
movl $0x1, 0x80(%rbx)
testl %ebp, %ebp
je 0x10e3e
leaq 0xb0(%rsp), %r13
leaq 0xe8(%rsp), %rbx
movl %ebp, %ebp
xorl %r14d, %r14d
movzbl (%r12,%r14,4), %esi
movzbl 0x1(%r12,%r14,4), %edx
movzbl 0x2(%r12,%r14,4), %ecx
movzbl 0x3(%r12,%r14,4), %r8d
movq %rbx, %rdi
callq 0x5aaa
movzbl (%r12,%r14,4), %esi
movzbl 0x1(%r12,%r14,4), %edx
movzbl 0x2(%r12,%r14,4), %ecx
movzbl 0x3(%r12,%r14,4), %r8d
movq %r13, %rdi
callq 0x5aaa
incq %r14
cmpl %r14d, %ebp
jne 0x10df8
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %r9
movq %r15, %rdx
movl (%rsp), %ecx
movl 0x4(%rsp), %r8d
callq 0xa364
testl %eax, %eax
jne 0x10eb8
leaq 0x1e1d(%rip), %rsi      # 0x12c85
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1190
testq %rax, %rax
je 0x10ec1
movq %rax, %rbx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl $0x1, %esi
movq %rax, %rcx
callq 0x11d0
movq %rbx, %rdi
callq 0x1090
leaq 0x20(%rsp), %rdi
callq 0xa0e1
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1390
jmp 0x10e9c
movq 0x8130(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x350c(%rip), %rsi      # 0x143de
movq %r14, %rdx
xorl %eax, %eax
callq 0x1110
jmp 0x10e9c
// File: /workspace/github_c_makefile_star2_O3/tditlu[P]shadetabler/src/shadetabler.c
// Function: usage
static void usage() {
	printf(SHADETABLER_HEADER "\n");
	printf("Usage: shadetabler -o <output directory> <additional options> <input files...>\n");
	printf("\n");
	printf("Available options are:\n");
	printf(" -o, --output                    Output directory. (Required)\n");
	printf(" -v, --verbose                   Verbose output.\n");
	printf(" -f, --force                     Overwrite existing files, never prompt.\n");
	printf(" -c, --colors [2-256]            Number of colors saved in the output file. (Default 256)\n");
	printf(" -s, --shades [2-256]            Number of shades in shade table. (Default 64)\n");
	printf(" -t, --type [light|dark|both]    Type of shade table(s) to genereate. (Default \"light\")\n");
	printf(" -h, --hq                        High quality quantization quality.\n");
	printf(" -r, --reserve                   Reserve colors for black and white.\n");
	printf(" -p, --priority [0-...]          Priority of input file colors over generated shaded. (Default 0)\n");
	printf(" -l, --light                     Light shade table filename. (Default \"shadetable_light.png\")\n");
	printf(" -d, --dark                      Dark shade table filename. (Default \"shadetable_dark.png\")\n");
	printf("\n");
}

// Assembly:
pushq %rax
leaq 0x32f8(%rip), %rdi      # 0x14413
callq 0x1060
leaq 0x333d(%rip), %rdi      # 0x14464
callq 0x1060
movl $0xa, %edi
callq 0x1040
leaq 0x3376(%rip), %rdi      # 0x144b3
callq 0x1060
leaq 0x3381(%rip), %rdi      # 0x144ca
callq 0x1060
leaq 0x33b3(%rip), %rdi      # 0x14508
callq 0x1060
leaq 0x33d8(%rip), %rdi      # 0x14539
callq 0x1060
leaq 0x3415(%rip), %rdi      # 0x14582
callq 0x1060
leaq 0x3463(%rip), %rdi      # 0x145dc
callq 0x1060
leaq 0x34a6(%rip), %rdi      # 0x1462b
callq 0x1060
leaq 0x34f2(%rip), %rdi      # 0x14683
callq 0x1060
leaq 0x352a(%rip), %rdi      # 0x146c7
callq 0x1060
leaq 0x3563(%rip), %rdi      # 0x1470c
callq 0x1060
leaq 0x35b9(%rip), %rdi      # 0x1476e
callq 0x1060
leaq 0x360b(%rip), %rdi      # 0x147cc
callq 0x1060
movl $0xa, %edi
popq %rax
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: setupTCP
int setupTCP(char* port) {
    int rv;
    int sockfd;
    struct addrinfo hints, *servinfo, *p;
    struct sigaction sa;
    int yes = 1;
    memset(&hints, 0, sizeof hints);
    hints.ai_family = AF_UNSPEC;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags = AI_PASSIVE;

    if((rv = getaddrinfo(IPADDRESS, port, &hints, &servinfo)) != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
		return 1;
    }

    for(p = servinfo; p != NULL; p = p->ai_next) {
        if((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
            perror("server: socket");
            continue;
        }
        if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
            perror("setsockopt");
            exit(1);
        }
        if(bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }
        break;
    }

    freeaddrinfo(servinfo);

    if(p == NULL) {
        fprintf(stderr, "server: failed to bind\n");
        exit(1);
    }

    if(listen(sockfd, BACKLOG) == -1) {
        perror("listen");
        exit(1);
    }
    
    sa.sa_handler = sigchld_handler; // reap all dead processes sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1) {
        perror("sigaction");
        exit(1); 
    }

    return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rsi
movl $0x1, %ebx
movl %ebx, -0x34(%rbp)
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl %ebx, 0x8(%rdx)
movl %ebx, (%rdx)
leaq 0xa4f(%rip), %rdi       # 0x2004
leaq -0x30(%rbp), %rcx
callq 0x11f0
testl %eax, %eax
jne 0x16b2
movq -0x30(%rbp), %r15
testq %r15, %r15
je 0x16c0
leaq 0xa45(%rip), %r12       # 0x201f
leaq -0x34(%rbp), %r14
leaq 0xa54(%rip), %r13       # 0x2039
movl 0x4(%r15), %edi
movl 0x8(%r15), %esi
movl 0xc(%r15), %edx
callq 0x1220
movq %r12, %rdi
cmpl $-0x1, %eax
je 0x1641
movl %eax, %ebx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x1090
cmpl $-0x1, %eax
je 0x16bb
movq 0x18(%r15), %rsi
movl 0x10(%r15), %edx
movl %ebx, %edi
callq 0x1170
cmpl $-0x1, %eax
jne 0x1658
movl %ebx, %edi
callq 0x1100
movq %r13, %rdi
callq 0x1190
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x15e5
movq -0x30(%rbp), %rdi
callq 0x12b8
movq -0x30(%rbp), %rdi
callq 0x1210
movl %ebx, %edi
movl $0xa, %esi
callq 0x1150
cmpl $-0x1, %eax
je 0x16c7
leaq -0x1cd(%rip), %rax      # 0x14ac
leaq -0x108(%rbp), %rsi
movq %rax, (%rsi)
movl $0x10000000, 0x88(%rsi) # imm = 0x10000000
movl $0x11, %edi
xorl %edx, %edx
callq 0x1080
cmpl $-0x1, %eax
je 0x16cc
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x1240
jmp 0x169e
callq 0x12a0
xorl %edi, %edi
callq 0x12b8
callq 0x1288
callq 0x1270
// File: /workspace/github_c_makefile_star2_O3/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: setupUDP2
int setupUDP2(char* port)
{
	int sockfd;
	int rv;
	struct addrinfo hints, *servinfo, *p;
	socklen_t addr_len;
	memset(&hints, 0, sizeof hints);
	hints.ai_family = AF_UNSPEC;
	hints.ai_socktype = SOCK_DGRAM;

	if ((rv = getaddrinfo(IPADDRESS, port, &hints, &servinfo)) != 0) {
		fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
		return 1;
	}

	// loop through all the results and make a socket
	for(p = servinfo; p != NULL; p = p->ai_next) {
		if ((sockfd = socket(p->ai_family, p->ai_socktype,
				p->ai_protocol)) == -1) {
			perror("talker: socket");
			continue;
		}

        if(bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
            close(sockfd);
            perror("server: bind");
            continue;
        }

		break;
	}

	if (p == NULL) {
		fprintf(stderr, "talker: failed to create socket\n");
		return 2;
	}

	freeaddrinfo(servinfo); // done with servinfo
	return sockfd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl $0x2, 0x8(%rdx)
leaq 0x901(%rip), %rdi       # 0x2004
leaq -0x28(%rbp), %rcx
callq 0x11f0
testl %eax, %eax
jne 0x1796
movq -0x28(%rbp), %r14
testq %r14, %r14
je 0x1772
leaq 0x94b(%rip), %r15       # 0x206f
leaq 0x90e(%rip), %r12       # 0x2039
movl 0x4(%r14), %edi
movl 0x8(%r14), %esi
movl 0xc(%r14), %edx
callq 0x1220
movq %r15, %rdi
cmpl $-0x1, %eax
je 0x1764
movl %eax, %ebx
movq 0x18(%r14), %rsi
movl 0x10(%r14), %edx
movl %eax, %edi
callq 0x1170
cmpl $-0x1, %eax
jne 0x177e
movl %ebx, %edi
callq 0x1100
movq %r12, %rdi
callq 0x1190
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x172b
callq 0x1315
movl $0x2, %ebx
jmp 0x1787
movq -0x28(%rbp), %rdi
callq 0x1210
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x12e5
movl $0x1, %ebx
jmp 0x1787
// File: /workspace/github_c_makefile_star2_O3/MAGI003769[P]EE450-Socket-Project/aws.c
// Function: check_vtx
int check_vtx(char *source_vtx, char *target_vtx, char *data) {
    int source_flag = 0, target_flag = 0;
    char *end_str;
    char *token = strtok_r(data, "\n", &end_str);
    int i = 0;

    while (token != NULL) {
        char *end_token;
        //printf("debug: check line -- %s\n", token);
        if(i >= 3) {
            char *token2 = strtok_r(token, " ", &end_token);
            int j = 0;
            while (token2 != NULL && j < 2) {
                //printf("debug: check word -- %s\n", token2);
                if(strcmp(token2, source_vtx) == 0) {
                    source_flag = 1;
                } else if(strcmp(token2, target_vtx) == 0) {
                    target_flag = 1;
                }

                if(target_flag == 1 && source_flag == 1) {
                    return 11;
                }

                token2 = strtok_r(NULL, " ", &end_token);
                j++;
            }
        }
        token = strtok_r(NULL, "\n", &end_str);
        i++;
    }
    return (target_flag * 10 + source_flag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rax
movq %rsi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
leaq 0x72d(%rip), %rsi       # 0x205c
leaq -0x48(%rbp), %rdx
movq %rax, %rdi
callq 0x1110
testq %rax, %rax
je 0x1a06
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %r12d, %r12d
cmpl $0x3, %r15d
jb 0x19d8
movq %rax, %rdi
leaq 0xc76(%rip), %rsi       # 0x25d6
leaq -0x40(%rbp), %rdx
callq 0x1110
testq %rax, %rax
je 0x19d8
movq %rax, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movq -0x38(%rbp), %rsi
callq 0x1120
testl %eax, %eax
je 0x199c
movq %r13, %rdi
movq -0x30(%rbp), %rsi
callq 0x1120
testl %eax, %eax
movl $0x1, %eax
cmovel %eax, %ebx
jmp 0x19a2
movl $0x1, %r12d
movl %ebx, %eax
xorl $0x1, %eax
movl %r12d, %ecx
xorl $0x1, %ecx
orl %eax, %ecx
je 0x19ff
xorl %edi, %edi
leaq 0xc1c(%rip), %rsi       # 0x25d6
leaq -0x40(%rbp), %rdx
callq 0x1110
movq %rax, %r13
testq %rax, %rax
setne %al
xorb $0x1, %r14b
testb %r14b, %al
movb $0x1, %r14b
jne 0x1974
xorl %edi, %edi
leaq 0x67b(%rip), %rsi       # 0x205c
leaq -0x48(%rbp), %rdx
callq 0x1110
incl %r15d
testq %rax, %rax
jne 0x194c
leal (%rbx,%rbx,4), %eax
leal (%r12,%rax,2), %eax
jmp 0x1a08
movl $0xb, %eax
jmp 0x1a08
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl %esi, %eax
movq %rdi, %rbx
movq 0x3279c(%rip), %rsi     # 0x6fb48
testq %rsi, %rsi
jne 0x3d3ec
cmpl $0x1, %eax
sete %cl
testq %rbx, %rbx
sete %dl
movl $0x1, %eax
orb %cl, %dl
jne 0x3d43e
leaq 0x5c93(%rip), %r14      # 0x43060
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d150
testl %eax, %eax
leaq 0x5c84(%rip), %rsi      # 0x43065
cmoveq %r14, %rsi
movq %rsi, 0x3275c(%rip)     # 0x6fb48
leaq 0x5c77(%rip), %rdi      # 0x4306a
callq 0x3d150
testl %eax, %eax
jne 0x3d40f
testq %rbx, %rbx
leaq 0x6304(%rip), %rdi      # 0x4370a
cmovneq %rbx, %rdi
callq 0x3d070
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3d0b0
testq %rax, %rax
je 0x3d424
movb $0x0, (%rax)
movq 0x3271d(%rip), %rdi     # 0x6fb48
movq %rbx, %rsi
callq 0x3d1d0
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_O3/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 0x32703(%rip), %rsi     # 0x6fb50
testq %rsi, %rsi
je 0x3d4aa
pushq %rbx
testq %rdi, %rdi
leaq 0x62ad(%rip), %rbx      # 0x4370a
cmovneq %rdi, %rbx
leaq 0x5c02(%rip), %rdi      # 0x4306a
callq 0x3d150
testl %eax, %eax
jne 0x3d479
movq %rbx, %rdi
callq 0x3d070
movq %rbx, %rdi
movl $0x20, %esi
callq 0x3d0b0
testq %rax, %rax
je 0x3d48e
movb $0x0, (%rax)
movq 0x326bb(%rip), %rdi     # 0x6fb50
movq %rbx, %rsi
callq 0x3d1d0
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
setne %al
popq %rbx
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
movl 0x3269d(%rip), %eax     # 0x6fb58
leal 0x1(%rax), %ecx
movl %ecx, 0x32694(%rip)     # 0x6fb58
movq 0x32695(%rip), %r14     # 0x6fb60
testq %r14, %r14
je 0x3d52f
movq %rdi, %rbx
leaq 0x5b90(%rip), %rdi      # 0x4306a
movq %r14, %rsi
callq 0x3d150
testl %eax, %eax
jne 0x3d4f5
movq %rbx, %rdi
callq 0x3d070
movq 0x3266b(%rip), %r14     # 0x6fb60
movzbl (%r14), %r15d
testq %r15, %r15
je 0x3d520
callq 0x3d1e0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r15,2)
je 0x3d520
movq %r14, %rdi
callq 0x3d1a0
movb $0x1, %cl
cmpl 0x3263a(%rip), %eax     # 0x6fb58
je 0x3d534
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d150
testl %eax, %eax
jmp 0x3d531
testl %eax, %eax
sete %cl
movzbl %cl, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x32615(%rip), %r15     # 0x6fb68
testq %r15, %r15
je 0x3d567
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3d150
testl %eax, %eax
je 0x3d5ac
movq $0x0, 0x325f6(%rip) # 0x6fb68
xorl %r12d, %r12d
leaq 0x2cba4(%rip), %r13     # 0x6a120
xorl %r15d, %r15d
movq (%r12,%r13), %rsi
movq %r14, %rdi
callq 0x3d150
testl %eax, %eax
jne 0x3d59a
leaq (%r12,%r13), %r15
movq %r15, 0x325ce(%rip)     # 0x6fb68
addq $0x10, %r12
cmpq $0x1e0, %r12            # imm = 0x1E0
jne 0x3d57f
testq %r15, %r15
je 0x3d5c5
movq 0x8(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3d1d0
testq %rax, %rax
je 0x3d5c5
subl %r14d, %eax
jmp 0x3d5ca
movl $0x3e8, %eax            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x32595(%rip)     # 0x6fb70
je 0x3d5de
retq
pushq %rbx
movq %rdi, %rbx
movq 0x3258f(%rip), %rsi     # 0x6fb78
testq %rsi, %rsi
je 0x3d5fc
leaq 0x5a7e(%rip), %rdi      # 0x43073
xorl %eax, %eax
callq 0x3d0c0
movq 0x3257d(%rip), %rsi     # 0x6fb80
testq %rsi, %rsi
je 0x3d623
leaq 0x5a60(%rip), %rdi      # 0x4306f
xorl %eax, %eax
callq 0x3d0c0
cmpq $0x0, 0x32562(%rip)     # 0x6fb80
sete %al
jmp 0x3d625
movb $0x1, %al
testq %rbx, %rbx
je 0x3d644
testb %al, %al
je 0x3d644
cmpb $0x0, (%rbx)
je 0x3d644
leaq 0x5a35(%rip), %rdi      # 0x4306f
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3d0c0
movq 0x3253d(%rip), %rsi     # 0x6fb88
testq %rsi, %rsi
je 0x3d65e
leaq 0x5a25(%rip), %rdi      # 0x4307c
xorl %eax, %eax
callq 0x3d0c0
callq 0x3e278
cmpl $0x0, 0x32526(%rip)     # 0x6fb90
je 0x3d678
leaq 0x605f(%rip), %rdi      # 0x436d2
callq 0x3d070
popq %rbx
jmp 0x3e2bb
// File: /workspace/github_c_makefile_star2_O3/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 0x3e4f0
movq %rax, 0x318c5(%rip)     # 0x6fbb0
movl $0x10b9, %edi           # imm = 0x10B9
callq 0x3e740
movq %rax, 0x358c4(%rip)     # 0x73bc0
movl $0x8, %ebx
leaq 0x19078(%rip), %r14     # 0x57380
movq 0x358b1(%rip), %rdi     # 0x73bc0
movq -0x8(%rbx,%r14), %rsi
movq (%rbx,%r14), %rdx
callq 0x3e7d5
addq $0x10, %rbx
cmpq $0x10b98, %rbx          # imm = 0x10B98
jne 0x3e308
movl $0x161, %edi            # imm = 0x161
callq 0x3e740
movq %rax, 0x3187d(%rip)     # 0x6fbb8
xorl %ebx, %ebx
leaq 0x2bfbc(%rip), %r14     # 0x6a300
movq 0x3186d(%rip), %rdi     # 0x6fbb8
leaq (%rbx,%r14), %rdx
addq $0x8, %rdx
movq -0x8(%rdx), %rsi
callq 0x3e7d5
addq $0x40, %rbx
cmpq $0x5840, %rbx           # imm = 0x5840
jne 0x3e344
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31837(%rip), %rdi     # 0x6fbb0
callq 0x3e5a0
movq 0x31833(%rip), %rdi     # 0x6fbb8
callq 0x3e7ae
movq 0x3582f(%rip), %rdi     # 0x73bc0
testq %rdi, %rdi
je 0x3e39c
popq %rax
jmp 0x3e7ae
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e430
movl %esi, %ecx
shrl $0x6, %ecx
orb $-0x40, %cl
movb %cl, (%rax)
movl $0x1, %eax
leal (%rax,%rax,2), %eax
leal -0x6(,%rax,2), %ecx
movl %esi, %eax
sarl %cl, %eax
andb $0x3f, %al
orb $-0x80, %al
movq (%rdi), %rdx
leaq 0x1(%rdx), %r8
movq %r8, (%rdi)
movb %al, (%rdx)
addl $-0x6, %ecx
cmpl $-0x6, %ecx
jne 0x3e40d
movq (%rdi), %rax
movb $0x0, (%rax)
retq
testl %esi, %esi
movl $0x20, %ecx
cmovgl %esi, %ecx
movb %cl, (%rax)
jmp 0x3e429
// File: /workspace/github_c_makefile_star2_O3/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 0x3e49f
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl %esi, %r12d
xorl %r15d, %r15d
leaq 0x52f8(%rip), %r14      # 0x43752
xorl %ebp, %ebp
movsbl (%rbx,%r15), %esi
testl %esi, %esi
je 0x3e48a
movl $0x11, %edx
movq %r14, %rdi
callq 0x3d110
testq %rax, %rax
je 0x3e48a
shll $0x4, %ebp
subl %r14d, %ebp
addl %eax, %ebp
incq %r15
cmpq %r15, %r12
jne 0x3e45c
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_O3/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
movq (%rdi), %rax
testq %rax, %rax
jne 0x3e51b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x3e528
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movb $0x0, (%rax,%rcx)
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d180
movq %rax, (%r14)
movslq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x3e554
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3d170
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d030
// File: /workspace/github_c_makefile_star2_O3/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), %eax
movl 0xc(%rdi), %esi
leal (%rbx,%rax), %ecx
incl %ecx
cmpl %esi, %ecx
jl 0x3e639
leal 0x1(%rbx), %eax
addl %esi, %eax
addl %esi, %esi
cmpl %eax, %esi
cmovlel %eax, %esi
addl $0x7f, %esi
andl $-0x80, %esi
movq %r14, %rdi
callq 0x3e528
movl 0x8(%r14), %eax
movslq %eax, %rdi
addq (%r14), %rdi
movslq %ebx, %rdx
movq %r15, %rsi
callq 0x3d170
addl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x1, %edi
movl $0x420, %esi            # imm = 0x420
callq 0x3d140
movq %rax, %rbx
movslq %ebp, %r14
leaq (,%r14,8), %r15
movq %r15, %rdi
callq 0x3d180
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x3d180
movq %rax, 0x8(%rbx)
shlq $0x2, %r14
movq %r14, %rdi
callq 0x3d180
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_O3/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 0x3e852
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 0x3e844
movq %r15, %rdi
callq 0x3d150
testl %eax, %eax
je 0x3e856
movq 0x18(%r14), %rax
movl (%rax,%r13,4), %eax
testl %eax, %eax
jns 0x3e82b
jmp 0x3e85e
xorl %ebx, %ebx
jmp 0x3e85e
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
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x3d1e0
testb %bpl, %bpl
je 0x3ef2d
cmpb $0x3b, %bpl
je 0x3ef2d
movq (%rax), %rcx
movsbq %bpl, %rdx
movzwl (%rcx,%rdx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
jne 0x3ef2d
movb %bpl, (%r14)
incq %r14
movb 0x1(%rbx), %bpl
incq %rbx
jmp 0x3ef00
movq (%rax), %rax
decq %rbx
movsbq 0x1(%rbx), %rcx
incq %rbx
cmpq $0x3b, %rcx
je 0x3ef33
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
jne 0x3ef33
movb $0x0, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x4191b
movq %rsi, %r14
movq %rdi, %rbx
rolw $0x8, %ax
addq $0xc, %r15
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %r13d
xorl %r12d, %r12d
movl $0x4, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d050
testl %eax, %eax
je 0x41920
addq $0x10, %r15
decq %r13
jne 0x418fc
jmp 0x4192a
xorl %r12d, %r12d
jmp 0x4192a
movl 0x8(%r15), %r12d
bswapl %r12d
addq (%rbx), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e4f0
movq %rax, %rbx
movq %rsp, %rsi
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
callq 0x3d120
testl %eax, %eax
jle 0x41983
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x3e5ff
movl $0x1000, %edx           # imm = 0x1000
xorl %edi, %edi
movq %r14, %rsi
callq 0x3d120
testl %eax, %eax
jg 0x41963
movq %rbx, %rdi
callq 0x3e563
movq %rax, %rbx
movl (%rax), %eax
bswapl %eax
cmpl $0x10000, %eax          # imm = 0x10000
je 0x419ad
cmpl $0x74746366, %eax       # imm = 0x74746366
je 0x419bd
movl $0x1, %r14d
cmpl $0x4f54544f, %eax       # imm = 0x4F54544F
jne 0x419ee
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3ef5c
movl %eax, %r14d
jmp 0x419ee
movl 0x8(%rbx), %eax
bswapl %eax
testl %eax, %eax
jle 0x419eb
movl %eax, %r15d
xorl %r14d, %r14d
xorl %r12d, %r12d
movl 0xc(%rbx,%r12,4), %esi
bswapl %esi
addq %rbx, %rsi
movq %rbx, %rdi
callq 0x3ef5c
incq %r12
cmpq %r12, %r15
jne 0x419cf
jmp 0x419ee
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_O3/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 $0x0, (%rsp)
testl %esi, %esi
jle 0x41a76
movl %esi, %ebp
movq %rdi, %r14
xorl %r13d, %r13d
movq %rsp, %rbx
xorl %r15d, %r15d
movl %r13d, %r12d
movq %r14, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq 0x41c1b
movl %eax, %r13d
addl %r12d, %r13d
movl (%rsp), %eax
cmpl $0xc, %eax
jne 0x41a65
movq %r14, %rdi
movl %r13d, %esi
movq %rbx, %rdx
callq 0x41c1b
addl %eax, %r13d
movl (%rsp), %eax
movl $0x4b0, %ecx            # imm = 0x4B0
addl %ecx, %eax
movl %eax, (%rsp)
cmpl 0x4(%rsp), %eax
je 0x41a79
movl %eax, %r15d
cmpl %ebp, %r13d
movq %rsp, %rbx
jl 0x41a28
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15d
cmpl $0x186, %esi            # imm = 0x186
jg 0x41b6f
movslq %r15d, %rax
leaq 0x27647(%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, %r15d      # imm = 0xFFFFFE79
movl %r15d, %esi
callq 0x41a8b
movl %eax, %ebp
leaq 0x2e016(%rip), %rax     # 0x6fba0
cmpl $0x0, (%rax)
setne %al
cmpl $0x40, %ebp
setge %cl
andb %al, %cl
cmpb $0x1, %cl
je 0x41c14
cmpl $0x3f, %ebp
movl $0x3f, %eax
cmovll %ebp, %eax
movzwl (%r14), %esi
movzbl 0x2(%r14), %ecx
xorl %edx, %edx
testl %ecx, %ecx
je 0x41bdf
imull %ecx, %r15d
movl %ecx, %edi
leaq (%r14,%r15), %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 0x41bc8
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 0x3d170
movb $0x0, (%rbx,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3d239
jmp 0x41b9d
// File: /workspace/github_c_makefile_star2_O3/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, %rsi
movzbl (%rdi,%rsi), %ecx
leal -0x20(%rcx), %eax
cmpb $-0x2a, %al
ja 0x41c36
addl $0xffffff75, %ecx       # imm = 0xFFFFFF75
movl $0x1, %eax
jmp 0x41c6c
leal 0x9(%rcx), %eax
cmpb $0x3, %al
ja 0x41c4f
shll $0x8, %ecx
movzbl 0x1(%rdi,%rsi), %eax
addl %eax, %ecx
addl $0xffff096c, %ecx       # imm = 0xFFFF096C
jmp 0x41c67
leal 0x5(%rcx), %eax
cmpb $0x3, %al
ja 0x41c6f
shll $0x8, %ecx
movzbl 0x1(%rdi,%rsi), %eax
orl %ecx, %eax
movl $0xfa94, %ecx           # imm = 0xFA94
subl %eax, %ecx
movl $0x2, %eax
movl %ecx, (%rdx)
retq
cmpl $0x1c, %ecx
je 0x41cc1
cmpl $0x1d, %ecx
je 0x41cb4
movl $0x1, %eax
cmpl $0x1e, %ecx
jne 0x41c6c
addq %rsi, %rdi
movl $0x1, %esi
movzbl (%rdi,%rsi), %eax
movl %eax, %ecx
notl %ecx
testb $0xf, %cl
je 0x41cd4
andl $-0x10, %eax
cmpl $0xf0, %eax
je 0x41cd4
incq %rsi
movl $0x21, %eax
xorl %ecx, %ecx
cmpq $0x20, %rsi
jne 0x41c8b
jmp 0x41c6c
movl 0x1(%rdi,%rsi), %ecx
bswapl %ecx
movl $0x5, %eax
jmp 0x41c6c
movzwl 0x1(%rdi,%rsi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
movl $0x3, %eax
jmp 0x41c6c
incl %esi
xorl %ecx, %ecx
movl %esi, %eax
jmp 0x41c6c
// File: /workspace/github_c_makefile_star2_O3/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 0x119a(%rip), %rcx      # 0x43060
cmovneq %rdi, %rcx
leaq 0x5b1d1f(%rip), %r14    # 0x5f3bf0
leaq 0x12eba(%rip), %rsi     # 0x54d92
movq %r14, %rdi
xorl %eax, %eax
callq 0x3d1b0
cmpb $0x0, 0x8(%rbx)
je 0x41f12
addq $0x8, %rbx
movq %r14, %rdi
callq 0x3d0a0
addq %rax, %r14
leaq 0x12e96(%rip), %rsi     # 0x54d94
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d1b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x42281
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 0x42748
movq %rax, 0x8(%rsp)
movzwl 0x4(%r15), %eax
testw %ax, %ax
je 0x42269
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x10(%rsp)
leaq 0x31a5a(%rip), %r14     # 0x73be0
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 0x42257
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 0x421e1
movl 0xc0(%rbx), %eax
movl 0xc8(%rbx), %ecx
addl 0xc4(%rbx), %eax
leal (%rcx,%rax), %edx
incl %edx
jmp 0x421e6
movl $0x2, %edx
leaq 0x12bab(%rip), %rdi     # 0x54d98
leaq 0x5b19fc(%rip), %rsi    # 0x5f3bf0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x42828
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 0x12b76(%rip), %rdi     # 0x54da3
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4289c
movl $0xa, %edi
callq 0x3d040
incq %r15
cmpq %r15, %rbp
jne 0x421c3
incq %r12
cmpq 0x10(%rsp), %r12
movq (%rsp), %r15
jne 0x4218d
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_O3/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 0x42474
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 0x42748
movq %rax, 0x10(%rsp)
movzwl 0x4(%r14), %eax
testw %ax, %ax
je 0x4245c
rolw $0x8, %ax
cmpw $0x2, %ax
movl $0x1, %ecx
cmovael %eax, %ecx
movzwl %cx, %eax
movq %rax, 0x20(%rsp)
leaq 0x318f8(%rip), %r13     # 0x73be0
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 0x42449
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 0x42370
movl 0xc0(%rbx), %eax
subl %ebp, %eax
addl 0xc4(%rbx), %eax
addl 0xc8(%rbx), %eax
jmp 0x42372
xorl %eax, %eax
addq %rdx, %r15
leal 0x1(%rbp), %edx
addl %eax, %edx
leaq 0x12a17(%rip), %rdi     # 0x54d98
leaq 0x5b1868(%rip), %rsi    # 0x5f3bf0
xorl %eax, %eax
callq 0x3d0c0
movq %rbx, %rdi
callq 0x42828
movq 0x10(%rsp), %rax
movslq (%rax,%r12,4), %rsi
shlq $0x6, %rsi
addq %r13, %rsi
leaq 0x12a04(%rip), %rbx     # 0x54db2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3d0c0
movq %rbp, 0x18(%rsp)
cmpw $0x2, %bp
jb 0x423f6
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 0x423d1
movzwl (%r15), %eax
rolw $0x8, %ax
movzwl %ax, %esi
shll $0x6, %esi
addq %r13, %rsi
leaq 0x12999(%rip), %rdi     # 0x54da7
xorl %eax, %eax
callq 0x3d0c0
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x4289c
movl $0xa, %edi
callq 0x3d040
incq %r14
cmpq 0x30(%rsp), %r14
movq 0x40(%rsp), %r12
movq 0x38(%rsp), %rdx
jne 0x4233a
incq %r12
cmpq 0x20(%rsp), %r12
movq 0x8(%rsp), %r14
jne 0x422f5
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_O3/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 $0x28, %rsp
movl %r9d, %eax
movq %r8, %rbx
movq %rcx, %r8
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movzwl 0x6(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %ebp
addq %rdi, %rbp
movzwl 0x2(%rsi), %ecx
movzwl 0x4(%rsi), %r14d
cmpw $-0x1, %cx
movq %r8, 0x10(%rsp)
je 0x424f4
rolw $0x8, %cx
movzwl %cx, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x2(%rbp,%rcx,2), %esi
movzwl 0x6(%rbp,%rcx,2), %edx
movl %eax, (%rsp)
movq %r13, %rdi
movq %r15, %rcx
movq %rbx, %r9
callq 0x425d9
testw %r14w, %r14w
je 0x4255f
rolw $0x8, %r14w
cmpw $0x2, %r14w
movl $0x1, %ecx
cmovael %r14d, %ecx
movq %rbx, 0x20(%rsp)
movzwl %cx, %ecx
movq %rcx, 0x18(%rsp)
movq %r12, %rbx
movq 0x10(%rsp), %r12
xorl %r14d, %r14d
movzwl 0x6(%rbx,%r14,2), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq (%rcx,%rcx,2), %rcx
movl 0x2(%rbp,%rcx,2), %esi
movzwl 0x6(%rbp,%rcx,2), %edx
movl %eax, (%rsp)
movq %r13, %rdi
movq %r15, %rcx
movq %r12, %r8
movq 0x20(%rsp), %r9
callq 0x425d9
incq %r14
cmpq %r14, 0x18(%rsp)
jne 0x42525
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3d150
movl %eax, %ebp
testl %eax, %eax
jne 0x425ce
leaq 0x10(%rbx), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d53d
movl %eax, %ebp
leaq 0x10(%r14), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d53d
cmpl %eax, %ebp
jne 0x425b4
movl 0x18(%rbx), %ebp
subl 0x18(%r14), %ebp
jmp 0x425ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d53d
movl %eax, %ebp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3d53d
subl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq %r8, 0x28(%rsp)
movq %rcx, %r15
movl 0x70(%rsp), %eax
movzwl 0x6(%rdi), %ecx
rolw $0x8, %cx
movzwl %cx, %r8d
addq %rdi, %r8
rolw $0x8, %dx
movzwl %dx, %ecx
movq $0x0, 0x8(%rsp)
movzwl 0x2(%rcx,%r8), %edx
movl %esi, 0x8(%rsp)
testw %dx, %dx
je 0x42739
addq %rcx, %r8
rolw $0x8, %dx
cmpw $0x2, %dx
movl $0x1, %ecx
cmovael %edx, %ecx
movzwl %cx, %ecx
movq %rcx, 0x30(%rsp)
movq %r9, 0x20(%rsp)
leaq 0x10(%r9), %rcx
movq %rcx, 0x18(%rsp)
xorl %r12d, %r12d
movq %r8, 0x10(%rsp)
movl %eax, %r14d
movl $0x0, %ebx
testl %eax, %eax
movl %eax, 0x4(%rsp)
jle 0x426ba
movzwl 0x4(%r8,%r12,2), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
movq 0x18(%rsp), %r13
xorl %ebx, %ebx
cmpl %ebp, 0x8(%r13)
jne 0x426a8
cmpb $0x0, -0x8(%r13)
jne 0x426a8
leaq -0x10(%r13), %rdi
movq %r15, %rsi
callq 0x3d150
testl %eax, %eax
jne 0x426a8
movq %r13, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3d150
testl %eax, %eax
je 0x426b6
incq %rbx
addq $0x1c, %r13
cmpq %rbx, %r14
jne 0x4267a
jmp 0x426be
movl 0x4(%rsp), %eax
cmpl %eax, %ebx
jne 0x42722
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rbx
addq %r14, %rbx
movq 0x20(%rsp), %r14
leaq (%r14,%rbx), %r13
leaq (%r14,%rbx), %rdi
addq $0x10, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3d060
movq %r13, %rdi
movq %r15, %rsi
callq 0x3d060
leaq (%r14,%rbx), %r13
addq $0x8, %r13
movq %r13, %rdi
movq 0x28(%rsp), %rsi
callq 0x3d060
movq 0x10(%rsp), %r8
movzwl 0x4(%r8,%r12,2), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x10(%r13)
movl 0x4(%rsp), %eax
incl %eax
jmp 0x4272b
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %r8
incq %r12
cmpq 0x30(%rsp), %r12
jne 0x42656
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x31466(%rip), %edi     # 0x73bd4
shlq $0x2, %rdi
callq 0x3d180
xorl %ecx, %ecx
cmpl $0x100, %r12d           # imm = 0x100
jne 0x427af
testw %bp, %bp
je 0x42816
cmpl $0x1, %r15d
movl %r15d, %ecx
adcl $0x0, %ecx
xorl %edx, %edx
movzwl 0x4(%r14,%rdx,2), %esi
rolw $0x8, %si
movzwl %si, %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x42797
movzwl %r12w, %edx
cmpl $0x200, %edx            # imm = 0x200
jne 0x42818
testw %bp, %bp
je 0x42818
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 0x4280c
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 0x427ff
incq %rdx
cmpq %r15, %rdx
jne 0x427ca
jmp 0x42818
xorl %ecx, %ecx
testq %rbx, %rbx
je 0x4281f
movl %ecx, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq