LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: t2
int t2(void)
{
    try
    {
        return(6);
    }
    finally
    {
        return(7);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x9c71(%rip), %r15      # 0xd270
movq (%r15), %rdi
leaq 0x6e8f(%rip), %rbx      # 0xa498
movl $0x7d, %edx
movq %rbx, %rsi
callq 0x151a
leaq 0x9cd7(%rip), %r14      # 0xd2f4
movl $0x1, %eax
leaq 0x6de7(%rip), %rbp      # 0xa410
movl %eax, %eax
movl %eax, 0xc(%rsp)
movq %rax, 0x10(%rsp)
movq (%r15), %rdi
callq 0x12d2
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x7d, %ecx
callq 0x1b4a
testl %eax, %eax
je 0x3675
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x3675
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x36cf
cmpl $0x0, 0x9c78(%rip)      # 0xd2f4
je 0x36b9
movq (%r12), %rdi
movl $0x3, %r13d
cmpl $0x0, 0x1b4(%rdi)
jne 0x36bf
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
jne 0x36bf
movq (%r12), %rax
movl $0x1, 0x1b4(%rax)
xorl %r13d, %r13d
jmp 0x36bf
movl $0x2, %r13d
movl %r13d, %r13d
movl %r13d, %eax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movq (%r12), %rax
movl $0x1, 0x1b8(%rax)
movq %r12, %rdi
callq 0x129c
cmpl $-0x1, %eax
je 0x373b
movq %r12, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
movl $0x7f, %ecx
callq 0x216e
movq %rax, %r13
movq %r12, %rdi
callq 0x12d2
movq (%rax), %rax
movq %r13, 0x1a0(%rax)
movq %r13, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3746
movq %r13, %rdi
callq 0x1040
movl 0xc(%rsp), %eax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl $0x1, %r13d
jmp 0x36bf
movq %r12, %rdi
callq 0x1b11
movq 0x10(%rsp), %rax
movslq (%rbp,%rax,4), %rax
addq %rbp, %rax
jmpq *%rax
movl $0x6, %eax
jmp 0x3820
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x379c
movq (%r15), %rdi
callq 0x18f4
testl %eax, %eax
je 0x375d
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jle 0x377c
movq (%r15), %rdi
callq 0x129c
movl $0x7, %ebp
cmpl $-0x1, %eax
je 0x381e
movq (%r15), %rdi
leaq 0x6cc1(%rip), %rdx      # 0xa498
movl $0xc8, %esi
movl $0x83, %ecx
callq 0x216e
movq %rax, %rbx
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
movq %rbx, 0x1a0(%rax)
movq %rbx, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3816
movq %rbx, %rdi
callq 0x1040
jmp 0x381e
movq (%r15), %rdi
callq 0x1b11
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: t3
int t3(void)
{
    try
    {
        assert(0);
    }
    catch (FailedAssertion, e)
    {
        return(8);
    }
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x9a2c(%rip), %rbp      # 0xd270
movq (%rbp), %rdi
leaq 0x6c49(%rip), %rbx      # 0xa498
movl $0x89, %edx
movq %rbx, %rsi
callq 0x151a
leaq 0x9a95(%rip), %r14      # 0xd2f8
movl $0x1, %eax
movl %eax, %eax
movl %eax, 0xc(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x6ba6(%rip), %r15      # 0xa420
movq (%rbp), %rdi
callq 0x12d2
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x89, %ecx
callq 0x1b4a
testl %eax, %eax
je 0x38c0
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x38c0
addq $0x8, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3990
movq %r13, %rdi
movq %r14, %rsi
leaq 0x9853(%rip), %rdx      # 0xd120
movq %rbx, %rcx
movl $0x8d, %r8d
callq 0x1bde
testl %eax, %eax
je 0x39b8
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x39b8
movq %r13, %rdi
leaq 0x9822(%rip), %rsi      # 0xd120
callq 0x18a9
testl %eax, %eax
je 0x39b8
movq 0x8(%r13), %rdi
movl $0x1, %r12d
movl %r12d, %esi
callq 0x1f2b
movq (%r13), %rax
movl $0x2, 0x1b8(%rax)
movq %r13, %rdi
callq 0x129c
cmpl $-0x1, %eax
je 0x3a02
movq %r13, %rdi
movl $0xc8, %esi
movq %rbx, %rdx
movl $0x8f, %ecx
callq 0x216e
movq %rax, %r12
movq %r13, %rdi
callq 0x12d2
movq (%rax), %rax
movq %r12, 0x1a0(%rax)
movq %r12, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
je 0x3a11
movq %r12, %rdi
callq 0x1040
movl 0xc(%rsp), %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq (%r13), %rax
movl $0x1, 0x1b8(%rax)
movq %r13, %rdi
xorl %esi, %esi
leaq 0x6988(%rip), %rdx      # 0xa332
movq %rbx, %rcx
movl $0x8b, %r8d
callq 0x208c
cmpl $0x0, 0x9939(%rip)      # 0xd2f8
je 0x39fc
movq (%r13), %rdi
movl $0x3, %r12d
cmpl $0x0, 0x1b4(%rdi)
jne 0x3a02
addq $0xd0, %rdi
movl $0x1, %esi
callq 0x1130
testl %eax, %eax
jne 0x3a02
movq (%r13), %rax
movl $0x1, 0x1b4(%rax)
xorl %r12d, %r12d
jmp 0x3a02
movl $0x2, %r12d
movl %r12d, %r12d
movl %r12d, %eax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq %r13, %rdi
callq 0x1b11
movq 0x10(%rsp), %rax
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movl $0x8, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x3a73
movq (%rbp), %rdi
callq 0x18f4
testl %eax, %eax
je 0x3a27
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x3a73
jmp 0x3a51
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: recurse
void recurse(int x)
{
    printf("recurse(%d)\n", x);

    try
    {
        if (x == 0)
            *((int *)0) = 0;
        recurse(x - 1);
    }
    finally
        printf("%d, ", x);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x5c3e(%rip), %rdi      # 0xa4ae
xorl %eax, %eax
movl %ebx, %esi
callq 0x1080
leaq 0x89f0(%rip), %r15      # 0xd270
movq (%r15), %rdi
leaq 0x5c0e(%rip), %rsi      # 0xa498
movl $0x2cd, %ebp            # imm = 0x2CD
movl %ebp, %edx
callq 0x151a
movl %ebx, %eax
decl %eax
movl %eax, 0x4(%rsp)
leaq 0x8a73(%rip), %r12      # 0xd318
movl $0x1, %r13d
movq (%r15), %rdi
callq 0x12d2
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
leaq 0x5bd5(%rip), %rdx      # 0xa498
movl %ebp, %ecx
callq 0x1b4a
testl %eax, %eax
je 0x4900
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x4900
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x4900
movq (%r14), %rax
movl $0x1, 0x1b8(%rax)
movl 0x4(%rsp), %edi
callq 0x485c
cmpl $0x0, 0x8a11(%rip)      # 0xd318
je 0x48ab
movq (%r14), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x493a
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x493a
movq (%r14), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x48ab
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
leaq 0x5b65(%rip), %r14      # 0xa4bb
xorl %ebp, %ebp
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x4986
movq (%r15), %rdi
callq 0x18f4
testl %eax, %eax
jne 0x4986
jmp 0x49a7
movl %ebp, %eax
movq %r14, %rdi
movl %ebx, %esi
callq 0x1080
movq (%r15), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x497a
jmp 0x4958
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: main
int main(void)
{
    TestThrow();
    CheckStack();

    TestReturn();
    CheckStack();

    TestMemory();
    CheckStack();

    TestNesting();
    CheckStack();

    TestAssert();
    CheckStack();

    TestValidate();
    CheckStack();

    TestCheck();
    CheckStack();

    TestRecursion();
    CheckStack();

    TestSignal();
    CheckStack();

    printf("\nREADY\n\n");
}

// Assembly:
pushq %rax
callq 0x4a90
callq 0x49b6
callq 0x542a
callq 0x49b6
callq 0x573c
callq 0x49b6
callq 0x7651
callq 0x49b6
callq 0x5ca7
callq 0x49b6
leaq 0x5fe3(%rip), %rdi      # 0xaa01
callq 0x1070
movl 0x8837(%rip), %esi      # 0xd260
leal 0x1(%rsi), %eax
movl %eax, 0x882e(%rip)      # 0xd260
leaq 0x5d01(%rip), %rdi      # 0xa73a
xorl %eax, %eax
callq 0x1080
leaq 0x5d08(%rip), %rdi      # 0xa74f
movl $0x1b, %esi
xorl %eax, %eax
callq 0x1080
movl $0xa, %edi
callq 0x1050
callq 0x49b6
callq 0x6256
callq 0x49b6
callq 0x6c02
callq 0x49b6
callq 0x6dd7
callq 0x49b6
leaq 0x5e76(%rip), %rdi      # 0xa8fd
callq 0x1070
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: TestRecursion
static void TestRecursion(void)
{
    printf("\nRECURSION TESTS ---------------------------------------\n\n");

    printf("-->%2d: Hits a run-time exception after 10 levels?\n", testNum++);
    try
        recurse(10);
    catch (RuntimeException, e)
        printf("%s\n", e->getMessage());
    finally;
    printf("\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3e61(%rip), %rdi      # 0xaa75
callq 0x1070
movl 0x6641(%rip), %esi      # 0xd260
movl %esi, %eax
incl %eax
movl %eax, 0x6637(%rip)      # 0xd260
leaq 0x3c0d(%rip), %rdi      # 0xa83d
xorl %eax, %eax
callq 0x1080
leaq 0x6632(%rip), %rbp      # 0xd270
movq (%rbp), %rdi
leaq 0x384f(%rip), %rbx      # 0xa498
movl $0x2dc, %edx            # imm = 0x2DC
movq %rbx, %rsi
callq 0x151a
leaq 0x6757(%rip), %r14      # 0xd3b4
leaq 0x64dc(%rip), %r15      # 0xd140
movl $0x1, %r13d
movq (%rbp), %rdi
callq 0x12d2
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0x2dc, %ecx            # imm = 0x2DC
callq 0x1b4a
testl %eax, %eax
je 0x6caa
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x6caa
addq $0x8, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
je 0x6d0c
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x2de, %r8d            # imm = 0x2DE
callq 0x1bde
testl %eax, %eax
je 0x6d24
movq (%r12), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x6d24
movq %r12, %rdi
movq %r15, %rsi
callq 0x18a9
testl %eax, %eax
je 0x6d24
movq 0x8(%r12), %rdi
movl %r13d, %esi
callq 0x1f2b
movq (%r12), %rcx
movl $0x2, 0x1b8(%rcx)
callq *0x1e0(%rax)
movq %rax, %rdi
callq 0x1070
jmp 0x6d24
movq (%r12), %rax
movl $0x1, 0x1b8(%rax)
movl $0xa, %edi
callq 0x485c
cmpl $0x0, 0x6689(%rip)      # 0xd3b4
je 0x6c6a
movq (%r12), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x6d64
addq $0xd0, %rdi
movl %r13d, %esi
callq 0x1130
testl %eax, %eax
jne 0x6d64
movq (%r12), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x6c6a
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x6d9c
movq (%rbp), %rdi
callq 0x18f4
testl %eax, %eax
je 0x6dbe
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x6d9c
jmp 0x6d7a
movl $0xa, %edi
callq 0x1050
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/meaning-matters[P]Except/Test.c
// Function: t5
static void t5(void)
{
    try
    {
        raise(SIGABRT);
    }
    catch (SegmentationFault, e);
    catch (IllegalInstruction, e);
    finally;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x3a9b(%rip), %rbp      # 0xd270
movq (%rbp), %rdi
leaq 0xcb8(%rip), %rbx       # 0xa498
movl $0xfe, %edx
movq %rbx, %rsi
callq 0x151a
leaq 0x3bd8(%rip), %r14      # 0xd3cc
leaq 0x39c5(%rip), %r15      # 0xd1c0
movl $0x1, %r12d
movq (%rbp), %rdi
callq 0x12d2
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl $0xfe, %ecx
callq 0x1b4a
testl %eax, %eax
je 0x9845
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
je 0x9845
addq $0x8, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
je 0x98d7
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbx, %rcx
movl $0x102, %r8d            # imm = 0x102
callq 0x1bde
testl %eax, %eax
je 0x987c
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x987c
movq %r13, %rdi
movq %r15, %rsi
callq 0x18a9
testl %eax, %eax
jne 0x98bb
movq %r13, %rdi
movq %r14, %rsi
leaq 0x3917(%rip), %rdx      # 0xd1a0
movq %rbx, %rcx
movl $0x103, %r8d            # imm = 0x103
callq 0x1bde
testl %eax, %eax
je 0x98ef
movq (%r13), %rax
cmpl $0x0, 0x1b4(%rax)
je 0x98ef
movq %r13, %rdi
leaq 0x38ee(%rip), %rsi      # 0xd1a0
callq 0x18a9
testl %eax, %eax
je 0x98ef
movq 0x8(%r13), %rdi
movl %r12d, %esi
callq 0x1f2b
movq (%r13), %rax
movl $0x2, 0x1b8(%rax)
jmp 0x98ef
movq (%r13), %rax
movl $0x1, 0x1b8(%rax)
movl $0x6, %edi
callq 0x1030
cmpl $0x0, 0x3ad6(%rip)      # 0xd3cc
je 0x9801
movq (%r13), %rdi
cmpl $0x0, 0x1b4(%rdi)
jne 0x992f
addq $0xd0, %rdi
movl %r12d, %esi
callq 0x1130
testl %eax, %eax
jne 0x992f
movq (%r13), %rax
movl $0x1, 0x1b4(%rax)
jmp 0x9801
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl $0x3, 0x1b8(%rax)
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
cmpl $0x0, 0x1b4(%rax)
jg 0x9967
movq (%rbp), %rdi
callq 0x18f4
testl %eax, %eax
je 0x9989
movq (%rbp), %rdi
callq 0x12d2
movq (%rax), %rax
movl 0x1b4(%rax), %ecx
movl %ecx, %edx
decl %edx
movl %edx, 0x1b4(%rax)
testl %ecx, %ecx
jg 0x9967
jmp 0x9945
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: deposit
void
deposit(Addr a, Word w)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		ww->core[a] = w;
	else if(IS_FF(a))
		ww->ffs[a & 037] = w;
	else
		ww->tss[a & 037] = w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x4266
movl 0xb398(%rip), %eax      # 0xf5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xb373(%rip), %rcx      # 0xf5d0
jae 0x427a
movw %si, 0x1c(%rcx,%rax,2)
jmp 0x427f
movzwl %di, %eax
leaq 0xb360(%rip), %rcx      # 0xf5d0
movw %si, 0x9c(%rcx,%rax,2)
jmp 0x427f
movw %si, 0x5c(%rcx,%rax,2)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: examine
Word
examine(Addr a)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		return ww->core[a];
	else if(IS_FF(a))
		return ww->ffs[a & 037];
	else
		return ww->tss[a & 037];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x42aa
movl 0xb357(%rip), %eax      # 0xf5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xb332(%rip), %rcx      # 0xf5d0
jae 0x42c0
leaq (%rcx,%rax,2), %rax
addq $0x1c, %rax
jmp 0x42c8
movzwl %di, %eax
leaq 0xb31c(%rip), %rcx      # 0xf5d0
leaq (%rcx,%rax,2), %rax
addq $0x9c, %rax
jmp 0x42c8
leaq (%rcx,%rax,2), %rax
addq $0x5c, %rax
movzwl (%rax), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: depositreg
void
depositreg(int a, Word w)
{
	switch(a){
	case REG_PC: ww1.pc = w & ADDRMASK; break;
	case REG_AC: ww1.ac = w & WORDMASK; break;
	case REG_A: ww1.ar = w & WORDMASK; break;
	case REG_B: ww1.br = w & WORDMASK; break;
	case REG_SAM:
		ww1.ac0_carry = ww1.sam = 0;
		if(w == 1)
			ww1.ac0_carry = 1;
		else if(w == 0177776)
			ww1.sam = 1;
		break;
	default:
		// Set toggle switch storage
		if(a < 32)
			ww1.tss[a] = w;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x4335
leaq 0x2f8c(%rip), %rcx      # 0x726c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, 0xb2ea(%rip)       # 0xf5e0
jmp 0x4354
movl $0x0, 0xc37c(%rip)      # 0x1067e
cmpl $0xfffe, %esi           # imm = 0xFFFE
je 0x434b
cmpl $0x1, %esi
jne 0x4354
movw $0x1, 0xc366(%rip)      # 0x1067e
jmp 0x4354
movw %si, 0xc34f(%rip)       # 0x10670
jmp 0x4354
movw %si, 0xc352(%rip)       # 0x1067c
jmp 0x4354
movw %si, 0xc345(%rip)       # 0x10678
jmp 0x4354
cmpl $0x1f, %edi
jg 0x4354
movslq %edi, %rax
leaq 0xb28c(%rip), %rcx      # 0xf5d0
movw %si, 0x5c(%rcx,%rax,2)
jmp 0x4354
movw $0x1, 0xc32c(%rip)      # 0x10680
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	word w;
	switch(a){
	case REG_PC: return ww1.pc;
	case REG_AC: return ww1.ac;
	case REG_A: return ww1.ar;
	case REG_B: return ww1.br;
	case REG_SAM:
		w = 0;
		if(ww1.ac0_carry) w |= 1;
		if(ww1.sam) w |= 0177776;
		return w;
	default:
		// Read toggle switch storage
		if(a < 32)
			return ww1.tss[a];
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x43b5
leaq 0x2f17(%rip), %rcx      # 0x7280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0xb267(%rip), %eax      # 0xf5e0
jmp 0x43cd
xorl %ecx, %ecx
cmpw $0x0, 0xc2f9(%rip)      # 0x1067e
setne %cl
movl %ecx, %eax
orl $-0x2, %eax
cmpw $0x0, 0xc2eb(%rip)      # 0x10680
cmovel %ecx, %eax
jmp 0x43cd
movzwl 0xc2cf(%rip), %eax      # 0x10670
jmp 0x43cd
movzwl 0xc2d2(%rip), %eax      # 0x1067c
jmp 0x43cd
movzwl 0xc2c5(%rip), %eax      # 0x10678
jmp 0x43cd
cmpl $0x1f, %edi
jg 0x43cb
movslq %edi, %rax
leaq 0xb20c(%rip), %rcx      # 0xf5d0
movzwl 0x5c(%rcx,%rax,2), %eax
jmp 0x43cd
xorl %eax, %eax
movzwl %ax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: scope_record
void
scope_record(WWI *ww, ExUnit *eu)
{
	Scope *s = (Scope*)eu;
	if(s->fd >= 0){
		u32 cmd = 0;
		int x = ww->hdefl;
		int y = ww->vdefl;
		// Convert [-1.0,+1.0] to [0,1023]
		if(x & 02000) x++;
		if(y & 02000) y++;
		x += 02000;
		y += 02000;
		x &= 03777;
		y &= 03777;
		x >>= 1;
		y >>= 1;
		cmd = x;
		cmd |= y<<10;
		cmd |= 7<<20;
		if(write(s->fd, &cmd, 4) < 4)
			s->fd = -1;
usleep(100);
	}
	ww->interlock = 0;
	eu->active = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rsi), %edi
testl %edi, %edi
js 0x469f
leaq -0x14(%rbp), %rsi
movl $0x0, (%rsi)
movl 0x10d8(%r14), %eax
btl $0xa, %eax
adcl $0x0, %eax
movl 0x10dc(%r14), %ecx
btl $0xa, %ecx
adcl $0x0, %ecx
shrl %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x9, %ecx
andl $0xffc00, %ecx          # imm = 0xFFC00
orl %eax, %ecx
xorl $0x780200, %ecx         # imm = 0x780200
movl %ecx, (%rsi)
movl $0x4, %edx
callq 0x20d0
cmpq $0x3, %rax
jg 0x4695
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
movl $0x64, %edi
callq 0x2430
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: ptape_init
void
ptape_init(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	pt->wbyw = !!(ww->ios & 2);
	pt->p7 = !(ww->ios & 1);

	ww->ioc_counter = pt->wbyw ? 015 : 017;
	pt->dly = 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10c8(%rdi), %eax
movl %eax, %ecx
notl %ecx
shrl %eax
andl $0x1, %ecx
xorl %edx, %edx
andl $0x1, %eax
movl %eax, 0x48(%rsi)
movl %ecx, 0x4c(%rsi)
sete %dl
leal 0xd(,%rdx,2), %eax
movl %eax, 0x10c0(%rdi)
movl $0x3e8, 0x50(%rsi)      # imm = 0x3E8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: ptape_record
void
ptape_record(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}

	int u = (ww->ios>>3) & 3;
	u8 c = ww->ior>>10 & 077;
	if(pt->p7) c |= 0100;
	write(pt->out_fd[u], &c, 1);

	if(pt->wbyw) ww->ior <<= 5;
	if(ww->ioc_counter++ == 017){
		ww->interlock = 0;
		eu->active = 0;
	}

	pt->dly = 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x4718
decl %eax
movl %eax, 0x50(%rbx)
jmp 0x4789
movq %rdi, %r14
movl 0x10c8(%rdi), %eax
shrl $0x3, %eax
andl $0x3, %eax
movzwl 0x10b8(%rdi), %ecx
shrl $0xa, %ecx
movb %cl, -0x11(%rbp)
cmpl $0x0, 0x4c(%rbx)
je 0x4740
orb $0x40, %cl
movb %cl, -0x11(%rbp)
movl 0x28(%rbx,%rax,4), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x20d0
cmpl $0x0, 0x48(%rbx)
je 0x4761
shlw $0x5, 0x10b8(%r14)
movl 0x10c0(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x4782
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: ptape_read
void
ptape_read(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}
	int u = (ww->ios>>3) & 3;
	if(eu->active && hasinput(pt->in_fd[u])){
		u8 c;
		read(pt->in_fd[u], &c, 1);
		if(pt->wbyw) ww->ior <<= 5;
		ww->ior |= c & 077;

		if(ww->ioc_counter++ == 017){
			ww->interlock = 0;
			eu->active = 0;
		}

		pt->dly = 1000;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x47b6
decl %eax
movl %eax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rbx)
je 0x47ab
movq %rdi, %r14
movl 0x10c8(%rdi), %r15d
shrl $0x3, %r15d
andl $0x3, %r15d
movl 0x38(%rbx,%r15,4), %edi
callq 0x37fb
testl %eax, %eax
je 0x47ab
movl 0x38(%rbx,%r15,4), %edi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0x2190
cmpl $0x0, 0x48(%rbx)
je 0x47fd
shlw $0x5, 0x10b8(%r14)
movzbl -0x19(%rbp), %eax
andl $0x3f, %eax
orw %ax, 0x10b8(%r14)
movl 0x10c0(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x482d
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
jmp 0x47ab
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: readmem
void
readmem(WWI *ww, FILE *f)
{
	char buf[100], *s;
	word a, w;

	a = 0;
	while(s = fgets(buf, 100, f)){
		while(*s){
			if(*s == ';')
				break;
			else if('0' <= *s && *s <= '7'){
				w = strtol(s, &s, 8);
				if(*s == ':'){
					a = w;
					s++;
				}else if(a < 04000)
					ww->core[a++] = w;
			}else
				s++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xa0(%rbp), %rdi
movl $0x64, %esi
movq %rbx, %rdx
callq 0x21a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x496d
xorl %eax, %eax
leaq -0xa0(%rbp), %r15
leaq -0x30(%rbp), %r12
movzwl %ax, %r13d
movq -0x30(%rbp), %rdi
movzbl (%rdi), %eax
testl %eax, %eax
je 0x490a
cmpl $0x3b, %eax
jne 0x4925
movq %r15, %rdi
movl $0x64, %esi
movq %rbx, %rdx
callq 0x21a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
jne 0x48fa
jmp 0x496d
andb $-0x8, %al
cmpb $0x30, %al
jne 0x494c
movq %r12, %rsi
movl $0x8, %edx
callq 0x21f0
movq -0x30(%rbp), %rcx
cmpb $0x3a, (%rcx)
je 0x4955
cmpl $0x7ff, %r13d           # imm = 0x7FF
ja 0x48fa
jmp 0x495e
incq %rdi
movq %rdi, -0x30(%rbp)
jmp 0x48fa
incq %rcx
movq %rcx, -0x30(%rbp)
jmp 0x48f6
movw %ax, 0x9c(%r14,%r13,2)
leal 0x1(%r13), %eax
jmp 0x48f6
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: handlemsg
void
handlemsg(WWI *ww, Msg msg)
{
	switch(msg.cmd){
	case CMD_NONE:
		break;
	case CMD_SET_PC:
		ww->pc_sw = msg.arg & ADDRMASK;
		ww->pc = ww->pc_sw;
		break;
	case CMD_STEP:
		ww->order_by_order = 1;
		ww->run = 1;
		break;
	case CMD_RUN:
		ww->order_by_order = 0;
		ww->run = 1;
		break;
	case CMD_STOP:
		ww->run = 0;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rsi), %eax
cmpl $0x3, %eax
ja 0x4ac8
leaq 0x288b(%rip), %rcx      # 0x7314
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrq $0x20, %rsi
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, (%rdi)
movw %si, 0x10(%rdi)
jmp 0x4ac8
movabsq $0x100000000, %rax      # imm = 0x100000000
jmp 0x4ac4
movl $0x0, 0x8(%rdi)
jmp 0x4ac8
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: handleio
void
handleio(WWI *ww)
{
	if(ww->active_unit && ww->active_unit->active){
		if(ww->ioc_out)
			ww->active_unit->record(ww, ww->active_unit);
		else
			ww->active_unit->read(ww, ww->active_unit);
	}

	if(ww->scope->fd >= 0 && hasinput(ww->scope->fd)){
		u32 input;
		if(readn(ww->scope->fd, &input, 4) < 0){
			ww->scope->fd = -1;
			return;
		}
		if(input & 0x80000000){
			// light pen/gun
			ww->scope->gunx = input & 01777;
			ww->scope->guny = (input>>10) & 01777;
			ww->scope->gun = (input>>20) & 1;
		}else{
			int id = input>>24;
			// we'll use FF register 2 for the input bits
			if(id == 0){
				ww->ffs[2] &= ~0140000;	// need upper 2 bits
				if(input & 0200) ww->ffs[2] |= 0100000;	// up
				if(input & 0100) ww->ffs[2] |= 0040000;	// down
			}else{
				ww->ffs[2] &= ~0030000;	// need next 2 bits
				if(input & 0200) ww->ffs[2] |= 0020000;	// up
				if(input & 0100) ww->ffs[2] |= 0010000;	// down
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10d0(%rdi), %rsi
testq %rsi, %rsi
je 0x4af7
cmpl $0x0, (%rsi)
je 0x4af7
xorl %eax, %eax
cmpl $0x0, 0x10bc(%rbx)
sete %al
movq %rbx, %rdi
callq *0x18(%rsi,%rax,8)
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
testl %edi, %edi
js 0x4bb9
callq 0x37fb
testl %eax, %eax
je 0x4bb9
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x38bc
testl %eax, %eax
js 0x4b62
movl -0xc(%rbp), %eax
testl %eax, %eax
js 0x4b72
movzwl 0x20(%rbx), %ecx
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x4b9a
andl $0x3fff, %ecx           # imm = 0x3FFF
movl %eax, %edx
andl $-0x80, %edx
shll $0x8, %edx
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x4bb9
orb $0x40, 0x21(%rbx)
jmp 0x4bb9
movq 0x10e0(%rbx), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0x4bb9
movl $0x3ff, %ecx            # imm = 0x3FF
movl %eax, %edx
andl %ecx, %edx
movq 0x10e0(%rbx), %rsi
movl %edx, 0x30(%rsi)
movl %eax, %edx
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x34(%rsi)
shrl $0x14, %eax
andl $0x1, %eax
movl %eax, 0x2c(%rsi)
jmp 0x4bb9
andl $0xffffcfff, %ecx       # imm = 0xFFFFCFFF
movl %eax, %edx
shll $0x6, %edx
andl $0x2000, %edx           # imm = 0x2000
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x4bb9
orb $0x10, 0x21(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: consthread
void*
consthread(void *arg)
{
	WWI *ww = (WWI*)arg;
	FILE *f;
	f = fdopen(ww->console_fd, "w");

	for(;;){
		fprintf(f, "\033[1J\033[H");	// clear
		fprintf(f, "CS/%02o\n", ww->cs);
		fprintf(f, "PC/%04o\n", ww->pc);
		fprintf(f, "PR/%06o\n", ww->par);
		fprintf(f, "AC/%06o\n", ww->ac);
		fprintf(f, "AR/%06o\n", ww->ar);
		fprintf(f, "BR/%06o\n", ww->br);
		usleep(50000);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10f0(%rdi), %edi
leaq 0x10e3(%rip), %rsi      # 0x742d
callq 0x2270
movq %rax, %r14
leaq 0x10f9(%rip), %r12      # 0x7452
leaq 0x10fb(%rip), %r13      # 0x745b
leaq 0x10fd(%rip), %r15      # 0x7464
movl $0x7, %esi
movl $0x1, %edx
leaq 0x10b7(%rip), %rdi      # 0x742f
movq %r14, %rcx
callq 0x2390
movzwl 0x14(%rbx), %edx
movq %r14, %rdi
leaq 0x10a9(%rip), %rsi      # 0x7437
xorl %eax, %eax
callq 0x21e0
movzwl 0x10(%rbx), %edx
movq %r14, %rdi
leaq 0x109d(%rip), %rsi      # 0x7440
xorl %eax, %eax
callq 0x21e0
movzwl 0x109c(%rbx), %edx
movq %r14, %rdi
leaq 0x108e(%rip), %rsi      # 0x7449
xorl %eax, %eax
callq 0x21e0
movzwl 0x10a8(%rbx), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21e0
movzwl 0x10a0(%rbx), %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x21e0
movzwl 0x10ac(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movl $0xc350, %edi           # imm = 0xC350
callq 0x2430
jmp 0x6367
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: cpu_start
void
cpu_start(Addr a)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = a;
	chansend(cmdchan, &msg);
	msg.cmd = CMD_RUN;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movl $0x1, (%rbx)
movl %edi, 0x4(%rbx)
movq 0xa311(%rip), %rdi      # 0x10738
movq %rbx, %rsi
callq 0x3f47
movl $0x3, (%rbx)
movq 0xa2fc(%rip), %rdi      # 0x10738
movq %rbx, %rsi
callq 0x3f47
movq 0xa2ed(%rip), %rdi      # 0x10738
leaq 0xa2ee(%rip), %rsi      # 0x10740
callq 0x3f47
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: cpu_setpc
void
cpu_setpc(Addr pc)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = pc;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movl $0x1, (%rsi)
movl %edi, 0x4(%rsi)
movq 0xa2be(%rip), %rdi      # 0x10738
callq 0x3f47
movq 0xa2b2(%rip), %rdi      # 0x10738
leaq 0xa2b3(%rip), %rsi      # 0x10740
callq 0x3f47
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/aap[P]rx-0/ww1/mach.c
// Function: end_around_carry
static void
carry(WWI *ww)
{
	int s = ww->ac + (ww->cry<<1);
	if(s & 0200000)
		s++;
	// overflow
	ww->ac0_carry = SGN(~ww->ac) && SGN(s^ww->cry);
	ww->ac = s;
	ww->cry = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl 0x10a8(%rdi), %eax
movl %eax, %ecx
andl $0x1, %ecx
movzwl 0x10aa(%rdi), %edx
orl %ecx, %edx
movl %eax, %ecx
xorl $0x1, %ecx
leal (%rdx,%rdx), %esi
leal (%rcx,%rdx,2), %r8d
btl $0x10, %r8d
adcl %ecx, %esi
xorl %esi, %edx
testw %dx, %dx
sets %cl
testw %ax, %ax
setns %al
andb %cl, %al
movzbl %al, %eax
movw %ax, 0x10ae(%rdi)
movw %si, 0x10a8(%rdi)
movw $0x0, 0x10aa(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2ae7(%rip), %r14      # 0x5028
leaq 0x2af3(%rip), %r15      # 0x503b
cmpl $0x0, 0x8(%rbx)
jle 0x2548
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%rbx), %r12
cmpb $0x0, 0x50(%r12,%r13)
jne 0x25b2
movq 0x30(%r12,%r13), %rdi
movq 0x40(%r12,%r13), %rsi
callq 0x35df
cmpl $0x3218, %eax           # imm = 0x3218
jne 0x25b2
addq %r13, %r12
xorl %eax, %eax
callq 0x42f9
movss %xmm0, 0x4(%rsp)
movq %r12, %rdi
callq 0x307b
xorl %eax, %eax
callq 0x42f9
subss 0x4(%rsp), %xmm0
mulss 0x2a63(%rip), %xmm0     # 0x5004
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2050
incq %rbp
movslq 0x8(%rbx), %rax
addq $0x58, %r13
cmpq %rax, %rbp
jl 0x2553
jmp 0x2548
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movslq 0xa13f(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x4232
movq 0x9deb(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xb1f5(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x53da(%rip), %rsi      # 0x9605
xorl %eax, %eax
callq 0x4110
movq 0x9dbf(%rip), %r15      # 0xdff8
movq (%r15), %rsi
movq %r14, %rdi
callq 0x40c0
testl %ebx, %ebx
jne 0x4258
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40e0
movq (%r15), %rsi
leaq 0x53a8(%rip), %rdi      # 0x960a
callq 0x40c0
movl %ebx, %edi
callq 0x41b0
movq (%r15), %rsi
movq %rax, %rdi
callq 0x40c0
jmp 0x4248
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movslq 0xa0ae(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x42c3
movq 0x9d5a(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xb164(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x5349(%rip), %rsi      # 0x9605
xorl %eax, %eax
callq 0x4110
movq 0x9d2e(%rip), %r12      # 0xdff8
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4110
testl %ebx, %ebx
jne 0x42f6
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40e0
movq (%r12), %rsi
leaq 0x5309(%rip), %rdi      # 0x960a
callq 0x40c0
movl %ebx, %edi
callq 0x41b0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x40c0
jmp 0x42df
// File: /workspace/github_c_makefile_star2_O1/ksherlock[P]nroff_man/read1.c
// Function: get_arg
int get_arg(unsigned *i_ptr, unsigned type) {
	unsigned i = *i_ptr;
	uint_fast8_t c = type;

	if (type == 0) c = type = buffer[i++];
	arg_buffer[0] = 0;
	if (type == 0) return 0; /* error. */
	if (type == '[') {
		unsigned j = 0;
		for (;;) {
			c = buffer[i++];
			if (c == 0) return 0;
			if (c == ']') break;
			if (j < 31) arg_buffer[j] = c;
			++j;
		}
		if (j < 32)
			arg_buffer[j] = 0;
		else arg_buffer[31] = 0;
		*i_ptr = i;
		return j;
	}
	if (type == '(') {
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[0] = c;
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[1] = c;
		arg_buffer[2] = 0;
		*i_ptr = i;
		return 2;
	}
	arg_buffer[0] = c;
	arg_buffer[1] = 0;
	*i_ptr = i;
	return 1;
}

// Assembly:
movl (%rdi), %ecx
testl %esi, %esi
je 0x487c
movl %esi, %eax
movl %eax, %edx
jmp 0x488b
leaq 0x9b1d(%rip), %rax      # 0xe3a0
movb (%rcx,%rax), %dl
incl %ecx
movzbl %dl, %eax
movb $0x0, 0xab0e(%rip)      # 0xf3a0
testl %eax, %eax
je 0x494a
cmpl $0x28, %eax
je 0x48dd
cmpl $0x5b, %eax
jne 0x491b
xorl %eax, %eax
leaq 0x9af3(%rip), %rsi      # 0xe3a0
leaq 0xaaec(%rip), %rdx      # 0xf3a0
movl %ecx, %r8d
movzbl (%r8,%rsi), %r8d
testl %r8d, %r8d
je 0x4948
cmpl $0x5d, %r8d
je 0x492f
cmpl $0x1e, %eax
ja 0x48d7
movl %eax, %r9d
movb %r8b, (%r9,%rdx)
incl %eax
incl %ecx
jmp 0x48b4
movl %ecx, %eax
leaq 0x9aba(%rip), %rdx      # 0xe3a0
movb (%rax,%rdx), %sil
xorl %eax, %eax
testb %sil, %sil
je 0x494a
leal 0x1(%rcx), %r8d
movb %sil, 0xaaa4(%rip)      # 0xf3a0
movb (%r8,%rdx), %dl
testb %dl, %dl
je 0x494a
addl $0x2, %ecx
movb %dl, 0xaa94(%rip)       # 0xf3a1
movb $0x0, 0xaa8e(%rip)      # 0xf3a2
movl $0x2, %eax
jmp 0x4945
movb %dl, 0xaa7f(%rip)       # 0xf3a0
movb $0x0, 0xaa79(%rip)      # 0xf3a1
movl $0x1, %eax
jmp 0x4945
cmpl $0x20, %eax
movl %eax, %esi
movl $0x1f, %r8d
cmovbq %rsi, %r8
movb $0x0, (%r8,%rdx)
incl %ecx
movl %ecx, (%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movl %eax, 0x99a6(%rip)      # 0xe310
xorl %eax, %eax
movl %eax, 0x99ee(%rip)      # 0xe360
movq $0x0, 0xaa43(%rip) # 0xf3c0
movb $0x2e, 0x99b8(%rip)     # 0xe33c
movb $0x27, 0x99b2(%rip)     # 0xe33d
movb $0x5c, 0x99ac(%rip)     # 0xe33e
movl $0x62, 0x9978(%rip)     # 0xe314
movl $0x1, %ecx
movl %ecx, 0x9971(%rip)      # 0xe318
movl %eax, 0x99b7(%rip)      # 0xe364
movl %ecx, 0x9969(%rip)      # 0xe31c
movl %eax, 0x99af(%rip)      # 0xe368
movl $0xffffffff, 0x9965(%rip) # imm = 0xFFFFFFFF
movl %eax, 0x99a7(%rip)      # 0xe370
movl %eax, 0x999d(%rip)      # 0xe36c
movl $0x4e, %edx
movl %edx, 0x9956(%rip)      # 0xe330
movl %edx, 0x994c(%rip)      # 0xe32c
movl $0x83, %esi
movl %esi, 0x9939(%rip)      # 0xe324
movl %esi, 0x992f(%rip)      # 0xe320
movl %edx, 0x993d(%rip)      # 0xe334
movl %ecx, 0x993b(%rip)      # 0xe338
movl %eax, 0x9971(%rip)      # 0xe374
callq 0x75f0
movl 0x9932(%rip), %eax      # 0xe340
testl %eax, %eax
js 0x4a3b
leaq (%rax,%rax,2), %rax
leaq 0x18(,%rax,8), %r15
xorl %r12d, %r12d
leaq 0xa9e8(%rip), %r13      # 0xf410
movq 0x8(%r12,%r13), %rdi
callq 0x4040
addq $0x18, %r12
cmpq %r12, %r15
jne 0x4a28
cmpl $0x0, 0x98fe(%rip)      # 0xe340
jle 0x4a69
leaq 0xa9dd(%rip), %r15      # 0xf428
xorl %r12d, %r12d
movq (%r15), %rdi
callq 0x4090
movslq 0x98e3(%rip), %rax      # 0xe340
incq %r12
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4a4e
movl $0xffffffff, 0x98cd(%rip) # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x4a9c
xorl %ebp, %ebp
movl %ebp, 0x98c0(%rip)      # 0xe340
movq %r14, 0xa989(%rip)      # 0xf410
movq %rbx, %rdi
callq 0x41a0
movq %rax, 0xa982(%rip)      # 0xf418
movl %ebp, 0xa984(%rip)      # 0xf420
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movb %dil, 0x9082(%rip)      # 0xf470
leaq 0x7f1b(%rip), %rax      # 0xe310
movl $0x1, (%rax)
leaq 0x7f5e(%rip), %rax      # 0xe360
movslq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
jle 0x6460
xorl %edx, %edx
leaq 0x8fa8(%rip), %rsi      # 0xf3c0
leaq 0x9051(%rip), %rdi      # 0xf470
testq %rdx, %rdx
je 0x642e
movslq %eax, %r8
incl %eax
movb $0x20, (%r8,%rdi)
movq (%rsi,%rdx,8), %r8
movb (%r8), %r9b
testb %r9b, %r9b
je 0x6458
movslq %eax, %r10
xorl %r11d, %r11d
leaq (%r10,%r11), %rbx
movb %r9b, (%rdi,%rbx)
movb 0x1(%r8,%r11), %r9b
incq %r11
testb %r9b, %r9b
jne 0x6440
addl %r11d, %eax
incq %rdx
cmpq %rcx, %rdx
jne 0x641f
cltq
leaq 0x9007(%rip), %rcx      # 0xf470
movw $0x83, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
leaq 0x7e95(%rip), %rax      # 0xe310
movl $0x1, (%rax)
leaq 0x7ed8(%rip), %rax      # 0xe360
movl (%rax), %ecx
testq %rcx, %rcx
je 0x64e9
xorl %edx, %edx
leaq 0x8f28(%rip), %r8       # 0xf3c0
leaq 0x8fd1(%rip), %r9       # 0xf470
xorl %eax, %eax
movq (%r8,%rdx,8), %r10
testb $0x1, %dl
movl %esi, %r11d
cmovel %edi, %r11d
movl %eax, %ebx
movb %r11b, (%rbx,%r9)
movb (%r10), %bl
testb %bl, %bl
je 0x64dd
movl $0x1, %r11d
leal (%rax,%r11), %r14d
movb %bl, (%r14,%r9)
movl %r11d, %ebx
movb (%r10,%rbx), %bl
incl %r11d
testb %bl, %bl
jne 0x64c2
addl %r11d, %eax
jmp 0x64df
incl %eax
incq %rdx
cmpq %rcx, %rdx
jne 0x64a1
jmp 0x64eb
xorl %eax, %eax
movl %eax, %ecx
incl %eax
leaq 0x8f7a(%rip), %rdx      # 0xf470
movb $-0x7d, (%rcx,%rdx)
movb $0x0, (%rax,%rdx)
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ksherlock[P]nroff_man/read3.c
// Function: get_unit
int get_unit(const unsigned char *arg, int dv, int base) {
	double d;
	char sign = 0;
	uint_fast8_t c;
	char *cp = NULL;
	int rv;
	unsigned i;
	
	if (!arg) return dv;

	i = 0;
	while (arg[i] == ' ') ++i;
	arg += i;
	c = arg[0];
	if (!c) return dv;

	if (c == '+' || c == '-') {
		sign = c;
		++arg;
	}
	c = arg[0];
	if (!isdigit(c) && c != '.') return dv;

	errno = 0;
	d = strtod(arg, &cp);
	if (errno) return dv;

	c = *cp;
	switch (c) {
		case 'c': /* centimeter */
			d *= 94.5 / 24.0;
			break;
		case 'i': /* inch */
			d *= 10.0; /* 240.0 / 24.0; */
			break;
		case 'P': /* pica - 1/6 inch */
			d *= 10.0 / 6.0;
			break;
		case 'p': /* point - 1/72 inch */
			d *= 10.0 / 72.0;
			break;
		case 'f':
			d *= 65536.0 / 24.0;
			break;
		case 'M': /* mini em - 1/100 em */
			d  /= 100.0;
			break;

		case 'm':
		case 'n':
		case 'u':
		case 'v':
			break;
		default:
			break;
	}

	rv = (int)d;
	if (sign && base >= 0) {
		if (sign == '+') base += rv;
		else base -= rv;
		if (base < 0) return 0;
		return base;
	}
	if (sign == '-') rv = 0;

	return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x69dd
movl %edx, %ebx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %eax
movzbl (%r14,%rax), %r12d
cmpl $0x20, %r12d
jne 0x68e2
incl %eax
jmp 0x68d1
testl %r12d, %r12d
je 0x69dd
cmpl $0x2b, %r12d
je 0x68f7
cmpl $0x2d, %r12d
jne 0x68ff
addq %rax, %r14
incq %r14
jmp 0x6905
addq %rax, %r14
xorl %r12d, %r12d
movzbl (%r14), %r15d
callq 0x41d0
cmpl $0x2e, %r15d
je 0x6927
movq (%rax), %rax
movzwl (%rax,%r15,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0x69dd
callq 0x4060
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4080
cmpl $0x0, (%r15)
jne 0x69dd
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x65, %eax
jg 0x6972
cmpl $0x4d, %eax
je 0x698b
cmpl $0x50, %eax
je 0x699f
cmpl $0x63, %eax
jne 0x69b1
mulsd 0x2e50(%rip), %xmm0     # 0x97c0
jmp 0x69b1
cmpl $0x66, %eax
je 0x6995
cmpl $0x69, %eax
je 0x69a9
cmpl $0x70, %eax
jne 0x69b1
mulsd 0x2e1f(%rip), %xmm0     # 0x97a8
jmp 0x69b1
divsd 0x2e05(%rip), %xmm0     # 0x9798
jmp 0x69b1
mulsd 0x2e03(%rip), %xmm0     # 0x97a0
jmp 0x69b1
mulsd 0x2e09(%rip), %xmm0     # 0x97b0
jmp 0x69b1
mulsd 0x2e07(%rip), %xmm0     # 0x97b8
cvttsd2si %xmm0, %ebp
testl %ebx, %ebx
js 0x69d4
testl %r12d, %r12d
je 0x69d4
movl %ebp, %ecx
negl %ecx
cmpl $0x2b, %r12d
cmovel %ebp, %ecx
addl %ebx, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
jmp 0x69df
xorl %eax, %eax
cmpl $0x2d, %r12d
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
xorl %r8d, %r8d
movl $0x130, %edi            # imm = 0x130
leaq 0x493f(%rip), %rdx      # 0xbe70
leaq 0x290a(%rip), %rsi      # 0x9e42
leal (%r8,%rdi), %r10d
shrl %r10d
leaq (%r10,%r10,2), %r9
movzwl (%rdx,%r9,8), %r11d
cmpl %r11d, %ecx
jne 0x755a
leaq (%rdx,%r9,8), %rax
movq 0x8(%rax), %rax
xorl %r9d, %r9d
jmp 0x757d
jbe 0x756f
incl %r10d
cmpl %edi, %r10d
setb %r9b
cmovaeq %rsi, %rax
movl %r10d, %r8d
jmp 0x757d
cmpl %r8d, %r10d
seta %r9b
cmovbeq %rsi, %rax
movl %r10d, %edi
testb %r9b, %r9b
jne 0x7538
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
xorl %r8d, %r8d
movl $0x1e, %edi
leaq 0x6554(%rip), %rdx      # 0xdaf0
leaq 0x289f(%rip), %rsi      # 0x9e42
leal (%r8,%rdi), %r10d
shrl %r10d
leaq (%r10,%r10,2), %r9
movzwl (%rdx,%r9,8), %r11d
cmpl %r11d, %ecx
jne 0x75c5
leaq (%rdx,%r9,8), %rax
movq 0x8(%rax), %rax
xorl %r9d, %r9d
jmp 0x75e8
jbe 0x75da
incl %r10d
cmpl %edi, %r10d
setb %r9b
cmovaeq %rsi, %rax
movl %r10d, %r8d
jmp 0x75e8
cmpl %r8d, %r10d
seta %r9b
cmovbeq %rsi, %rax
movl %r10d, %edi
testb %r9b, %r9b
jne 0x75a3
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, 0x93b8(%rip)      # 0x109b0
movl %eax, 0x93b6(%rip)      # 0x109b4
movl %eax, 0x93b4(%rip)      # 0x109b8
movl %eax, 0x93b2(%rip)      # 0x109bc
movb $0x0, 0x93af(%rip)      # 0x109c0
movl $0x83, 0x6d29(%rip)     # 0xe344
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6cfb(%rip), %rax      # 0xe324
cmpl $0x86, %edi
jne 0x7633
movl (%rax), %ebx
cmpl $0x87, %ebx
leaq 0x6ce0(%rip), %r14      # 0xe320
movl (%r14), %ecx
leaq 0x6cfa(%rip), %rdx      # 0xe344
cmovneq %rax, %rdx
movl %ecx, (%rdx)
cmpl %ebx, %ecx
je 0x76fc
cmpl $0x87, %ecx
je 0x76a6
cmpl $0x85, %ecx
je 0x7679
cmpl $0x84, %ecx
jne 0x76ae
leaq 0x8621(%rip), %rax      # 0xfc98
jmp 0x7680
leaq 0x8628(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x76ae
leaq 0x6ce9(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x76ae
movq 0x6924(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
jmp 0x76ae
movl 0x6c98(%rip), %ecx      # 0xe344
movl %ecx, (%rax)
movl %ebx, (%r14)
cmpl $0x85, %ebx
je 0x76ca
cmpl $0x84, %ebx
jne 0x76fc
leaq 0x85c8(%rip), %rax      # 0xfc90
jmp 0x76d1
leaq 0x85cf(%rip), %rax      # 0xfca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x76fc
leaq 0x6c98(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x76fc
movq 0x68d3(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40c0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
leaq 0x6c14(%rip), %rbx      # 0xe320
movl (%rbx), %eax
cmpl $0x85, %eax
je 0x7725
cmpl $0x84, %eax
jne 0x7750
leaq 0x8575(%rip), %rax      # 0xfc98
jmp 0x772c
leaq 0x857c(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7750
leaq 0x6c3d(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7750
movq 0x6878(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40c0
movl $0x83, %eax
movl %eax, 0x6be9(%rip)      # 0xe344
leaq 0x6bc2(%rip), %rcx      # 0xe324
movl %eax, (%rcx)
movl %eax, (%rbx)
popq %rbx
retq