LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lukexi[P]eglstreams-mini/acquire-thread-one.c
// Function: AcquireThreadMain
void* AcquireThreadMain(void* Arg) {
    egl_state* EGL = Arg;

    while (1) {
        for (int DisplayIndex = 0; DisplayIndex < EGL->DisplaysCount; DisplayIndex++) {
            egl_display* Display = &EGL->Displays[DisplayIndex];
            if (Display->PageFlipPending) {
                continue;
            }
            EGLint StreamState = EGLQueryStreamState(Display->DisplayDevice, Display->Stream);
            if (StreamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
                NEWTIME(StreamAcquire);
                EGLStreamAcquire(Display);
                ENDTIME(StreamAcquire);
            }
        }

    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x25e4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x256d
jmp 0x25d6
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x3d70
movl %eax, -0x24(%rbp)
cmpl $0x3218, -0x24(%rbp)    # imm = 0x3218
jne 0x25d4
movb $0x0, %al
callq 0x4e40
movss %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x34c0
movb $0x0, %al
callq 0x4e40
subss -0x28(%rbp), %xmm0
movss 0x3a4d(%rip), %xmm1     # 0x6004
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x3a6a(%rip), %rdi      # 0x6030
leaq 0x3a76(%rip), %rsi      # 0x6043
movb $0x1, %al
callq 0x2050
jmp 0x25d6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x253b
jmp 0x2534
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/main.c
// Function: usage
static void usage(int rv) {
	fputs(
		"nroff.man [-bih] [-W level] [-I os=name] [-t terminal] [-T output] [file ...]\n"
		" -t terminal   set terminal type\n"
		" -T output     set output type (termcap, ascii, plain)\n"
		" -h            help\n",

		stdout);


	exit(rv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x9a5e(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
leaq 0x6bd6(%rip), %rdi      # 0xb142
callq 0x40c0
movl -0x4(%rbp), %edi
callq 0x4190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/main.c
// Function: parseT
static int parseT(const char *arg) {
	/* */
	if (!arg || !*arg) return -1;
	if (arg[0] == 't' && !strcmp(arg, "termcap")) return FMT_TERMCAP;
	if (arg[0] == 'a' && !strcmp(arg, "ascii")) return FMT_ASCII;
	if (arg[0] == 'p' && !strcmp(arg, "plain")) return FMT_PLAIN;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x459c
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x45a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x462d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0x45d2
movq -0x10(%rbp), %rdi
leaq 0x6c3e(%rip), %rsi      # 0xb1fd
callq 0x4100
cmpl $0x0, %eax
jne 0x45d2
movl $0x0, -0x4(%rbp)
jmp 0x462d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
jne 0x45fc
movq -0x10(%rbp), %rdi
leaq 0x6c1c(%rip), %rsi      # 0xb205
callq 0x4100
cmpl $0x0, %eax
jne 0x45fc
movl $0x1, -0x4(%rbp)
jmp 0x462d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x4626
movq -0x10(%rbp), %rdi
leaq 0x6bf8(%rip), %rsi      # 0xb20b
callq 0x4100
cmpl $0x0, %eax
jne 0x4626
movl $0x2, -0x4(%rbp)
jmp 0x462d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read1.c
// Function: read_init
void read_init(FILE *fp, const char *name) {
	int i;

	type = fp ? tkTEXT : tkEOF;
	argc = 0;
	argv[0] = NULL;

	cc = '.';
	c2 = '\'';
	ec = '\\';

	ad = 'b'; 
	fi = 1;
	na = 0;
	hy = 1;
	ns = 0;

	ti = -1;
	in = prev_in = 0;
	ll = prev_ll = 78;
	ft = prev_ft = FONT_R;
	width = 78;
	line = 1;
	ignore = 0;

	render_init();


	for (i = 0; i <= so_index; ++i) free(so_entries[i].name);
	for (i = 1; i <= so_index; ++i) fclose(so_entries[i].fp);
	so_index = -1;

	if (fp) {
		so_index = 0;
		so_entries[0].fp = fp;
		so_entries[0].name = strdup(name);
		so_entries[0].line = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, 0x9af8(%rip)      # 0xe310
movl $0x0, 0xba9e(%rip)      # 0x102c0
movq $0x0, 0xcaf3(%rip) # 0x11320
movb $0x2e, 0x9b08(%rip)     # 0xe33c
movb $0x27, 0x9b02(%rip)     # 0xe33d
movb $0x5c, 0x9afc(%rip)     # 0xe33e
movl $0x62, 0x9ac8(%rip)     # 0xe314
movl $0x1, 0x9ac2(%rip)      # 0xe318
movl $0x0, 0xba64(%rip)      # 0x102c4
movl $0x1, 0x9ab2(%rip)      # 0xe31c
movl $0x0, 0xba54(%rip)      # 0x102c8
movl $0xffffffff, 0x9aaa(%rip) # imm = 0xFFFFFFFF
movl $0x0, 0xba48(%rip)      # 0x102d0
movl $0x0, 0xba3a(%rip)      # 0x102cc
movl $0x4e, 0x9a94(%rip)     # 0xe330
movl $0x4e, 0x9a86(%rip)     # 0xe32c
movl $0x83, 0x9a74(%rip)     # 0xe324
movl $0x83, 0x9a66(%rip)     # 0xe320
movl $0x4e, 0x9a70(%rip)     # 0xe334
movl $0x1, 0x9a6a(%rip)      # 0xe338
movl $0x0, 0xb9fc(%rip)      # 0x102d4
callq 0x89c0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x9a53(%rip), %eax      # 0xe340
jg 0x4915
movslq -0x14(%rbp), %rcx
leaq 0xca76(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x4040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x48e4
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x9a1b(%rip), %eax      # 0xe340
jg 0x494c
movslq -0x14(%rbp), %rcx
leaq 0xca3e(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x4090
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x491c
movl $0xffffffff, 0x99ea(%rip) # imm = 0xFFFFFFFF
cmpq $0x0, -0x8(%rbp)
je 0x498c
movl $0x0, 0x99d9(%rip)      # 0xe340
movq -0x8(%rbp), %rax
movq %rax, 0xc9fe(%rip)      # 0x11370
movq -0x10(%rbp), %rdi
callq 0x41a0
movq %rax, 0xc9f6(%rip)      # 0x11378
movl $0x0, 0xc9f4(%rip)      # 0x11380
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read1.c
// Function: man_warnc
void man_warnc(int e, const char *msg) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fputs(msg, stderr);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x995a(%rip)      # 0xe340
jl 0x4a31
movq 0x9609(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movslq 0x9947(%rip), %rcx      # 0xe340
leaq 0xc970(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movslq 0x992e(%rip), %rcx      # 0xe340
leaq 0xc957(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
leaq 0x711f(%rip), %rsi      # 0xbb49
movb $0x0, %al
callq 0x4110
movq -0x10(%rbp), %rdi
movq 0x95bc(%rip), %rax      # 0xdff8
movq (%rax), %rsi
callq 0x40c0
cmpl $0x0, -0x4(%rbp)
je 0x4a7a
movq 0x95a7(%rip), %rax      # 0xdff8
movq (%rax), %rsi
leaq 0x70f3(%rip), %rdi      # 0xbb4e
callq 0x40c0
movl -0x4(%rbp), %edi
callq 0x41b0
movq %rax, %rdi
movq 0x9586(%rip), %rax      # 0xdff8
movq (%rax), %rsi
callq 0x40c0
movq 0x9577(%rip), %rax      # 0xdff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x40e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read1.c
// Function: man_warnc1s
void man_warnc1s(int e, const char *msg, const char *s) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fprintf(stderr, msg, s);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, 0x9856(%rip)      # 0xe340
jl 0x4b35
movq 0x9505(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movslq 0x9843(%rip), %rcx      # 0xe340
leaq 0xc86c(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movslq 0x982a(%rip), %rcx      # 0xe340
leaq 0xc853(%rip), %rax      # 0x11370
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
leaq 0x701b(%rip), %rsi      # 0xbb49
movb $0x0, %al
callq 0x4110
movq 0x94bc(%rip), %rax      # 0xdff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb $0x0, %al
callq 0x4110
cmpl $0x0, -0x4(%rbp)
je 0x4b84
movq 0x949d(%rip), %rax      # 0xdff8
movq (%rax), %rsi
leaq 0x6fe9(%rip), %rdi      # 0xbb4e
callq 0x40c0
movl -0x4(%rbp), %edi
callq 0x41b0
movq %rax, %rdi
movq 0x947c(%rip), %rax      # 0xdff8
movq (%rax), %rsi
callq 0x40c0
movq 0x946d(%rip), %rax      # 0xdff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x40e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read2.c
// Function: font
static unsigned char *font(unsigned f) {
	int i,j,k;
	uint_fast8_t c;

	buffer[0] = f;

	type = tkTEXT;
	for(i = 0, j = 1; i <argc; ++i) {
		const unsigned char *cp = argv[i];
		if (i > 0) buffer[j++] = ' ';
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}
	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movb %al, 0xa5b0(%rip)       # 0x113d0
leaq 0x74e9(%rip), %rax      # 0xe310
movl $0x1, (%rax)
movl $0x0, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %eax
leaq 0x947b(%rip), %rcx      # 0x102c0
cmpl (%rcx), %eax
jge 0x6ecf
movslq -0x8(%rbp), %rcx
leaq 0xa4c8(%rip), %rax      # 0x11320
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x6e7f
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xa555(%rip), %rax      # 0x113d0
movb $0x20, (%rax,%rcx)
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0x6ebf
movb -0x11(%rbp), %dl
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xa516(%rip), %rax      # 0x113d0
movb %dl, (%rax,%rcx)
jmp 0x6e86
jmp 0x6ec1
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6e3b
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xa4ec(%rip), %rax      # 0x113d0
movb $-0x7d, (%rax,%rcx)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xa4d3(%rip), %rax      # 0x113d0
movb $0x0, (%rax,%rcx)
leaq 0xa4c8(%rip), %rax      # 0x113d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read2.c
// Function: fonts
static unsigned char *fonts(unsigned f1, unsigned f2) {
	unsigned i,j,k;
	uint_fast8_t c;

	type = tkTEXT;
	for (i = 0, j = 0; i < argc; ++i) {
		const unsigned char *cp = argv[i];
		buffer[j++] = i & 0x01 ? f2 : f1;
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}

	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x73ef(%rip), %rax      # 0xe310
movl $0x1, (%rax)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
leaq 0x9381(%rip), %rcx      # 0x102c0
cmpl (%rcx), %eax
jae 0x6fe2
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xa3cd(%rip), %rax      # 0x11320
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6f6e
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x6f74
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0xa441(%rip), %rax      # 0x113d0
movb %dl, (%rax,%rcx)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
cmpb $0x0, %al
je 0x6fd2
movb -0x15(%rbp), %dl
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0xa403(%rip), %rax      # 0x113d0
movb %dl, (%rax,%rcx)
jmp 0x6f99
jmp 0x6fd4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6f35
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0xa3d8(%rip), %rax      # 0x113d0
movb $-0x7d, (%rax,%rcx)
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0xa3be(%rip), %rax      # 0x113d0
movb $0x0, (%rax,%rcx)
leaq 0xa3b3(%rip), %rax      # 0x113d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read2.c
// Function: font_first_word
static unsigned char *font_first_word(unsigned f) {
	int i,j,k;
	uint_fast8_t c;

	if (!argc) return buffer;

	buffer[0] = f;

	type = tkTEXT;
	for(i = 0, j = 1; i <argc; ++i) {
		const unsigned char *cp = argv[i];
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
		if (i == 0) buffer[j++] = FONT_R;
	}
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
leaq 0x9292(%rip), %rax      # 0x102c0
cmpl $0x0, (%rax)
jne 0x7043
leaq 0xa396(%rip), %rax      # 0x113d0
movq %rax, -0x8(%rbp)
jmp 0x711f
movl -0xc(%rbp), %eax
movb %al, 0xa384(%rip)       # 0x113d0
leaq 0x72bd(%rip), %rax      # 0xe310
movl $0x1, (%rax)
movl $0x0, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x10(%rbp), %eax
leaq 0x924f(%rip), %rcx      # 0x102c0
cmpl (%rcx), %eax
jge 0x70fb
movslq -0x10(%rbp), %rcx
leaq 0xa29c(%rip), %rax      # 0x11320
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
cmpb $0x0, %al
je 0x70cc
movb -0x19(%rbp), %dl
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xa309(%rip), %rax      # 0x113d0
movb %dl, (%rax,%rcx)
jmp 0x7093
cmpl $0x0, -0x10(%rbp)
jne 0x70eb
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xa2e9(%rip), %rax      # 0x113d0
movb $-0x7d, (%rax,%rcx)
jmp 0x70ed
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7067
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %eax, %rcx
leaq 0xa2c0(%rip), %rax      # 0x113d0
movb $0x0, (%rax,%rcx)
leaq 0xa2b5(%rip), %rax      # 0x113d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read3.c
// Function: at
static void at(void) {
	char *cp = NULL;

	switch(get_int(argv[0])) {
		default:
		case 3: cp = "7th Edition"; break;
		case 4: cp = "System III"; break;
		case 5:
			if (argc == 2 && get_int(argv[1]) == 2)
				cp = "System V Release 2";
			else cp = "System V Release";
	}
	if (th_source) free(th_source);
	th_source = strdup(cp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
leaq 0x91e9(%rip), %rax      # 0x11320
movq (%rax), %rdi
callq 0x75a0
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
subl $0x3, %eax
je 0x8161
jmp 0x814b
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x816e
jmp 0x8155
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x817b
jmp 0x815f
jmp 0x8161
leaq 0x3d88(%rip), %rax      # 0xbef0
movq %rax, -0x8(%rbp)
jmp 0x81b6
leaq 0x3d87(%rip), %rax      # 0xbefc
movq %rax, -0x8(%rbp)
jmp 0x81b6
leaq 0x813e(%rip), %rax      # 0x102c0
cmpl $0x2, (%rax)
jne 0x81a9
leaq 0x9192(%rip), %rax      # 0x11320
movq 0x8(%rax), %rdi
callq 0x75a0
cmpl $0x2, %eax
jne 0x81a9
leaq 0x3d64(%rip), %rax      # 0xbf07
movq %rax, -0x8(%rbp)
jmp 0x81b4
leaq 0x3d6a(%rip), %rax      # 0xbf1a
movq %rax, -0x8(%rbp)
jmp 0x81b6
cmpq $0x0, 0xa672(%rip)      # 0x12830
je 0x81cc
movq 0xa669(%rip), %rdi      # 0x12830
callq 0x4040
movq -0x8(%rbp), %rdi
callq 0x41a0
movq %rax, 0xa654(%rip)      # 0x12830
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read3.c
// Function: uc
static void uc(void) {
	char *cp = NULL;
	switch (get_int(argv[0])) {
		default:
		case 3: cp = "3rd Berkeley Distribution"; break;
		case 4: cp = "4th Berkeley Distribution"; break;
		case 5: cp = "4.2 Berkeley Distribution"; break;
		case 6: cp = "4.3 Berkeley Distribution"; break;
		case 7: cp = "4.4 Berkeley Distribution"; break;
	}
	if (th_source) free(th_source);
	th_source = strdup(cp);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
leaq 0x9119(%rip), %rax      # 0x11320
movq (%rax), %rdi
callq 0x75a0
addl $-0x3, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x4, %eax
ja 0x8231
movq -0x10(%rbp), %rax
leaq 0x3c2c(%rip), %rcx      # 0xbe54
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x8233
leaq 0x3cf1(%rip), %rax      # 0xbf2b
movq %rax, -0x8(%rbp)
jmp 0x8272
leaq 0x3cfe(%rip), %rax      # 0xbf45
movq %rax, -0x8(%rbp)
jmp 0x8272
leaq 0x3d0b(%rip), %rax      # 0xbf5f
movq %rax, -0x8(%rbp)
jmp 0x8272
leaq 0x3d18(%rip), %rax      # 0xbf79
movq %rax, -0x8(%rbp)
jmp 0x8272
leaq 0x3d25(%rip), %rax      # 0xbf93
movq %rax, -0x8(%rbp)
cmpq $0x0, 0xa5b6(%rip)      # 0x12830
je 0x8288
movq 0xa5ad(%rip), %rdi      # 0x12830
callq 0x4040
movq -0x8(%rbp), %rdi
callq 0x41a0
movq %rax, 0xa598(%rip)      # 0x12830
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/read3.c
// Function: print_footer
static void print_footer(void) {

	unsigned i;
	const char *cp = NULL;
	char c;

	if (!header[0]) return;

	cp = th_source ? th_source : flags.os;
	if (cp) {
		i = 0;
		while ((c = cp[i])) footer[i++] = c;
	}

	fputs("\n\n\n", stdout); line += 3;
	fputs(footer, stdout);
	fputc('\n', stdout); ++line;

	if (th_source) free(th_source);
	th_source = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x10(%rbp)
cmpb $0x0, 0xa129(%rip)      # 0x12840
jne 0x871e
jmp 0x8816
cmpq $0x0, 0xa10a(%rip)      # 0x12830
je 0x8735
movq 0xa101(%rip), %rax      # 0x12830
movq %rax, -0x20(%rbp)
jmp 0x8744
leaq 0x7b9c(%rip), %rax      # 0x102d8
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x878b
movl $0x0, -0x4(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
cmpb $0x0, %al
je 0x8789
movb -0x11(%rbp), %dl
movl -0x4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x4(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0xa10c(%rip), %rax      # 0x12890
movb %dl, (%rax,%rcx)
jmp 0x875a
jmp 0x878b
movq 0x582e(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
leaq 0x38e0(%rip), %rdi      # 0xc07c
callq 0x40c0
leaq 0x5b90(%rip), %rax      # 0xe338
movl (%rax), %ecx
addl $0x3, %ecx
leaq 0x5b84(%rip), %rax      # 0xe338
movl %ecx, (%rax)
movq 0x5803(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
leaq 0xa0c9(%rip), %rdi      # 0x12890
callq 0x40c0
movq 0x57ed(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x40e0
leaq 0x5b51(%rip), %rax      # 0xe338
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x5b45(%rip), %rax      # 0xe338
movl %ecx, (%rax)
cmpq $0x0, 0xa033(%rip)      # 0x12830
je 0x880b
movq 0xa02a(%rip), %rdi      # 0x12830
callq 0x4040
movq $0x0, 0xa01a(%rip) # 0x12830
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/chars.c
// Function: special_char
const unsigned char *special_char(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(char_table) / sizeof(char_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = char_table[mid].key;
		if (key == target) return char_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x130, -0x18(%rbp)     # imm = 0x130
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x5ae8(%rip), %rax      # 0xe350
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x889d
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x5ac4(%rip), %rax      # 0xe350
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x88e8
movl -0x24(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jae 0x88c8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jb 0x88c6
leaq 0x3b52(%rip), %rax      # 0xc412
movq %rax, -0x8(%rbp)
jmp 0x88e8
jmp 0x8851
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x88e3
leaq 0x3b35(%rip), %rax      # 0xc412
movq %rax, -0x8(%rbp)
jmp 0x88e8
jmp 0x8851
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/chars.c
// Function: special_string
const unsigned char *special_string(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(string_table) / sizeof(string_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = string_table[mid].key;
		if (key == target) return string_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1e, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movw %ax, -0x1a(%rbp)
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x7698(%rip), %rax      # 0xffd0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jne 0x896d
movl -0x20(%rbp), %eax
movl %eax, %ecx
leaq 0x7674(%rip), %rax      # 0xffd0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x89b8
movl -0x24(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jae 0x8998
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jb 0x8996
leaq 0x3a82(%rip), %rax      # 0xc412
movq %rax, -0x8(%rbp)
jmp 0x89b8
jmp 0x8921
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0x89b3
leaq 0x3a65(%rip), %rax      # 0xc412
movq %rax, -0x8(%rbp)
jmp 0x89b8
jmp 0x8921
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: render_init
void render_init(void) {
	buffer_flip_flop = 0;
	buffer_width = 0;
	buffer_offset = 0;
	buffer_words = 0;
	buffer[0] = 0;
	prev_ftx = FONT_R;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x9f42(%rip)      # 0x12910
movl $0x0, 0x9f3c(%rip)      # 0x12914
movl $0x0, 0x9f36(%rip)      # 0x12918
movl $0x0, 0x9f30(%rip)      # 0x1291c
movb $0x0, 0x9f2d(%rip)      # 0x12920
movl $0x83, 0x78a3(%rip)     # 0x102a0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: set_font
void set_font(unsigned new_font) {


	if (new_font == FONT_P) new_font = prev_ft;

	if (new_font == FONT_X) {
		prev_ftx = ft;
	} else {
		prev_ft = ft;
	}

	if (ft == new_font) return;
	/* disable current font. */
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
		case FONT_X: prev_ft = prev_ftx; break;
	}
	ft = new_font;
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x86, -0x4(%rbp)
jne 0x8a20
leaq 0x5909(%rip), %rax      # 0xe324
movl (%rax), %eax
movl %eax, -0x4(%rbp)
cmpl $0x87, -0x4(%rbp)
jne 0x8a3a
leaq 0x58f0(%rip), %rax      # 0xe320
movl (%rax), %eax
movl %eax, 0x7868(%rip)      # 0x102a0
jmp 0x8a4c
leaq 0x58df(%rip), %rax      # 0xe320
movl (%rax), %ecx
leaq 0x58da(%rip), %rax      # 0xe324
movl %ecx, (%rax)
leaq 0x58cd(%rip), %rax      # 0xe320
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x8a5f
jmp 0x8b95
leaq 0x58ba(%rip), %rax      # 0xe320
movl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x84, %eax
je 0x8a8c
jmp 0x8a74
movl -0x8(%rbp), %eax
subl $0x85, %eax
je 0x8ac1
jmp 0x8a80
movl -0x8(%rbp), %eax
subl $0x87, %eax
je 0x8af6
jmp 0x8b05
leaq 0x9165(%rip), %rax      # 0x11bf8
cmpq $0x0, (%rax)
je 0x8abf
leaq 0x7838(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8abf
leaq 0x914b(%rip), %rax      # 0x11bf8
movq (%rax), %rdi
movq 0x5509(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8b05
leaq 0x9140(%rip), %rax      # 0x11c08
cmpq $0x0, (%rax)
je 0x8af4
leaq 0x7803(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8af4
leaq 0x9126(%rip), %rax      # 0x11c08
movq (%rax), %rdi
movq 0x54d4(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8b05
movl 0x77a4(%rip), %ecx      # 0x102a0
leaq 0x5821(%rip), %rax      # 0xe324
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
leaq 0x5811(%rip), %rax      # 0xe320
movl %ecx, (%rax)
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x84, %eax
je 0x8b2b
jmp 0x8b1f
movl -0xc(%rbp), %eax
subl $0x85, %eax
je 0x8b60
jmp 0x8b95
leaq 0x90be(%rip), %rax      # 0x11bf0
cmpq $0x0, (%rax)
je 0x8b5e
leaq 0x7799(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8b5e
leaq 0x90a4(%rip), %rax      # 0x11bf0
movq (%rax), %rdi
movq 0x546a(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8b95
leaq 0x9099(%rip), %rax      # 0x11c00
cmpq $0x0, (%rax)
je 0x8b93
leaq 0x7764(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8b93
leaq 0x907f(%rip), %rax      # 0x11c00
movq (%rax), %rdi
movq 0x5435(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8b95
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: reset_font
void reset_font(void) {
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	ft = prev_ft = prev_ftx = FONT_R;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5771(%rip), %rax      # 0xe320
movl (%rax), %eax
movl %eax, -0x4(%rbp)
subl $0x84, %eax
je 0x8bc9
jmp 0x8bbd
movl -0x4(%rbp), %eax
subl $0x85, %eax
je 0x8bfe
jmp 0x8c33
leaq 0x9028(%rip), %rax      # 0x11bf8
cmpq $0x0, (%rax)
je 0x8bfc
leaq 0x76fb(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8bfc
leaq 0x900e(%rip), %rax      # 0x11bf8
movq (%rax), %rdi
movq 0x53cc(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8c33
leaq 0x9003(%rip), %rax      # 0x11c08
cmpq $0x0, (%rax)
je 0x8c31
leaq 0x76c6(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x8c31
leaq 0x8fe9(%rip), %rax      # 0x11c08
movq (%rax), %rdi
movq 0x5397(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x8c33
movl $0x83, 0x7663(%rip)     # 0x102a0
leaq 0x56e0(%rip), %rax      # 0xe324
movl $0x83, (%rax)
leaq 0x56cf(%rip), %rax      # 0xe320
movl $0x83, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: set_ti
void set_ti(int new_ti) {
	int lm;
	ti = new_ti;
	lm = new_ti < 0 ? in : new_ti;
	width = ll - lm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %ecx
leaq 0x56b7(%rip), %rax      # 0xe328
movl %ecx, (%rax)
cmpl $0x0, -0x4(%rbp)
jge 0x8c87
leaq 0x764c(%rip), %rax      # 0x102cc
movl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x8c8d
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x5692(%rip), %rax      # 0xe32c
movl (%rax), %ecx
subl -0x8(%rbp), %ecx
leaq 0x568e(%rip), %rax      # 0xe334
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: set_in_ti
void set_in_ti(int new_in, int new_ti) {
	int lm;
	prev_in = in;
	in = new_in;
	ti = new_ti;
	lm = new_ti >= 0 ? new_ti : new_in;
	width = ll - lm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x75bb(%rip), %rax      # 0x102cc
movl (%rax), %ecx
leaq 0x75b6(%rip), %rax      # 0x102d0
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
leaq 0x75a6(%rip), %rax      # 0x102cc
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
leaq 0x55f6(%rip), %rax      # 0xe328
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
jl 0x8d42
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x8d48
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
leaq 0x55d7(%rip), %rax      # 0xe32c
movl (%rax), %ecx
subl -0xc(%rbp), %ecx
leaq 0x55d3(%rip), %rax      # 0xe334
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: set_ll
void set_ll(int new_ll) {
	int lm;
	prev_ll = ll;
	ll = new_ll;
	lm = ti >= 0 ? ti : in;
	width = ll - lm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x55ae(%rip), %rax      # 0xe32c
movl (%rax), %ecx
leaq 0x55a9(%rip), %rax      # 0xe330
movl %ecx, (%rax)
movl -0x4(%rbp), %ecx
leaq 0x5599(%rip), %rax      # 0xe32c
movl %ecx, (%rax)
leaq 0x558c(%rip), %rax      # 0xe328
cmpl $0x0, (%rax)
jl 0x8daf
leaq 0x5580(%rip), %rax      # 0xe328
movl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x8dbb
leaq 0x7516(%rip), %rax      # 0x102cc
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
leaq 0x5564(%rip), %rax      # 0xe32c
movl (%rax), %ecx
subl -0x8(%rbp), %ecx
leaq 0x5560(%rip), %rax      # 0xe334
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: indent
static void indent(void) {
	int i, amt;

	if (ti >= 0) {
		amt = ti;
		ti = -1;
		width = ll - in;
	} else {
		amt = in;
	}

	if (!amt) return;

	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	for (i = 0; i < amt; ++i) fputc(' ', stdout);
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x5379(%rip), %rax      # 0xe328
cmpl $0x0, (%rax)
jl 0x8fea
leaq 0x536d(%rip), %rax      # 0xe328
movl (%rax), %eax
movl %eax, -0x8(%rbp)
leaq 0x5361(%rip), %rax      # 0xe328
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x5358(%rip), %rax      # 0xe32c
movl (%rax), %ecx
leaq 0x72ef(%rip), %rax      # 0x102cc
subl (%rax), %ecx
leaq 0x534e(%rip), %rax      # 0xe334
movl %ecx, (%rax)
jmp 0x8ff6
leaq 0x72db(%rip), %rax      # 0x102cc
movl (%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x9001
jmp 0x9145
leaq 0x5318(%rip), %rax      # 0xe320
movl (%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x84, %eax
je 0x9022
jmp 0x9016
movl -0xc(%rbp), %eax
subl $0x85, %eax
je 0x9057
jmp 0x908c
leaq 0x8bcf(%rip), %rax      # 0x11bf8
cmpq $0x0, (%rax)
je 0x9055
leaq 0x72a2(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x9055
leaq 0x8bb5(%rip), %rax      # 0x11bf8
movq (%rax), %rdi
movq 0x4f73(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x908c
leaq 0x8baa(%rip), %rax      # 0x11c08
cmpq $0x0, (%rax)
je 0x908a
leaq 0x726d(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x908a
leaq 0x8b90(%rip), %rax      # 0x11c08
movq (%rax), %rdi
movq 0x4f3e(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x908c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x90ba
movq 0x4f1e(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x40e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9093
leaq 0x525f(%rip), %rax      # 0xe320
movl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x84, %eax
je 0x90db
jmp 0x90cf
movl -0x10(%rbp), %eax
subl $0x85, %eax
je 0x9110
jmp 0x9145
leaq 0x8b0e(%rip), %rax      # 0x11bf0
cmpq $0x0, (%rax)
je 0x910e
leaq 0x71e9(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x910e
leaq 0x8af4(%rip), %rax      # 0x11bf0
movq (%rax), %rdi
movq 0x4eba(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x9145
leaq 0x8ae9(%rip), %rax      # 0x11c00
cmpq $0x0, (%rax)
je 0x9143
leaq 0x71b4(%rip), %rax      # 0x102d8
cmpl $0x0, 0x20(%rax)
jne 0x9143
leaq 0x8acf(%rip), %rax      # 0x11c00
movq (%rax), %rdi
movq 0x4e85(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x9145
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: xstrlen
unsigned xstrlen(const unsigned char *cp) {
	unsigned length = 0;
	unsigned i;
	for (i = 0; ; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
cmpb $0x0, -0x11(%rbp)
jne 0x917e
movl -0xc(%rbp), %eax
popq %rbp
retq
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jg 0x9192
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9194
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9166
nop
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: xstrnlen
unsigned xstrnlen(const unsigned char *cp, unsigned max) {

	unsigned length = 0;
	unsigned i;
	for (i = 0; i < max; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x91fd
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
cmpb $0x0, -0x1d(%rbp)
jne 0x91dc
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9203
movzbl -0x1d(%rbp), %eax
cmpl $0x80, %eax
jg 0x91f0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x91f2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x91b9
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: append_font
void append_font(unsigned font) {
	/* todo - check if buffer is overflowing */

	/* if there is trailing WS, this inserts a FONT_X token before the whitespace. */
	unsigned k;
	unsigned xfont = 0;

	k = buffer_offset;
	if (k == 0) {
		buffer[0] = font;
		buffer_offset++;
		return;
	}

	while (k > 0) {
		uint_fast8_t c = buffer[--k];
		if (c == ' ' || c == XSPACE) {
			buffer[k+1] = c;
			xfont = 1;
		} else break;
	}
	if (xfont) {
		buffer[k+1] = FONT_X;
		++buffer_offset;
	}
	buffer[buffer_offset++] = font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl 0x96f4(%rip), %eax      # 0x12918
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x924a
movl -0x4(%rbp), %eax
movb %al, 0x96ea(%rip)       # 0x12920
movl 0x96dc(%rip), %eax      # 0x12918
addl $0x1, %eax
movl %eax, 0x96d3(%rip)      # 0x12918
jmp 0x92f2
jmp 0x924c
cmpl $0x0, -0x8(%rbp)
jbe 0x92a4
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
movl %eax, %eax
movl %eax, %ecx
leaq 0x96ba(%rip), %rax      # 0x12920
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x20, %eax
je 0x9280
movzbl -0xd(%rbp), %eax
cmpl $0x81, %eax
jne 0x92a0
movb -0xd(%rbp), %dl
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x968c(%rip), %rax      # 0x12920
movb %dl, (%rax,%rcx)
movl $0x1, -0xc(%rbp)
jmp 0x92a2
jmp 0x92a4
jmp 0x924c
cmpl $0x0, -0xc(%rbp)
je 0x92ce
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x9665(%rip), %rax      # 0x12920
movb $-0x79, (%rax,%rcx)
movl 0x9653(%rip), %eax      # 0x12918
addl $0x1, %eax
movl %eax, 0x964a(%rip)      # 0x12918
movl -0x4(%rbp), %eax
movb %al, %dl
movl 0x963f(%rip), %eax      # 0x12918
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x9634(%rip)      # 0x12918
movl %eax, %eax
movl %eax, %ecx
leaq 0x9631(%rip), %rax      # 0x12920
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: hyphenate
static int hyphenate(const unsigned char *in, unsigned available, int *rv) {
	/* check for hyphens in the text... */
	/* todo: - hyphenate with - character, if word is [A-Za-z-]+ */
	uint_fast8_t c;
	unsigned i;
	int hpos = -1;
	unsigned hlen = 0;
	unsigned xlen = 0;

	for (i = 0; ; ) {
		c = in[i++];
		switch(c) {
		case HYPHEN: hpos = i; hlen = xlen; break;
		case ' ': case '\t': case 0:
				if (hlen) {
					rv[0] = hpos;
					rv[1] = hlen;
					return 1;
				}
				return 0;
		default:
			if (c <= NBSPACE) {
				xlen++;
				if (xlen >= available) {
					if (hlen) {
						rv[0] = hpos;
						rv[1] = hlen;
						return 1;
					}
					return 0;
				}
			}
			break;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %edx
incl %edx
movl %edx, -0x28(%rbp)
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
movl %eax, -0x38(%rbp)
testl %eax, %eax
je 0x9a5a
jmp 0x9a2c
movl -0x38(%rbp), %eax
subl $0x9, %eax
je 0x9a5a
jmp 0x9a36
movl -0x38(%rbp), %eax
subl $0x20, %eax
je 0x9a5a
jmp 0x9a40
movl -0x38(%rbp), %eax
subl $0x88, %eax
jne 0x9a85
jmp 0x9a4c
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x9ad0
cmpl $0x0, -0x30(%rbp)
je 0x9a7c
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9ad5
movl $0x0, -0x4(%rbp)
jmp 0x9ad5
movzbl -0x21(%rbp), %eax
cmpl $0x80, %eax
jg 0x9ace
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jb 0x9acc
cmpl $0x0, -0x30(%rbp)
je 0x9ac3
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9ad5
movl $0x0, -0x4(%rbp)
jmp 0x9ad5
jmp 0x9ace
jmp 0x9ad0
jmp 0x9a0b
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: is_sentence
static unsigned is_sentence(const unsigned char *cp, unsigned offset) {
	uint_fast8_t c;
	if (offset == 0) return 0;
	--offset;
	while (offset) {
		c = cp[offset];
		if (c == ')' || c == ']' || c == '\'' || c == '"' || c == '*'
			|| c == FONT_R || c == FONT_B || c == FONT_I || c == FONT_P) {
			--offset;
			continue;
		}
		break;
	}
	c = cp[offset];
	if (c == '.' || c == '?' || c == '!') return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x9afd
movl $0x0, -0x4(%rbp)
jmp 0x9bb7
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x9b7f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x29, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x5d, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x27, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x22, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x2a, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x83, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x84, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x85, %eax
je 0x9b72
movzbl -0x15(%rbp), %eax
cmpl $0x86, %eax
jne 0x9b7d
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b06
jmp 0x9b7f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
cmpl $0x2e, %eax
je 0x9ba7
movzbl -0x15(%rbp), %eax
cmpl $0x3f, %eax
je 0x9ba7
movzbl -0x15(%rbp), %eax
cmpl $0x21, %eax
jne 0x9bb0
movl $0x1, -0x4(%rbp)
jmp 0x9bb7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/render.c
// Function: set_tag
void set_tag(const unsigned char *cp, unsigned IP) {
	/* set the tag for IP/TP */
	unsigned n;

	/* assumes buffer has been flushed */
	/* set_in_ti(LM + IP, LM); */

	n = xstrlen(cp);
	if (n >= width || n >= IP) { 
		append(cp);
		flush(0);
	} else {
		uint_fast8_t c;
		unsigned i;
		for (i = 0; ; ++i) {
			c = cp[i];
			if (c == 0) break;
			if (c == ' ' || c == '\t') c = NBSPACE;
			buffer[buffer_offset++] = c;
			if (c <= NBSPACE) buffer_width++;
		}
		buffer[buffer_offset] = 0;

		while(buffer_width < IP) {
			buffer[buffer_offset++] = NBSPACE;
			buffer_width++;
		}
		buffer[buffer_offset] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9150
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x474f(%rip), %rcx      # 0xe334
cmpl (%rcx), %eax
jae 0x9bf1
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jb 0x9c06
movq -0x8(%rbp), %rdi
callq 0x9300
xorl %edi, %edi
callq 0x9650
jmp 0x9ce6
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jne 0x9c25
jmp 0x9c84
movzbl -0x11(%rbp), %eax
cmpl $0x20, %eax
je 0x9c37
movzbl -0x11(%rbp), %eax
cmpl $0x9, %eax
jne 0x9c3b
movb $-0x80, -0x11(%rbp)
movb -0x11(%rbp), %dl
movl 0x8cd4(%rip), %eax      # 0x12918
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8cc9(%rip)      # 0x12918
movl %eax, %eax
movl %eax, %ecx
leaq 0x8cc6(%rip), %rax      # 0x12920
movb %dl, (%rax,%rcx)
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jg 0x9c77
movl 0x8ca6(%rip), %eax      # 0x12914
addl $0x1, %eax
movl %eax, 0x8c9d(%rip)      # 0x12914
jmp 0x9c79
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9c0d
movl 0x8c8e(%rip), %eax      # 0x12918
movl %eax, %ecx
leaq 0x8c8d(%rip), %rax      # 0x12920
movb $0x0, (%rax,%rcx)
movl 0x8c77(%rip), %eax      # 0x12914
cmpl -0xc(%rbp), %eax
jae 0x9cd3
movl 0x8c70(%rip), %eax      # 0x12918
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8c65(%rip)      # 0x12918
movl %eax, %eax
movl %eax, %ecx
leaq 0x8c62(%rip), %rax      # 0x12920
movb $-0x80, (%rax,%rcx)
movl 0x8c4c(%rip), %eax      # 0x12914
addl $0x1, %eax
movl %eax, 0x8c43(%rip)      # 0x12914
jmp 0x9c97
movl 0x8c3f(%rip), %eax      # 0x12918
movl %eax, %ecx
leaq 0x8c3e(%rip), %rax      # 0x12920
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ksherlock[P]nroff_man/tbl.c
// Function: num_width
unsigned num_width(const char *cp, unsigned n, int *offset) {

	int zwsp = -1;
	int dig = -1;
	int dot = -1;
	unsigned l = 0;
	int st = 0;
	for (unsigned i = 0; i < n; ++i) {
		unsigned c = cp[i];
		if (c == ZWSPACE && zwsp < 0) zwsp = l+1;
		if (c > XSPACE) continue;
		++l;

		st <<= 2;
		if (c == '.') st |= 0b01;
		else if (isdigit(c)) {
			dig = l+1;
			st |= 0b11;
		}
		st &= 0b1111;
		if (st == 0b1101) dot = l;
		if (st == 0b0111) dot = l-1;
	}
	if (dot < 0) dot = dig;
	if (zwsp >= 0) dot = zwsp;
	*offset = dot;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x9def
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
cmpl $0x82, -0x34(%rbp)
jne 0x9d5f
cmpl $0x0, -0x1c(%rbp)
jge 0x9d5f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x81, -0x34(%rbp)
jbe 0x9d6a
jmp 0x9de1
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x2e, -0x34(%rbp)
jne 0x9d8d
movl -0x2c(%rbp), %eax
orl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9dbb
callq 0x41d0
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x9db9
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
orl $0x3, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9dbb
movl -0x2c(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x2c(%rbp)
cmpl $0xd, -0x2c(%rbp)
jne 0x9dd0
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x7, -0x2c(%rbp)
jne 0x9ddf
movl -0x28(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9de1
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9d2d
cmpl $0x0, -0x24(%rbp)
jge 0x9dfb
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x9e07
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]containers/pseudo.c
// Function: usage
static void usage(const char *progname) {
  fprintf(stderr, "\
Usage: %s [OPTIONS] [CMD [ARG]...]\n\
Options:\n\
  -g MAP    set the user namespace GID map\n\
  -u MAP    set the user namespace UID map\n\
GID and UID maps are specified as START:LOWER:COUNT[,START:LOWER:COUNT]...\n\
", progname);
  exit(EX_USAGE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3985(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x19dd(%rip), %rsi      # 0x405e
movb $0x0, %al
callq 0x2190
movl $0x40, %edi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/liuhaotian[P]xmppsh/libstrophe/examples/basic.c
// Function: conn_handler
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
                  const int error, xmpp_stream_error_t * const stream_error,
                  void * const userdata)
{
    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;

    if (status == XMPP_CONN_CONNECT) {
        fprintf(stderr, "DEBUG: connected\n");
        xmpp_disconnect(conn);
    }
    else {
        fprintf(stderr, "DEBUG: disconnected\n");
        xmpp_stop(ctx);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x249b
movq 0x15b69(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10b7b(%rip), %rsi     # 0x13004
movb $0x0, %al
callq 0x20d0
movq -0x8(%rbp), %rdi
callq 0x5370
jmp 0x24bc
movq 0x15b46(%rip), %rax     # 0x17fe8
movq (%rax), %rdi
leaq 0x10b6a(%rip), %rsi     # 0x13016
movb $0x0, %al
callq 0x20d0
movq -0x28(%rbp), %rdi
callq 0x6ad0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)