LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: new_term
Term *
new_term(int rows, int cols)
{
    size_t size = sizeof(Term) + rows*sizeof(Cell *) + rows*cols*sizeof(Cell);
    Term *term = malloc(size);
    if (!term)
        return NULL;
    term->rows = rows;
    term->cols = cols;
    term->addr = (Cell **) &term[1];
    term->cells = (Cell *) &term->addr[rows];
    reset(term);
    term->plt_dirty = 0;
    return term;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq $0x1a0, %rax            # imm = 0x1A0
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x180f
movq $0x0, -0x8(%rbp)
jmp 0x186c
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rcx
addq $0x1a0, %rcx            # imm = 0x1A0
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rdi
callq 0x1880
movq -0x20(%rbp), %rax
movb $0x0, 0x19d(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: reset
static void
reset(Term *term)
{
    int i, j;

    term->row = term->col = 0;
    term->top = 0;
    term->bot = term->rows - 1;
    term->mode = def_mode;
    term->attr = def_attr;
    term->pair = def_pair;
    term->cs_array[0] = CS_BMP;
    term->cs_array[1] = CS_VTG;
    term->cs_index = 0;
    term->state = S_ANY;
    term->parlen = 0;
    if (memcmp(term->plt, def_plt, sizeof(term->plt) != 0)) {
        term->plt_dirty = 1;
    }
    memcpy(term->plt, def_plt, sizeof(term->plt));
    term->plt_local = 0;
    for (i = 0; i < term->rows; i++) {
        term->addr[i] = &term->cells[i*term->cols];
        for (j = 0; j < term->cols; j++)
            term->addr[i][j] = (Cell) {EMPTY, def_attr, def_pair};
    }
    save_cursor(term);
    save_misc(term);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movw 0x8dcc(%rip), %cx       # 0xa690
movq -0x8(%rbp), %rax
movw %cx, 0x18(%rax)
movb 0xcf26(%rip), %cl       # 0xe7f8
movq -0x8(%rbp), %rax
movb %cl, 0x1a(%rax)
movb 0x8db3(%rip), %cl       # 0xa692
movq -0x8(%rbp), %rax
movb %cl, 0x1b(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
movq -0x8(%rbp), %rdi
addq $0x16c, %rdi            # imm = 0x16C
movq 0x8951(%rip), %rsi      # 0xa280
movl $0x1, %edx
callq 0x1100
cmpl $0x0, %eax
je 0x1949
movq -0x8(%rbp), %rax
movb $0x1, 0x19d(%rax)
movq -0x8(%rbp), %rdi
addq $0x16c, %rdi            # imm = 0x16C
movq 0x8925(%rip), %rsi      # 0xa280
movl $0x30, %edx
callq 0x1160
movq -0x8(%rbp), %rax
movb $0x0, 0x19c(%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x1a12
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdx
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x4(%rcx), %eax
cltq
shlq $0x2, %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1a02
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movw $0x20, -0x14(%rbp)
movb 0xce13(%rip), %dl       # 0xe7f8
movb %dl, -0x12(%rbp)
movb 0x8ca4(%rip), %dl       # 0xa692
movb %dl, -0x11(%rbp)
movl -0x14(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x19b9
jmp 0x1a04
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1977
movq -0x8(%rbp), %rdi
callq 0x35c0
movq -0x8(%rbp), %rdi
callq 0x35f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: addchar
static void
addchar(Term *term, uint16_t code)
{
    Cell cell = (Cell) {code, term->attr, term->pair};
    if (term->col >= term->cols) {
        if (term->mode & M_AUTOWRAP) {
            term->col = 0;
            if (term->row < term->bot)
                term->row++;
            else
                scroll_down(term);
        } else {
            term->col = term->cols - 1;
        }
    }
    if (!within_bounds(term, term->row, term->col))
        return;
    if (term->mode & M_INSERT) {
        Cell next;
        int col;
        for (col = term->col; col < term->cols; col++) {
            next = term->addr[term->row][col];
            term->addr[term->row][col] = cell;
            cell = next;
        }
    } else {
        term->addr[term->row][term->col] = cell;
    }
    term->col++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movb 0x1a(%rax), %al
movb %al, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %al
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x2029
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x2016
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x200b
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x2014
movq -0x8(%rbp), %rdi
callq 0x3670
jmp 0x2027
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x2029
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x3790
cmpl $0x0, %eax
jne 0x204a
jmp 0x20ee
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x20bf
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x20bd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movl -0xe(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x12(%rbp), %eax
movl %eax, -0xe(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2064
jmp 0x20e1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movl -0xe(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: ctrlchar
static void
ctrlchar(Term *term, uint8_t byte)
{
    switch (byte) {
    case 0x08:
        CLEARWRAP;
        if (term->col) term->col--;
        break;
    case 0x09:
        /* TODO: See ESC Sequence H (HTS) */
        term->col &= ~7; term->col += 8;
        CLIPCOL(term->cols-1);
        break;
    case 0x0A: case 0x0B: case 0x0C:
        CLEARWRAP;
        linefeed(term);
        break;
    case 0x0D:
        term->col = 0;
        break;
    case 0x0E:
        term->cs_index = 1;
        break;
    case 0x0F:
        term->cs_index = 0;
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x2219
movq -0x18(%rbp), %rax
leaq 0x4f01(%rip), %rcx      # 0x7034
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x213e
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x215f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x2161
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x2178
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x2219
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
andl $-0x8, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jl 0x21b1
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x21c2
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x2219
jmp 0x21c6
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x21e7
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
jmp 0x21e9
movq -0x8(%rbp), %rdi
callq 0x3810
jmp 0x2219
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x2219
movq -0x8(%rbp), %rax
movl $0x1, 0x38(%rax)
jmp 0x2219
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: char_code
static uint16_t
char_code(Term *term)
{
    int i;
    uint16_t code = term->partial[0] & ((1 << (8 - term->parlen)) - 1);
    for (i = 1; i < term->parlen; i++)
        code = (code << 6) | (term->partial[i] & 0x3F);
    return code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x6c(%rax), %eax
movq -0x8(%rbp), %rdx
movl $0x8, %ecx
subl 0x64(%rdx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movw %ax, -0xe(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x64(%rcx), %eax
jge 0x35b9
movzwl -0xe(%rbp), %eax
shll $0x6, %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0x6c(%rcx,%rdx), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3585
movw -0xe(%rbp), %ax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: save_misc
static void
save_misc(Term *term)
{
    term->save_misc.row = term->row;
    term->save_misc.col = term->col;
    term->save_misc.origin_on = term->mode & M_ORIGIN;
    term->save_misc.attr = term->attr;
    term->save_misc.pair = term->pair;
    term->save_misc.cs_array[0] = term->cs_array[0];
    term->save_misc.cs_array[1] = term->cs_array[1];
    term->save_misc.cs_index = term->cs_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %ecx
andl $0x40, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4c(%rax)
movq -0x8(%rbp), %rax
movb 0x1a(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x50(%rax)
movq -0x8(%rbp), %rax
movb 0x1b(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x51(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x5c(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: scroll_down
static void
scroll_down(Term *term)
{
    int row, col;
    Cell *addr;

    if (!within_bounds(term, term->top, 0))
        return;
    if (!within_bounds(term, term->bot, 0))
        return;
    addr = term->addr[term->top];
    for (row = term->top; row < term->bot; row++)
        term->addr[row] = term->addr[row+1];
    term->addr[term->bot] = addr;
    for (col = 0; col < term->cols; col++)
        term->addr[term->bot][col] = BLANK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
xorl %edx, %edx
callq 0x3790
cmpl $0x0, %eax
jne 0x3698
jmp 0x3780
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
xorl %edx, %edx
callq 0x3790
cmpl $0x0, %eax
jne 0x36b4
jmp 0x3780
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jge 0x3712
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x36d6
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3780
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movw $0x20, -0x1c(%rbp)
movq -0x8(%rbp), %rdx
movb 0x1a(%rdx), %dl
movb %dl, -0x1a(%rbp)
movq -0x8(%rbp), %rdx
movb 0x1b(%rdx), %dl
movb %dl, -0x19(%rbp)
movl -0x1c(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3731
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: within_bounds
static int
within_bounds(Term *term, int row, int col)
{
    if (row < 0 || row >= term->rows || col < 0 || col > term->cols) {
        logfmt("position %d,%d is out of bounds %d,%d\n",
               row+1, col+1, term->rows, term->cols);
        return 0;
    } else {
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x37c5
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x37c5
cmpl $0x0, -0x18(%rbp)
jl 0x37c5
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x37f6
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl -0x18(%rbp), %edx
addl $0x1, %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0x3dc2(%rip), %rdi      # 0x75a8
movb $0x0, %al
callq 0x2220
movl $0x0, -0x4(%rbp)
jmp 0x37fd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: linefeed
static void
linefeed(Term *term)
{
    if (term->row == term->bot)
        scroll_down(term);
    else
        term->row++;
    if (term->mode & M_NEWLINE)
        term->col = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0x3837
movq -0x8(%rbp), %rdi
callq 0x3670
jmp 0x3844
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x385f
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: scroll_up
static void
scroll_up(Term *term)
{
    int row, col;
    Cell *addr;

    if (!within_bounds(term, term->top, 0))
        return;
    if (!within_bounds(term, term->bot, 0))
        return;
    addr = term->addr[term->bot];
    for (row = term->bot; row > term->top; row--)
        term->addr[row] = term->addr[row-1];
    term->addr[term->top] = addr;
    for (col = 0; col < term->cols; col++)
        term->addr[term->top][col] = BLANK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %esi
xorl %edx, %edx
callq 0x3790
cmpl $0x0, %eax
jne 0x3898
jmp 0x3980
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %esi
xorl %edx, %edx
callq 0x3790
cmpl $0x0, %eax
jne 0x38b4
jmp 0x3980
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x3912
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x38d6
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3980
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x10(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movw $0x20, -0x1c(%rbp)
movq -0x8(%rbp), %rdx
movb 0x1a(%rdx), %dl
movb %dl, -0x1a(%rbp)
movq -0x8(%rbp), %rdx
movb 0x1b(%rdx), %dl
movb %dl, -0x19(%rbp)
movl -0x1c(%rbp), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3931
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: load_misc
static void
load_misc(Term *term)
{
    term->row = term->save_misc.row;
    term->col = term->save_misc.col;
    if (term->save_misc.origin_on)
        term->mode |= M_ORIGIN;
    else
        term->mode &= ~M_ORIGIN;
    term->attr = term->save_misc.attr;
    term->pair = term->save_misc.pair;
    term->cs_array[0] = term->save_misc.cs_array[0];
    term->cs_array[1] = term->save_misc.cs_array[1];
    term->cs_index = term->save_misc.cs_index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4c(%rax)
je 0x39cf
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %ecx
orl $0x40, %ecx
movw %cx, 0x18(%rax)
jmp 0x39de
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %ecx
andl $-0x41, %ecx
movw %cx, 0x18(%rax)
movq -0x8(%rbp), %rax
movb 0x50(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1a(%rax)
movq -0x8(%rbp), %rax
movb 0x51(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1b(%rax)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x58(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movl 0x5c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: getparams
static int
getparams(char *partial, int *params, int n)
{
    char *next;
    char *token = partial;
    int i = 0;
    if (!*partial) {
        params[0] = 0;
        return 1;
    }
    while (i < n && *token) {
        params[i++] = strtol(token, &next, 10);
        if (*next) next++;
        token = next;
    }
    if (i < n && *(token-1) == ';')
        params[i++] = 0;
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x3a71
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x3b15
jmp 0x3a73
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x35(%rbp)
jge 0x3a90
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x3a99
jmp 0x3ae1
movq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x1150
movl %eax, %edx
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x34(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3ad7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3a73
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3b0f
movq -0x30(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x3b, %eax
jne 0x3b0f
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: fake_colour_256
static int
fake_colour_256(int colnum){
    int nr, ng, nb;
    if (colnum < 16) {
        nr = (colnum&1) ? 170:0;
        ng = (colnum&2) ? 170:0;
        nb = (colnum&4) ? 170:0;
        if (colnum&8) { nr += 85; ng += 85; nb += 85; }
        if (colnum == 3) ng = 85;
    } else if (colnum < 232) {
        int i = colnum - 16;
        nr = i / 36; ng = (i / 6) % 6; nb = i % 6;
        nr = nr ? nr * 40 + 55 : 0;
        ng = ng ? ng * 40 + 55 : 0;
        nb = nb ? nb * 40 + 55 : 0;
    } else if (colnum < 256) {
        int i = colnum - 232;
        nr = ng = nb = i * 10 + 8;
    } else
        nr=ng=nb = 127;

    return fake_colour_16m(nr, ng, nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jge 0x441b
movl -0x4(%rbp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0xaa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edx
andl $0x2, %edx
xorl %eax, %eax
movl $0xaa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edx
andl $0x4, %edx
xorl %eax, %eax
movl $0xaa, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4409
movl -0x8(%rbp), %eax
addl $0x55, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x55, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x55, %eax
movl %eax, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x4416
movl $0x55, -0xc(%rbp)
jmp 0x4501
cmpl $0xe8, -0x4(%rbp)
jge 0x44c2
movl -0x4(%rbp), %eax
subl $0x10, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x24, %ecx
cltd
idivl %ecx
movl %eax, -0x8(%rbp)
movl -0x14(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl $0x6, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x4475
imull $0x28, -0x8(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x1c(%rbp)
jmp 0x447c
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x447c
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4494
imull $0x28, -0xc(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x20(%rbp)
jmp 0x449b
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x449b
movl -0x20(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x44b3
imull $0x28, -0x10(%rbp), %eax
addl $0x37, %eax
movl %eax, -0x24(%rbp)
jmp 0x44ba
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x44ba
movl -0x24(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x44ff
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x44e8
movl -0x4(%rbp), %eax
subl $0xe8, %eax
movl %eax, -0x18(%rbp)
imull $0xa, -0x18(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x10(%rbp)
movl %eax, -0xc(%rbp)
movl %eax, -0x8(%rbp)
jmp 0x44fd
movl $0x7f, -0x10(%rbp)
movl $0x7f, -0xc(%rbp)
movl $0x7f, -0x8(%rbp)
jmp 0x44ff
jmp 0x4501
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x4520
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/term.c
// Function: fake_colour_16m
static int
fake_colour_16m(int red, int green, int blue)
{
    int av = (red+green+blue)/3;
    int palno = 1*(red>=av) + 2*(green>=av) + 4*(blue>=av);
    if (red==green && green==blue) {
        if (av > 212) palno = 15-8;
        else if (av > 127) palno = 7-8;
        else if (av > 42) palno = 8;
        else palno = 0;
    }
    return palno + 8*(av>127);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x10(%rbp), %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
shll $0x0, %eax
movl -0x8(%rbp), %ecx
cmpl -0x10(%rbp), %ecx
setge %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll %ecx
addl %ecx, %eax
movl -0xc(%rbp), %ecx
cmpl -0x10(%rbp), %ecx
setge %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x45c9
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x45c9
cmpl $0xd4, -0x10(%rbp)
jle 0x459e
movl $0x7, -0x14(%rbp)
jmp 0x45c7
cmpl $0x7f, -0x10(%rbp)
jle 0x45ad
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x45c5
cmpl $0x2a, -0x10(%rbp)
jle 0x45bc
movl $0x8, -0x14(%rbp)
jmp 0x45c3
movl $0x0, -0x14(%rbp)
jmp 0x45c5
jmp 0x45c7
jmp 0x45c9
movl -0x14(%rbp), %eax
cmpl $0x7f, -0x10(%rbp)
setg %cl
andb $0x1, %cl
movzbl %cl, %ecx
shll $0x3, %ecx
addl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/mbf.c
// Function: load_font
Font *
load_font(const char *fname)
{
    int fd;
    char sig[4];
    Header header;
    int stride;
    size_t ranges_size, data_size;
    Font *font;

    fd = open(fname, O_RDONLY);
    if (fd == -1)
        return NULL;
    read(fd, sig, sizeof(sig));
    if (memcmp(sig, (char []) {'M', 'B', 'F', 0x01}, sizeof(sig))) {
        close(fd);
        return NULL;
    }
    read(fd, &header, sizeof(header));
    /* stride = ceil(w / 8) = floor(w / 8) + (w % 8 ? 1 : 0) */
    stride = (header.w >> 3) + !!(header.w & 7);
    ranges_size = header.nr * sizeof(Range);
    data_size = header.ng * stride * header.h;
    font = malloc(sizeof(Font) + ranges_size + data_size);
    if (!font) {
        close(fd);
        return NULL;
    }
    font->stride = stride;
    font->header = header;
    font->ranges = (Range *) &font[1];
    read(fd, font->ranges, ranges_size);
    font->data = (uint8_t *) &font->ranges[header.nr];
    read(fd, font->data, data_size);
    close(fd);
    return font;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x11a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x460f
movq $0x0, -0x8(%rbp)
jmp 0x4761
movl -0x14(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x10f0
leaq -0x18(%rbp), %rax
movb $0x4d, -0x44(%rbp)
movb $0x42, -0x43(%rbp)
movb $0x46, -0x42(%rbp)
movb $0x1, -0x41(%rbp)
leaq -0x44(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x465e
movl -0x14(%rbp), %edi
callq 0x10e0
movq $0x0, -0x8(%rbp)
jmp 0x4761
movl -0x14(%rbp), %edi
leaq -0x1e(%rbp), %rsi
movl $0x6, %edx
callq 0x10f0
movzbl -0x1c(%rbp), %eax
sarl $0x3, %eax
movzbl -0x1c(%rbp), %ecx
andl $0x7, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movzwl -0x1a(%rbp), %eax
shlq $0x2, %rax
movq %rax, -0x30(%rbp)
movzwl -0x1e(%rbp), %eax
imull -0x24(%rbp), %eax
movzbl -0x1b(%rbp), %ecx
imull %ecx, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
addq -0x38(%rbp), %rdi
callq 0x1170
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x46e3
movl -0x14(%rbp), %edi
callq 0x10e0
movq $0x0, -0x8(%rbp)
jmp 0x4761
movl -0x24(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x40(%rbp), %rax
movl -0x1e(%rbp), %ecx
movl %ecx, (%rax)
movw -0x1a(%rbp), %cx
movw %cx, 0x4(%rax)
movq -0x40(%rbp), %rcx
addq $0x20, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %edi
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x30(%rbp), %rdx
callq 0x10f0
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rcx
movzwl -0x1a(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %edi
movq -0x40(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x10f0
movl -0x14(%rbp), %edi
callq 0x10e0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/mbf.c
// Function: search_glyph
int
search_glyph(Font *font, uint16_t code)
{
    int index, i;
    Range r;

    index = 0;
    for (i = 0; i < font->header.nr; i++) {
        r = font->ranges[i];
        if (code < r.offset)
            return -1;
        if (code < r.offset + r.length)
            return index + code - r.offset;
        index += r.length;
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jge 0x47fe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jge 0x47c3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4805
movzwl -0x12(%rbp), %eax
movzwl -0x20(%rbp), %ecx
movzwl -0x1e(%rbp), %edx
addl %edx, %ecx
cmpl %ecx, %eax
jge 0x47e9
movl -0x18(%rbp), %eax
movzwl -0x12(%rbp), %ecx
addl %ecx, %eax
movzwl -0x20(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4805
movzwl -0x1e(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x478d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/mbf.c
// Function: get_index
int
get_index(Font *font, uint16_t code)
{
    int index;
    uint16_t *cur_code;
    uint16_t codes[] = {code, 0xFFFD, 0x003F, 0x0020, 0};

    for (cur_code = &codes[0]; *cur_code; cur_code++) {
        index = search_glyph(font, *cur_code);
        if (index != -1)
            break;
    };
    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x22(%rbp)
movw $0xfffd, -0x20(%rbp)    # imm = 0xFFFD
movw $0x3f, -0x1e(%rbp)
movw $0x20, -0x1c(%rbp)
movw $0x0, -0x1a(%rbp)
leaq -0x22(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpw $0x0, (%rax)
je 0x4880
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl (%rax), %esi
callq 0x4770
movl %eax, -0x10(%rbp)
cmpl $-0x1, -0x10(%rbp)
je 0x4870
jmp 0x4880
jmp 0x4872
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x484b
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: put_loop
static void
put_loop(GIF *gif, uint16_t loop)
{
    write(gif->fd, (uint8_t []) {'!', 0xFF, 0x0B}, 3);
    write(gif->fd, "NETSCAPE2.0", 11);
    write(gif->fd, (uint8_t []) {0x03, 0x01}, 2);
    write_num(gif->fd, loop);
    write(gif->fd, "\0", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movb $0x21, -0xd(%rbp)
movb $-0x1, -0xc(%rbp)
movb $0xb, -0xb(%rbp)
leaq -0xd(%rbp), %rsi
movl $0x3, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x2ccf(%rip), %rsi      # 0x7771
movl $0xb, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movb $0x3, -0xf(%rbp)
movb $0x1, -0xe(%rbp)
leaq -0xf(%rbp), %rsi
movl $0x2, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0x11(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0x10(%rbp)
leaq -0x11(%rbp), %rsi
movl $0x2, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x2c81(%rip), %rsi      # 0x7783
movl $0x1, %edx
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: add_frame
void
add_frame(GIF *gif, uint16_t d)
{
    uint16_t w, h, x, y;
    uint8_t *tmp;

    if (d)
        set_delay(gif, d);
    if (gif->plt_dirty) {
        w = gif->w; h = gif->h; x = y = 0;
        gif->plt_dirty = 0;
    } else
    if (!get_bbox(gif, &w, &h, &x, &y)) {
        /* image's not changed; save one pixel just to add delay */
        if (!d) return;
        w = h = 1;
        x = y = 0;
    }
    put_image(gif, w, h, x, y);
    tmp = gif->old;
    gif->old = gif->cur;
    gif->cur = tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
cmpw $0x0, -0xa(%rbp)
je 0x4b47
movq -0x8(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x4c10
movq -0x8(%rbp), %rax
cmpb $0x0, 0x2c(%rax)
je 0x4b7e
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0xe(%rbp)
movw $0x0, -0x12(%rbp)
movw $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, 0x2c(%rax)
jmp 0x4bbf
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0xe(%rbp), %rdx
leaq -0x10(%rbp), %rcx
leaq -0x12(%rbp), %r8
callq 0x4ca0
cmpl $0x0, %eax
jne 0x4bbd
cmpw $0x0, -0xa(%rbp)
jne 0x4ba5
jmp 0x4c0a
movw $0x1, -0xe(%rbp)
movw $0x1, -0xc(%rbp)
movw $0x0, -0x12(%rbp)
movw $0x0, -0x10(%rbp)
jmp 0x4bbf
movq -0x8(%rbp), %rdi
movw -0xc(%rbp), %dx
movw -0xe(%rbp), %cx
movw -0x10(%rbp), %ax
movzwl %dx, %esi
movzwl %cx, %edx
movzwl %ax, %ecx
movzwl -0x12(%rbp), %r8d
callq 0x4e10
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: get_bbox
static int
get_bbox(GIF *gif, uint16_t *w, uint16_t *h, uint16_t *x, uint16_t *y)
{
    int i, j, k;
    int left, right, top, bottom;
    left = gif->w; right = 0;
    top = gif->h; bottom = 0;
    k = 0;
    for (i = 0; i < gif->h; i++) {
        for (j = 0; j < gif->w; j++, k++) {
            if (gif->cur[k] != gif->old[k]) {
                if (j < left)   left    = j;
                if (j > right)  right   = j;
                if (i < top)    top     = i;
                if (i > bottom) bottom  = i;
            }
        }
    }
    if (left != gif->w && top != gif->h) {
        *x = left; *y = top;
        *w = right - left + 1;
        *h = bottom - top + 1;
        return 1;
    } else {
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x4d98
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4d88
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x3c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movslq -0x3c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x4d6f
movl -0x38(%rbp), %eax
cmpl -0x40(%rbp), %eax
jge 0x4d43
movl -0x38(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x44(%rbp), %eax
jle 0x4d51
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x4d5f
movl -0x34(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4c(%rbp), %eax
jle 0x4d6d
movl -0x34(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0x4d6f
jmp 0x4d71
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x4d03
jmp 0x4d8a
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x4ce9
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
cmpl %ecx, %eax
je 0x4dfe
movl -0x48(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
je 0x4dfe
movl -0x40(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movl -0x48(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movw %cx, (%rax)
movl -0x44(%rbp), %eax
subl -0x40(%rbp), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movl -0x4c(%rbp), %eax
subl -0x48(%rbp), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x4e05
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: new_trie
static Node *
new_trie(int *nkeys)
{
    Node *root = new_node(0);
    /* Create nodes for single pixels. */
    for (*nkeys = 0; *nkeys < 0x10; (*nkeys)++)
        root->children[*nkeys] = new_node(*nkeys);
    *nkeys += 2; /* skip clear code and stop code */
    return root;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %edi, %edi
callq 0x5300
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x10, (%rax)
jge 0x51d8
movq -0x8(%rbp), %rax
movl (%rax), %eax
movzwl %ax, %edi
callq 0x5300
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x51a1
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x2, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: put_key
static void
put_key(GIF *gif, uint16_t key, int key_size)
{
    int byte_offset, bit_offset, bits_to_write;
    byte_offset = gif->offset / 8;
    bit_offset = gif->offset % 8;
    gif->partial |= ((uint32_t) key) << bit_offset;
    bits_to_write = bit_offset + key_size;
    while (bits_to_write >= 8) {
        gif->buffer[byte_offset++] = gif->partial & 0xFF;
        if (byte_offset == 0xFF) {
            write(gif->fd, "\xFF", 1);
            write(gif->fd, gif->buffer, 0xFF);
            byte_offset = 0;
        }
        gif->partial >>= 8;
        bits_to_write -= 8;
    }
    gif->offset = (gif->offset + key_size) % (0xFF * 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
movzwl -0xa(%rbp), %eax
movl -0x18(%rbp), %ecx
shll %cl, %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
orl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movl -0x18(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jl 0x52d2
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, 0x2d(%rax,%rcx)
cmpl $0xff, -0x14(%rbp)
jne 0x52b7
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x24f4(%rip), %rsi      # 0x7781
movl $0x1, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x2d, %rsi
movl $0xff, %edx
callq 0x1080
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
shrl $0x8, %ecx
movl %ecx, 0x28(%rax)
movl -0x1c(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5248
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x10(%rbp), %eax
movl $0x7f8, %ecx            # imm = 0x7F8
cltd
idivl %ecx
movq -0x8(%rbp), %rax
movl %edx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: new_node
static Node *
new_node(uint16_t key)
{
    Node *node = calloc(1, sizeof(*node));
    if (node)
        node->key = key;
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl $0x1, %edi
movl $0x88, %esi
callq 0x1120
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5334
movw -0x2(%rbp), %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: del_trie
static void
del_trie(Node *root)
{
    int i;

    if (!root)
        return;
    for (i = 0; i < 0x10; i++)
        del_trie(root->children[i]);
    free(root);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5355
jmp 0x5388
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x537f
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x5340
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x535c
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/gif.c
// Function: end_key
static void
end_key(GIF *gif)
{
    int byte_offset;
    byte_offset = gif->offset / 8;
    if (gif->offset % 8)
        gif->buffer[byte_offset++] = gif->partial & 0xFF;
    if (byte_offset) {
	write(gif->fd, (uint8_t []) {byte_offset}, 1);
	write(gif->fd, gif->buffer, byte_offset);
    }
    write(gif->fd, "\0", 1);
    gif->offset = gif->partial = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x8, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x53e6
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, 0x2d(%rax,%rcx)
cmpl $0x0, -0xc(%rbp)
je 0x541f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x2d, %rsi
movslq -0xc(%rbp), %rdx
callq 0x1080
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
leaq 0x2356(%rip), %rsi      # 0x7783
movl $0x1, %edx
callq 0x1080
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lecram[P]congif/main.c
// Function: get_pair
uint8_t
get_pair(Term *term, int row, int col)
{
    Cell cell;
    uint8_t fore, back;
    int inverse;

    inverse = term->mode & M_REVERSE;
    if (term->mode & M_CURSORVIS)
        inverse = term->row == row && term->col == col ? !inverse : inverse;
    cell = term->addr[row][col];
    inverse = cell.attr & A_INVERSE ? !inverse : inverse;
    fore = cell.pair >> 4;
    back = cell.pair & 0xF;
    if (cell.attr & (A_ITALIC | A_CROSSED))
        fore = 0x2;
    else if (cell.attr & A_UNDERLINE)
        fore = 0x6;
    else if (cell.attr & A_DIM)
        fore = 0x8;
    if (inverse) {
        uint8_t t;
        t = fore; fore = back; back = t;
    }
    if (cell.attr & A_BOLD)
        fore |= 0x8;
    if (cell.attr & A_BLINK)
        back |= 0x8;
    if ((cell.attr & A_INVISIBLE) != 0) fore = back;
    return (fore << 4) | (back & 0xF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0x20, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x54c5
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x54b9
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x54b9
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
jmp 0x54bf
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x54fe
cmpl $0x0, -0x1c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x28(%rbp)
jmp 0x5504
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
movzbl -0x11(%rbp), %eax
sarl $0x4, %eax
movb %al, -0x15(%rbp)
movzbl -0x11(%rbp), %eax
andl $0xf, %eax
movb %al, -0x16(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x84, %eax
cmpl $0x0, %eax
je 0x5532
movb $0x2, -0x15(%rbp)
jmp 0x5558
movzbl -0x12(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x5544
movb $0x6, -0x15(%rbp)
jmp 0x5556
movzbl -0x12(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5554
movb $0x8, -0x15(%rbp)
jmp 0x5556
jmp 0x5558
cmpl $0x0, -0x1c(%rbp)
je 0x5570
movb -0x15(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x1d(%rbp), %al
movb %al, -0x16(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5586
movzbl -0x15(%rbp), %eax
orl $0x8, %eax
movb %al, -0x15(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x559c
movzbl -0x16(%rbp), %eax
orl $0x8, %eax
movb %al, -0x16(%rbp)
movzbl -0x12(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x55ae
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %eax
shll $0x4, %eax
movzbl -0x16(%rbp), %ecx
andl $0xf, %ecx
orl %ecx, %eax
popq %rbp
retq