
kernel/bin-x86_64/kernel:     file format elf64-x86-64


Disassembly of section .text:

ffffffff80001000 <bump_alloc>:
#endif

static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE];
static size_t bump_alloc_ptr = 0;

static void *bump_alloc(size_t s) {
ffffffff80001000:	f3 0f 1e fa          	endbr64
    static bool base_offset_added = false;
    if (!base_offset_added) {
ffffffff80001004:	80 3d f5 b0 00 00 00 	cmpb   $0x0,0xb0f5(%rip)        # ffffffff8000c100 <base_offset_added.0>
ffffffff8000100b:	75 07                	jne    ffffffff80001014 <bump_alloc+0x14>
        if ((uintptr_t)bump_alloc_pool & 0xf) {
            bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf);
        }
        base_offset_added = true;
ffffffff8000100d:	c6 05 ec b0 00 00 01 	movb   $0x1,0xb0ec(%rip)        # ffffffff8000c100 <base_offset_added.0>
    }

    if ((s & 0xf) != 0) {
        s += 0x10;
        s &= ~(size_t)0xf;
ffffffff80001014:	48 8d 47 10          	lea    0x10(%rdi),%rax
ffffffff80001018:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
ffffffff8000101c:	40 f6 c7 0f          	test   $0xf,%dil
ffffffff80001020:	48 0f 45 f8          	cmovne %rax,%rdi
    }

    size_t next_ptr = bump_alloc_ptr + s;
ffffffff80001024:	48 8b 05 dd b0 00 00 	mov    0xb0dd(%rip),%rax        # ffffffff8000c108 <bump_alloc_ptr>
ffffffff8000102b:	48 01 c7             	add    %rax,%rdi
    if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) {
ffffffff8000102e:	48 81 ff 28 52 0d 00 	cmp    $0xd5228,%rdi
ffffffff80001035:	77 11                	ja     ffffffff80001048 <bump_alloc+0x48>
        return NULL;
    }
    void *ret = &bump_alloc_pool[bump_alloc_ptr];
    bump_alloc_ptr = next_ptr;
ffffffff80001037:	48 89 3d ca b0 00 00 	mov    %rdi,0xb0ca(%rip)        # ffffffff8000c108 <bump_alloc_ptr>
    void *ret = &bump_alloc_pool[bump_alloc_ptr];
ffffffff8000103e:	48 05 20 c1 00 80    	add    $0xffffffff8000c120,%rax
    return ret;
ffffffff80001044:	c3                   	ret
ffffffff80001045:	0f 1f 00             	nopl   (%rax)
        return NULL;
ffffffff80001048:	31 c0                	xor    %eax,%eax
}
ffffffff8000104a:	c3                   	ret
ffffffff8000104b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001050 <flanterm_fb_save_state>:
    uint32_t g = (colour >> 8) & 0xff;
    uint32_t b =  colour & 0xff;
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
}

static void flanterm_fb_save_state(struct flanterm_context *_ctx) {
ffffffff80001050:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    ctx->saved_state_text_fg = ctx->text_fg;
ffffffff80001054:	48 8b 87 e0 02 00 00 	mov    0x2e0(%rdi),%rax
    ctx->saved_state_text_bg = ctx->text_bg;
    ctx->saved_state_cursor_x = ctx->cursor_x;
ffffffff8000105b:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
    ctx->saved_state_text_fg = ctx->text_fg;
ffffffff80001062:	48 89 87 f8 02 00 00 	mov    %rax,0x2f8(%rdi)
    ctx->saved_state_cursor_x = ctx->cursor_x;
ffffffff80001069:	48 8b 87 f0 02 00 00 	mov    0x2f0(%rdi),%rax
ffffffff80001070:	48 89 97 00 03 00 00 	mov    %rdx,0x300(%rdi)
ffffffff80001077:	48 89 87 08 03 00 00 	mov    %rax,0x308(%rdi)
    ctx->saved_state_cursor_y = ctx->cursor_y;
}
ffffffff8000107e:	c3                   	ret
ffffffff8000107f:	90                   	nop

ffffffff80001080 <flanterm_fb_restore_state>:

static void flanterm_fb_restore_state(struct flanterm_context *_ctx) {
ffffffff80001080:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    ctx->text_fg = ctx->saved_state_text_fg;
ffffffff80001084:	48 8b 87 f8 02 00 00 	mov    0x2f8(%rdi),%rax
    ctx->text_bg = ctx->saved_state_text_bg;
    ctx->cursor_x = ctx->saved_state_cursor_x;
ffffffff8000108b:	48 8b 97 00 03 00 00 	mov    0x300(%rdi),%rdx
    ctx->text_fg = ctx->saved_state_text_fg;
ffffffff80001092:	48 89 87 e0 02 00 00 	mov    %rax,0x2e0(%rdi)
    ctx->cursor_x = ctx->saved_state_cursor_x;
ffffffff80001099:	48 8b 87 08 03 00 00 	mov    0x308(%rdi),%rax
ffffffff800010a0:	48 89 97 e8 02 00 00 	mov    %rdx,0x2e8(%rdi)
ffffffff800010a7:	48 89 87 f0 02 00 00 	mov    %rax,0x2f0(%rdi)
    ctx->cursor_y = ctx->saved_state_cursor_y;
}
ffffffff800010ae:	c3                   	ret
ffffffff800010af:	90                   	nop

ffffffff800010b0 <flanterm_fb_swap_palette>:

static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) {
ffffffff800010b0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    uint32_t tmp = ctx->text_bg;
    ctx->text_bg = ctx->text_fg;
    ctx->text_fg = tmp;
ffffffff800010b4:	8b 97 e0 02 00 00    	mov    0x2e0(%rdi),%edx
ffffffff800010ba:	8b 87 e4 02 00 00    	mov    0x2e4(%rdi),%eax
ffffffff800010c0:	48 c1 e2 20          	shl    $0x20,%rdx
ffffffff800010c4:	48 09 d0             	or     %rdx,%rax
ffffffff800010c7:	48 89 87 e0 02 00 00 	mov    %rax,0x2e0(%rdi)
}
ffffffff800010ce:	c3                   	ret
ffffffff800010cf:	90                   	nop

ffffffff800010d0 <push_to_queue>:

static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
}

static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff800010d0:	49 89 f0             	mov    %rsi,%r8
ffffffff800010d3:	48 89 ce             	mov    %rcx,%rsi
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff800010d6:	48 8b 8f e8 00 00 00 	mov    0xe8(%rdi),%rcx
static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff800010dd:	48 89 f8             	mov    %rdi,%rax
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff800010e0:	48 39 ca             	cmp    %rcx,%rdx
ffffffff800010e3:	73 31                	jae    ffffffff80001116 <push_to_queue+0x46>
ffffffff800010e5:	48 3b b7 e0 00 00 00 	cmp    0xe0(%rdi),%rsi
ffffffff800010ec:	73 28                	jae    ffffffff80001116 <push_to_queue+0x46>
        return;
    }

    size_t i = y * _ctx->cols + x;
ffffffff800010ee:	48 0f af ce          	imul   %rsi,%rcx

    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800010f2:	48 8b bf d8 02 00 00 	mov    0x2d8(%rdi),%rdi
    size_t i = y * _ctx->cols + x;
ffffffff800010f9:	48 01 d1             	add    %rdx,%rcx
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800010fc:	4c 8d 0c cf          	lea    (%rdi,%rcx,8),%r9
ffffffff80001100:	49 8b 39             	mov    (%r9),%rdi

    if (q == NULL) {
ffffffff80001103:	48 85 ff             	test   %rdi,%rdi
ffffffff80001106:	74 18                	je     ffffffff80001120 <push_to_queue+0x50>
        q->x = x;
        q->y = y;
        ctx->map[i] = q;
    }

    q->c = *c;
ffffffff80001108:	49 8b 00             	mov    (%r8),%rax
ffffffff8000110b:	48 89 47 10          	mov    %rax,0x10(%rdi)
ffffffff8000110f:	41 8b 40 08          	mov    0x8(%r8),%eax
ffffffff80001113:	89 47 18             	mov    %eax,0x18(%rdi)
}
ffffffff80001116:	c3                   	ret
ffffffff80001117:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000111e:	00 00 
        if (compare_char(&ctx->grid[i], c)) {
ffffffff80001120:	48 8d 3c 49          	lea    (%rcx,%rcx,2),%rdi
ffffffff80001124:	48 8b 88 c0 02 00 00 	mov    0x2c0(%rax),%rcx
ffffffff8000112b:	48 8d 0c b9          	lea    (%rcx,%rdi,4),%rcx
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
ffffffff8000112f:	41 8b 38             	mov    (%r8),%edi
ffffffff80001132:	39 39                	cmp    %edi,(%rcx)
ffffffff80001134:	74 2a                	je     ffffffff80001160 <push_to_queue+0x90>
        q = &ctx->queue[ctx->queue_i++];
ffffffff80001136:	48 8b b8 d0 02 00 00 	mov    0x2d0(%rax),%rdi
ffffffff8000113d:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
ffffffff80001141:	48 c1 e7 05          	shl    $0x5,%rdi
ffffffff80001145:	48 03 b8 c8 02 00 00 	add    0x2c8(%rax),%rdi
ffffffff8000114c:	48 89 88 d0 02 00 00 	mov    %rcx,0x2d0(%rax)
        q->x = x;
ffffffff80001153:	48 89 17             	mov    %rdx,(%rdi)
        q->y = y;
ffffffff80001156:	48 89 77 08          	mov    %rsi,0x8(%rdi)
        ctx->map[i] = q;
ffffffff8000115a:	49 89 39             	mov    %rdi,(%r9)
ffffffff8000115d:	eb a9                	jmp    ffffffff80001108 <push_to_queue+0x38>
ffffffff8000115f:	90                   	nop
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
ffffffff80001160:	41 8b 78 08          	mov    0x8(%r8),%edi
ffffffff80001164:	39 79 08             	cmp    %edi,0x8(%rcx)
ffffffff80001167:	75 cd                	jne    ffffffff80001136 <push_to_queue+0x66>
ffffffff80001169:	41 8b 78 04          	mov    0x4(%r8),%edi
ffffffff8000116d:	39 79 04             	cmp    %edi,0x4(%rcx)
ffffffff80001170:	75 c4                	jne    ffffffff80001136 <push_to_queue+0x66>
}
ffffffff80001172:	c3                   	ret
ffffffff80001173:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000117a:	00 00 00 
ffffffff8000117d:	0f 1f 00             	nopl   (%rax)

ffffffff80001180 <flanterm_fb_revscroll>:

static void flanterm_fb_revscroll(struct flanterm_context *_ctx) {
ffffffff80001180:	f3 0f 1e fa          	endbr64
ffffffff80001184:	41 55                	push   %r13
ffffffff80001186:	41 54                	push   %r12
ffffffff80001188:	55                   	push   %rbp
ffffffff80001189:	53                   	push   %rbx
ffffffff8000118a:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000118d:	48 83 ec 10          	sub    $0x10,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff80001191:	48 8b 47 70          	mov    0x70(%rdi),%rax
ffffffff80001195:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff8000119c:	48 8b 6f 68          	mov    0x68(%rdi),%rbp
    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff800011a0:	48 83 e8 01          	sub    $0x1,%rax
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff800011a4:	4d 89 dc             	mov    %r11,%r12
    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff800011a7:	49 0f af c3          	imul   %r11,%rax
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff800011ab:	4c 0f af e5          	imul   %rbp,%r12
        if (i == (size_t)-1) {
ffffffff800011af:	48 85 c0             	test   %rax,%rax
ffffffff800011b2:	74 5c                	je     ffffffff80001210 <flanterm_fb_revscroll+0x90>
ffffffff800011b4:	4c 8d 50 ff          	lea    -0x1(%rax),%r10
ffffffff800011b8:	4d 39 e2             	cmp    %r12,%r10
ffffffff800011bb:	72 53                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
            break;
        }
        struct flanterm_fb_char *c;
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800011bd:	4c 8b af d8 02 00 00 	mov    0x2d8(%rdi),%r13
ffffffff800011c4:	eb 2d                	jmp    ffffffff800011f3 <flanterm_fb_revscroll+0x73>
ffffffff800011c6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800011cd:	00 00 00 
        if (q != NULL) {
            c = &q->c;
ffffffff800011d0:	48 83 c6 10          	add    $0x10,%rsi
        } else {
            c = &ctx->grid[i];
        }
        push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols);
ffffffff800011d4:	4b 8d 04 13          	lea    (%r11,%r10,1),%rax
ffffffff800011d8:	31 d2                	xor    %edx,%edx
ffffffff800011da:	48 89 df             	mov    %rbx,%rdi
ffffffff800011dd:	49 f7 f3             	div    %r11
ffffffff800011e0:	48 89 c1             	mov    %rax,%rcx
ffffffff800011e3:	e8 e8 fe ff ff       	call   ffffffff800010d0 <push_to_queue>
        if (i == (size_t)-1) {
ffffffff800011e8:	49 83 ea 01          	sub    $0x1,%r10
ffffffff800011ec:	72 22                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
ffffffff800011ee:	4d 39 e2             	cmp    %r12,%r10
ffffffff800011f1:	72 1d                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800011f3:	4b 8b 74 d5 00       	mov    0x0(%r13,%r10,8),%rsi
        if (q != NULL) {
ffffffff800011f8:	48 85 f6             	test   %rsi,%rsi
ffffffff800011fb:	75 d3                	jne    ffffffff800011d0 <flanterm_fb_revscroll+0x50>
            c = &ctx->grid[i];
ffffffff800011fd:	48 8b 93 c0 02 00 00 	mov    0x2c0(%rbx),%rdx
ffffffff80001204:	4b 8d 04 52          	lea    (%r10,%r10,2),%rax
ffffffff80001208:	48 8d 34 82          	lea    (%rdx,%rax,4),%rsi
ffffffff8000120c:	eb c6                	jmp    ffffffff800011d4 <flanterm_fb_revscroll+0x54>
ffffffff8000120e:	66 90                	xchg   %ax,%ax
    }

    // Clear the first line of the screen.
    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
ffffffff80001210:	48 8b 83 e0 02 00 00 	mov    0x2e0(%rbx),%rax
    empty.c  = ' ';
ffffffff80001217:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff8000121e:	00 
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff8000121f:	31 d2                	xor    %edx,%edx
    empty.fg = ctx->text_fg;
ffffffff80001221:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001226:	4d 85 db             	test   %r11,%r11
ffffffff80001229:	74 1e                	je     ffffffff80001249 <flanterm_fb_revscroll+0xc9>
ffffffff8000122b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin);
ffffffff80001230:	48 89 e9             	mov    %rbp,%rcx
ffffffff80001233:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff80001238:	48 89 df             	mov    %rbx,%rdi
ffffffff8000123b:	e8 90 fe ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001240:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001244:	49 39 d3             	cmp    %rdx,%r11
ffffffff80001247:	75 e7                	jne    ffffffff80001230 <flanterm_fb_revscroll+0xb0>
    }
}
ffffffff80001249:	48 83 c4 10          	add    $0x10,%rsp
ffffffff8000124d:	5b                   	pop    %rbx
ffffffff8000124e:	5d                   	pop    %rbp
ffffffff8000124f:	41 5c                	pop    %r12
ffffffff80001251:	41 5d                	pop    %r13
ffffffff80001253:	c3                   	ret
ffffffff80001254:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000125b:	00 00 00 
ffffffff8000125e:	66 90                	xchg   %ax,%ax

ffffffff80001260 <flanterm_fb_scroll>:

static void flanterm_fb_scroll(struct flanterm_context *_ctx) {
ffffffff80001260:	f3 0f 1e fa          	endbr64
ffffffff80001264:	41 56                	push   %r14
ffffffff80001266:	41 55                	push   %r13
ffffffff80001268:	41 54                	push   %r12
ffffffff8000126a:	55                   	push   %rbp
ffffffff8000126b:	53                   	push   %rbx
ffffffff8000126c:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000126f:	48 83 ec 10          	sub    $0x10,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001273:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
ffffffff8000127a:	48 8b 47 68          	mov    0x68(%rdi),%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff8000127e:	48 8b 6f 70          	mov    0x70(%rdi),%rbp
    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001282:	48 83 c0 01          	add    $0x1,%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff80001286:	4d 89 dc             	mov    %r11,%r12
    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001289:	49 0f af c3          	imul   %r11,%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff8000128d:	4c 0f af e5          	imul   %rbp,%r12
ffffffff80001291:	4c 39 e0             	cmp    %r12,%rax
ffffffff80001294:	73 62                	jae    ffffffff800012f8 <flanterm_fb_scroll+0x98>
ffffffff80001296:	49 89 c2             	mov    %rax,%r10
ffffffff80001299:	4c 8d 34 40          	lea    (%rax,%rax,2),%r14
ffffffff8000129d:	48 8b 87 d8 02 00 00 	mov    0x2d8(%rdi),%rax
ffffffff800012a4:	4d 29 dc             	sub    %r11,%r12
ffffffff800012a7:	4d 29 da             	sub    %r11,%r10
ffffffff800012aa:	49 c1 e6 02          	shl    $0x2,%r14
ffffffff800012ae:	4e 8d 2c d8          	lea    (%rax,%r11,8),%r13
ffffffff800012b2:	eb 28                	jmp    ffffffff800012dc <flanterm_fb_scroll+0x7c>
ffffffff800012b4:	0f 1f 40 00          	nopl   0x0(%rax)
        struct flanterm_fb_char *c;
        struct flanterm_fb_queue_item *q = ctx->map[i];
        if (q != NULL) {
            c = &q->c;
ffffffff800012b8:	48 83 c6 10          	add    $0x10,%rsi
        } else {
            c = &ctx->grid[i];
        }
        push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);
ffffffff800012bc:	4c 89 d0             	mov    %r10,%rax
ffffffff800012bf:	31 d2                	xor    %edx,%edx
ffffffff800012c1:	48 89 df             	mov    %rbx,%rdi
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff800012c4:	49 83 c2 01          	add    $0x1,%r10
ffffffff800012c8:	49 f7 f3             	div    %r11
ffffffff800012cb:	49 83 c6 0c          	add    $0xc,%r14
ffffffff800012cf:	48 89 c1             	mov    %rax,%rcx
        push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);
ffffffff800012d2:	e8 f9 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff800012d7:	4d 39 d4             	cmp    %r10,%r12
ffffffff800012da:	74 1c                	je     ffffffff800012f8 <flanterm_fb_scroll+0x98>
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800012dc:	4b 8b 74 d5 00       	mov    0x0(%r13,%r10,8),%rsi
        if (q != NULL) {
ffffffff800012e1:	48 85 f6             	test   %rsi,%rsi
ffffffff800012e4:	75 d2                	jne    ffffffff800012b8 <flanterm_fb_scroll+0x58>
            c = &ctx->grid[i];
ffffffff800012e6:	48 8b b3 c0 02 00 00 	mov    0x2c0(%rbx),%rsi
ffffffff800012ed:	4c 01 f6             	add    %r14,%rsi
ffffffff800012f0:	eb ca                	jmp    ffffffff800012bc <flanterm_fb_scroll+0x5c>
ffffffff800012f2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    }

    // Clear the last line of the screen.
    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
ffffffff800012f8:	48 8b 83 e0 02 00 00 	mov    0x2e0(%rbx),%rax
    empty.c  = ' ';
ffffffff800012ff:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff80001306:	00 
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->cols; i++) {
        push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);
ffffffff80001307:	48 83 ed 01          	sub    $0x1,%rbp
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff8000130b:	31 d2                	xor    %edx,%edx
    empty.fg = ctx->text_fg;
ffffffff8000130d:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001312:	4d 85 db             	test   %r11,%r11
ffffffff80001315:	74 22                	je     ffffffff80001339 <flanterm_fb_scroll+0xd9>
ffffffff80001317:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000131e:	00 00 
        push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);
ffffffff80001320:	48 89 e9             	mov    %rbp,%rcx
ffffffff80001323:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff80001328:	48 89 df             	mov    %rbx,%rdi
ffffffff8000132b:	e8 a0 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001330:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001334:	49 39 d3             	cmp    %rdx,%r11
ffffffff80001337:	75 e7                	jne    ffffffff80001320 <flanterm_fb_scroll+0xc0>
    }
}
ffffffff80001339:	48 83 c4 10          	add    $0x10,%rsp
ffffffff8000133d:	5b                   	pop    %rbx
ffffffff8000133e:	5d                   	pop    %rbp
ffffffff8000133f:	41 5c                	pop    %r12
ffffffff80001341:	41 5d                	pop    %r13
ffffffff80001343:	41 5e                	pop    %r14
ffffffff80001345:	c3                   	ret
ffffffff80001346:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000134d:	00 00 00 

ffffffff80001350 <flanterm_fb_clear>:

static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) {
ffffffff80001350:	f3 0f 1e fa          	endbr64
ffffffff80001354:	41 54                	push   %r12
ffffffff80001356:	41 89 f4             	mov    %esi,%r12d
ffffffff80001359:	55                   	push   %rbp
ffffffff8000135a:	53                   	push   %rbx
ffffffff8000135b:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000135e:	48 83 ec 10          	sub    $0x10,%rsp

    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80001362:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
ffffffff80001369:	48 8b af e0 00 00 00 	mov    0xe0(%rdi),%rbp
    empty.fg = ctx->text_fg;
ffffffff80001370:	48 8b 87 e0 02 00 00 	mov    0x2e0(%rdi),%rax
    empty.c  = ' ';
ffffffff80001377:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff8000137e:	00 
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff8000137f:	49 0f af eb          	imul   %r11,%rbp
    empty.fg = ctx->text_fg;
ffffffff80001383:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80001388:	48 85 ed             	test   %rbp,%rbp
ffffffff8000138b:	74 24                	je     ffffffff800013b1 <flanterm_fb_clear+0x61>
ffffffff8000138d:	45 31 d2             	xor    %r10d,%r10d
        push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);
ffffffff80001390:	4c 89 d0             	mov    %r10,%rax
ffffffff80001393:	31 d2                	xor    %edx,%edx
ffffffff80001395:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff8000139a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000139d:	49 f7 f3             	div    %r11
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800013a0:	49 83 c2 01          	add    $0x1,%r10
ffffffff800013a4:	48 89 c1             	mov    %rax,%rcx
        push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);
ffffffff800013a7:	e8 24 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800013ac:	49 39 ea             	cmp    %rbp,%r10
ffffffff800013af:	75 df                	jne    ffffffff80001390 <flanterm_fb_clear+0x40>
    }

    if (move) {
ffffffff800013b1:	45 84 e4             	test   %r12b,%r12b
ffffffff800013b4:	74 16                	je     ffffffff800013cc <flanterm_fb_clear+0x7c>
        ctx->cursor_x = 0;
ffffffff800013b6:	48 c7 83 e8 02 00 00 	movq   $0x0,0x2e8(%rbx)
ffffffff800013bd:	00 00 00 00 
        ctx->cursor_y = 0;
ffffffff800013c1:	48 c7 83 f0 02 00 00 	movq   $0x0,0x2f0(%rbx)
ffffffff800013c8:	00 00 00 00 
    }
}
ffffffff800013cc:	48 83 c4 10          	add    $0x10,%rsp
ffffffff800013d0:	5b                   	pop    %rbx
ffffffff800013d1:	5d                   	pop    %rbp
ffffffff800013d2:	41 5c                	pop    %r12
ffffffff800013d4:	c3                   	ret
ffffffff800013d5:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800013dc:	00 00 00 
ffffffff800013df:	90                   	nop

ffffffff800013e0 <flanterm_fb_set_cursor_pos>:

static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) {
ffffffff800013e0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (x >= _ctx->cols) {
ffffffff800013e4:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff800013eb:	48 39 c6             	cmp    %rax,%rsi
ffffffff800013ee:	72 0f                	jb     ffffffff800013ff <flanterm_fb_set_cursor_pos+0x1f>
        if ((int)x < 0) {
            x = 0;
        } else {
            x = _ctx->cols - 1;
ffffffff800013f0:	48 83 e8 01          	sub    $0x1,%rax
ffffffff800013f4:	85 f6                	test   %esi,%esi
ffffffff800013f6:	be 00 00 00 00       	mov    $0x0,%esi
ffffffff800013fb:	48 0f 49 f0          	cmovns %rax,%rsi
        }
    }
    if (y >= _ctx->rows) {
ffffffff800013ff:	48 8b 87 e0 00 00 00 	mov    0xe0(%rdi),%rax
ffffffff80001406:	48 39 c2             	cmp    %rax,%rdx
ffffffff80001409:	72 0f                	jb     ffffffff8000141a <flanterm_fb_set_cursor_pos+0x3a>
        if ((int)y < 0) {
            y = 0;
        } else {
            y = _ctx->rows - 1;
ffffffff8000140b:	48 83 e8 01          	sub    $0x1,%rax
ffffffff8000140f:	85 d2                	test   %edx,%edx
ffffffff80001411:	ba 00 00 00 00       	mov    $0x0,%edx
ffffffff80001416:	48 0f 49 d0          	cmovns %rax,%rdx
        }
    }
    ctx->cursor_x = x;
ffffffff8000141a:	48 89 b7 e8 02 00 00 	mov    %rsi,0x2e8(%rdi)
    ctx->cursor_y = y;
ffffffff80001421:	48 89 97 f0 02 00 00 	mov    %rdx,0x2f0(%rdi)
}
ffffffff80001428:	c3                   	ret
ffffffff80001429:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80001430 <flanterm_fb_get_cursor_pos>:

static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {
ffffffff80001430:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;
ffffffff80001434:	48 8b 87 e8 02 00 00 	mov    0x2e8(%rdi),%rax
static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {
ffffffff8000143b:	48 89 d1             	mov    %rdx,%rcx
    *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;
ffffffff8000143e:	48 8b 97 e8 00 00 00 	mov    0xe8(%rdi),%rdx
ffffffff80001445:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001448:	4c 8d 42 ff          	lea    -0x1(%rdx),%r8
ffffffff8000144c:	49 0f 43 c0          	cmovae %r8,%rax
ffffffff80001450:	48 89 06             	mov    %rax,(%rsi)
    *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y;
ffffffff80001453:	48 8b 87 f0 02 00 00 	mov    0x2f0(%rdi),%rax
ffffffff8000145a:	48 8b 97 e0 00 00 00 	mov    0xe0(%rdi),%rdx
ffffffff80001461:	48 8d 72 ff          	lea    -0x1(%rdx),%rsi
ffffffff80001465:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001468:	48 0f 43 c6          	cmovae %rsi,%rax
ffffffff8000146c:	48 89 01             	mov    %rax,(%rcx)
}
ffffffff8000146f:	c3                   	ret

ffffffff80001470 <flanterm_fb_move_character>:

static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) {
ffffffff80001470:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (old_x >= _ctx->cols || old_y >= _ctx->rows
ffffffff80001474:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff8000147b:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000147e:	73 1f                	jae    ffffffff8000149f <flanterm_fb_move_character+0x2f>
ffffffff80001480:	4c 8b 97 e0 00 00 00 	mov    0xe0(%rdi),%r10
     || new_x >= _ctx->cols || new_y >= _ctx->rows) {
ffffffff80001487:	48 39 c6             	cmp    %rax,%rsi
ffffffff8000148a:	41 0f 93 c1          	setae  %r9b
    if (old_x >= _ctx->cols || old_y >= _ctx->rows
ffffffff8000148e:	4d 39 d0             	cmp    %r10,%r8
ffffffff80001491:	41 0f 93 c3          	setae  %r11b
     || new_x >= _ctx->cols || new_y >= _ctx->rows) {
ffffffff80001495:	45 08 d9             	or     %r11b,%r9b
ffffffff80001498:	75 05                	jne    ffffffff8000149f <flanterm_fb_move_character+0x2f>
ffffffff8000149a:	4c 39 d2             	cmp    %r10,%rdx
ffffffff8000149d:	72 01                	jb     ffffffff800014a0 <flanterm_fb_move_character+0x30>
    } else {
        c = &ctx->grid[i];
    }

    push_to_queue(_ctx, c, new_x, new_y);
}
ffffffff8000149f:	c3                   	ret
    size_t i = old_x + old_y * _ctx->cols;
ffffffff800014a0:	49 0f af c0          	imul   %r8,%rax
ffffffff800014a4:	48 01 c8             	add    %rcx,%rax
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800014a7:	48 8b 8f d8 02 00 00 	mov    0x2d8(%rdi),%rcx
ffffffff800014ae:	48 8b 0c c1          	mov    (%rcx,%rax,8),%rcx
    if (q != NULL) {
ffffffff800014b2:	48 85 c9             	test   %rcx,%rcx
ffffffff800014b5:	74 19                	je     ffffffff800014d0 <flanterm_fb_move_character+0x60>
        c = &q->c;
ffffffff800014b7:	48 8d 41 10          	lea    0x10(%rcx),%rax
    push_to_queue(_ctx, c, new_x, new_y);
ffffffff800014bb:	48 89 d1             	mov    %rdx,%rcx
ffffffff800014be:	48 89 f2             	mov    %rsi,%rdx
ffffffff800014c1:	48 89 c6             	mov    %rax,%rsi
ffffffff800014c4:	e9 07 fc ff ff       	jmp    ffffffff800010d0 <push_to_queue>
ffffffff800014c9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        c = &ctx->grid[i];
ffffffff800014d0:	48 8d 0c 40          	lea    (%rax,%rax,2),%rcx
ffffffff800014d4:	48 8b 87 c0 02 00 00 	mov    0x2c0(%rdi),%rax
ffffffff800014db:	48 8d 04 88          	lea    (%rax,%rcx,4),%rax
ffffffff800014df:	eb da                	jmp    ffffffff800014bb <flanterm_fb_move_character+0x4b>
ffffffff800014e1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800014e8:	00 00 00 
ffffffff800014eb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff800014f0 <flanterm_fb_set_text_fg>:

static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) {
ffffffff800014f0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->ansi_colours[fg];
ffffffff800014f4:	8b 84 b7 48 02 00 00 	mov    0x248(%rdi,%rsi,4),%eax
ffffffff800014fb:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001501:	c3                   	ret
ffffffff80001502:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001509:	00 00 00 
ffffffff8000150c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001510 <flanterm_fb_set_text_bg>:

static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) {
ffffffff80001510:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->ansi_colours[bg];
ffffffff80001514:	8b 84 b7 48 02 00 00 	mov    0x248(%rdi,%rsi,4),%eax
ffffffff8000151b:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001521:	c3                   	ret
ffffffff80001522:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001529:	00 00 00 
ffffffff8000152c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001530 <flanterm_fb_set_text_fg_bright>:

static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) {
ffffffff80001530:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->ansi_bright_colours[fg];
ffffffff80001534:	8b 84 b7 68 02 00 00 	mov    0x268(%rdi,%rsi,4),%eax
ffffffff8000153b:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001541:	c3                   	ret
ffffffff80001542:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001549:	00 00 00 
ffffffff8000154c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001550 <flanterm_fb_set_text_bg_bright>:

static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) {
ffffffff80001550:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->ansi_bright_colours[bg];
ffffffff80001554:	8b 84 b7 68 02 00 00 	mov    0x268(%rdi,%rsi,4),%eax
ffffffff8000155b:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001561:	c3                   	ret
ffffffff80001562:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001569:	00 00 00 
ffffffff8000156c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001570 <flanterm_fb_set_text_fg_rgb>:

static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {
ffffffff80001570:	f3 0f 1e fa          	endbr64
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80001574:	89 f0                	mov    %esi,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80001576:	0f b6 8f 21 02 00 00 	movzbl 0x221(%rdi),%ecx
static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {
ffffffff8000157d:	89 f2                	mov    %esi,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000157f:	c1 e8 10             	shr    $0x10,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80001582:	0f b6 f6             	movzbl %dh,%esi
    uint32_t b =  colour & 0xff;
ffffffff80001585:	0f b6 d2             	movzbl %dl,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80001588:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000158b:	d3 e0                	shl    %cl,%eax
ffffffff8000158d:	0f b6 8f 23 02 00 00 	movzbl 0x223(%rdi),%ecx
ffffffff80001594:	d3 e6                	shl    %cl,%esi
ffffffff80001596:	0f b6 8f 25 02 00 00 	movzbl 0x225(%rdi),%ecx
ffffffff8000159d:	09 f0                	or     %esi,%eax
ffffffff8000159f:	d3 e2                	shl    %cl,%edx
ffffffff800015a1:	09 d0                	or     %edx,%eax
ffffffff800015a3:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = convert_colour(_ctx, fg);
}
ffffffff800015a9:	c3                   	ret
ffffffff800015aa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800015b0 <flanterm_fb_set_text_bg_rgb>:

static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {
ffffffff800015b0:	f3 0f 1e fa          	endbr64
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015b4:	89 f0                	mov    %esi,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800015b6:	0f b6 8f 21 02 00 00 	movzbl 0x221(%rdi),%ecx
static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {
ffffffff800015bd:	89 f2                	mov    %esi,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015bf:	c1 e8 10             	shr    $0x10,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800015c2:	0f b6 f6             	movzbl %dh,%esi
    uint32_t b =  colour & 0xff;
ffffffff800015c5:	0f b6 d2             	movzbl %dl,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015c8:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800015cb:	d3 e0                	shl    %cl,%eax
ffffffff800015cd:	0f b6 8f 23 02 00 00 	movzbl 0x223(%rdi),%ecx
ffffffff800015d4:	d3 e6                	shl    %cl,%esi
ffffffff800015d6:	0f b6 8f 25 02 00 00 	movzbl 0x225(%rdi),%ecx
ffffffff800015dd:	09 f0                	or     %esi,%eax
ffffffff800015df:	d3 e2                	shl    %cl,%edx
ffffffff800015e1:	09 d0                	or     %edx,%eax
ffffffff800015e3:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = convert_colour(_ctx, bg);
}
ffffffff800015e9:	c3                   	ret
ffffffff800015ea:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800015f0 <flanterm_fb_set_text_fg_default>:

static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) {
ffffffff800015f0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->default_fg;
ffffffff800015f4:	8b 87 88 02 00 00    	mov    0x288(%rdi),%eax
ffffffff800015fa:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001600:	c3                   	ret
ffffffff80001601:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001608:	00 00 00 
ffffffff8000160b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001610 <flanterm_fb_set_text_bg_default>:

static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) {
ffffffff80001610:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = 0xffffffff;
ffffffff80001614:	c7 87 e4 02 00 00 ff 	movl   $0xffffffff,0x2e4(%rdi)
ffffffff8000161b:	ff ff ff 
}
ffffffff8000161e:	c3                   	ret
ffffffff8000161f:	90                   	nop

ffffffff80001620 <flanterm_fb_set_text_fg_default_bright>:

static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) {
ffffffff80001620:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->default_fg_bright;
ffffffff80001624:	8b 87 90 02 00 00    	mov    0x290(%rdi),%eax
ffffffff8000162a:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001630:	c3                   	ret
ffffffff80001631:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001638:	00 00 00 
ffffffff8000163b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001640 <flanterm_fb_set_text_bg_default_bright>:

static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) {
ffffffff80001640:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->default_bg_bright;
ffffffff80001644:	8b 87 94 02 00 00    	mov    0x294(%rdi),%eax
ffffffff8000164a:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001650:	c3                   	ret
ffffffff80001651:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001658:	00 00 00 
ffffffff8000165b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001660 <draw_cursor>:

static void draw_cursor(struct flanterm_context *_ctx) {
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {
ffffffff80001660:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
ffffffff80001667:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff8000166e:	48 39 c2             	cmp    %rax,%rdx
ffffffff80001671:	0f 83 a1 00 00 00    	jae    ffffffff80001718 <draw_cursor+0xb8>
static void draw_cursor(struct flanterm_context *_ctx) {
ffffffff80001677:	41 55                	push   %r13
ffffffff80001679:	41 54                	push   %r12
ffffffff8000167b:	55                   	push   %rbp
ffffffff8000167c:	53                   	push   %rbx
ffffffff8000167d:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001680:	48 83 ec 18          	sub    $0x18,%rsp
    if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {
ffffffff80001684:	48 8b 8f f0 02 00 00 	mov    0x2f0(%rdi),%rcx
ffffffff8000168b:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001692:	73 73                	jae    ffffffff80001707 <draw_cursor+0xa7>
        return;
    }

    size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;
ffffffff80001694:	48 0f af c1          	imul   %rcx,%rax
        c = ctx->grid[i];
    }
    uint32_t tmp = c.fg;
    c.fg = c.bg;
    c.bg = tmp;
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff80001698:	4c 8b 87 b0 01 00 00 	mov    0x1b0(%rdi),%r8
    size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;
ffffffff8000169f:	48 8d 2c 10          	lea    (%rax,%rdx,1),%rbp
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800016a3:	48 8b 87 d8 02 00 00 	mov    0x2d8(%rdi),%rax
    if (q != NULL) {
        ctx->grid[i] = q->c;
ffffffff800016aa:	4c 8d 64 6d 00       	lea    0x0(%rbp,%rbp,2),%r12
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800016af:	4c 8b 2c e8          	mov    (%rax,%rbp,8),%r13
        ctx->grid[i] = q->c;
ffffffff800016b3:	49 c1 e4 02          	shl    $0x2,%r12
    if (q != NULL) {
ffffffff800016b7:	4d 85 ed             	test   %r13,%r13
ffffffff800016ba:	74 64                	je     ffffffff80001720 <draw_cursor+0xc0>
        c = q->c;
ffffffff800016bc:	49 8b 45 10          	mov    0x10(%r13),%rax
ffffffff800016c0:	48 89 44 24 04       	mov    %rax,0x4(%rsp)
ffffffff800016c5:	48 89 c6             	mov    %rax,%rsi
ffffffff800016c8:	41 8b 45 18          	mov    0x18(%r13),%eax
ffffffff800016cc:	48 c1 ee 20          	shr    $0x20,%rsi
    c.fg = c.bg;
ffffffff800016d0:	89 44 24 08          	mov    %eax,0x8(%rsp)
    c.bg = tmp;
ffffffff800016d4:	89 74 24 0c          	mov    %esi,0xc(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff800016d8:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff800016dd:	41 ff d0             	call   *%r8
        ctx->grid[i] = q->c;
ffffffff800016e0:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff800016e7:	49 8b 55 10          	mov    0x10(%r13),%rdx
ffffffff800016eb:	4a 89 14 20          	mov    %rdx,(%rax,%r12,1)
ffffffff800016ef:	41 8b 55 18          	mov    0x18(%r13),%edx
ffffffff800016f3:	42 89 54 20 08       	mov    %edx,0x8(%rax,%r12,1)
        ctx->map[i] = NULL;
ffffffff800016f8:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff800016ff:	48 c7 04 e8 00 00 00 	movq   $0x0,(%rax,%rbp,8)
ffffffff80001706:	00 
    }
}
ffffffff80001707:	48 83 c4 18          	add    $0x18,%rsp
ffffffff8000170b:	5b                   	pop    %rbx
ffffffff8000170c:	5d                   	pop    %rbp
ffffffff8000170d:	41 5c                	pop    %r12
ffffffff8000170f:	41 5d                	pop    %r13
ffffffff80001711:	c3                   	ret
ffffffff80001712:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff80001718:	c3                   	ret
ffffffff80001719:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        c = ctx->grid[i];
ffffffff80001720:	48 8b 87 c0 02 00 00 	mov    0x2c0(%rdi),%rax
ffffffff80001727:	4a 8b 34 20          	mov    (%rax,%r12,1),%rsi
ffffffff8000172b:	48 89 74 24 04       	mov    %rsi,0x4(%rsp)
ffffffff80001730:	42 8b 74 20 08       	mov    0x8(%rax,%r12,1),%esi
    uint32_t tmp = c.fg;
ffffffff80001735:	8b 44 24 08          	mov    0x8(%rsp),%eax
    c.fg = c.bg;
ffffffff80001739:	89 74 24 08          	mov    %esi,0x8(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff8000173d:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
    c.bg = tmp;
ffffffff80001742:	89 44 24 0c          	mov    %eax,0xc(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff80001746:	41 ff d0             	call   *%r8
}
ffffffff80001749:	48 83 c4 18          	add    $0x18,%rsp
ffffffff8000174d:	5b                   	pop    %rbx
ffffffff8000174e:	5d                   	pop    %rbp
ffffffff8000174f:	41 5c                	pop    %r12
ffffffff80001751:	41 5d                	pop    %r13
ffffffff80001753:	c3                   	ret
ffffffff80001754:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000175b:	00 00 00 
ffffffff8000175e:	66 90                	xchg   %ax,%ax

ffffffff80001760 <flanterm_fb_double_buffer_flush>:

static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) {
ffffffff80001760:	f3 0f 1e fa          	endbr64
ffffffff80001764:	41 55                	push   %r13
ffffffff80001766:	41 54                	push   %r12
ffffffff80001768:	55                   	push   %rbp
ffffffff80001769:	53                   	push   %rbx
ffffffff8000176a:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000176d:	48 83 ec 08          	sub    $0x8,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (_ctx->cursor_enabled) {
ffffffff80001771:	80 7f 09 00          	cmpb   $0x0,0x9(%rdi)
ffffffff80001775:	0f 85 35 01 00 00    	jne    ffffffff800018b0 <flanterm_fb_double_buffer_flush+0x150>
        draw_cursor(_ctx);
    }

    for (size_t i = 0; i < ctx->queue_i; i++) {
ffffffff8000177b:	48 83 bb d0 02 00 00 	cmpq   $0x0,0x2d0(%rbx)
ffffffff80001782:	00 
ffffffff80001783:	74 7b                	je     ffffffff80001800 <flanterm_fb_double_buffer_flush+0xa0>
ffffffff80001785:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff8000178c:	45 31 ed             	xor    %r13d,%r13d
ffffffff8000178f:	90                   	nop
        struct flanterm_fb_queue_item *q = &ctx->queue[i];
ffffffff80001790:	4c 89 ed             	mov    %r13,%rbp
        size_t offset = q->y * _ctx->cols + q->x;
ffffffff80001793:	4c 8b a3 e8 00 00 00 	mov    0xe8(%rbx),%r12
        struct flanterm_fb_queue_item *q = &ctx->queue[i];
ffffffff8000179a:	48 c1 e5 05          	shl    $0x5,%rbp
ffffffff8000179e:	48 03 ab c8 02 00 00 	add    0x2c8(%rbx),%rbp
        size_t offset = q->y * _ctx->cols + q->x;
ffffffff800017a5:	48 8b 4d 08          	mov    0x8(%rbp),%rcx
ffffffff800017a9:	48 8b 55 00          	mov    0x0(%rbp),%rdx
ffffffff800017ad:	4c 0f af e1          	imul   %rcx,%r12
ffffffff800017b1:	49 01 d4             	add    %rdx,%r12
        if (ctx->map[offset] == NULL) {
ffffffff800017b4:	4a 83 3c e0 00       	cmpq   $0x0,(%rax,%r12,8)
ffffffff800017b9:	74 38                	je     ffffffff800017f3 <flanterm_fb_double_buffer_flush+0x93>
            continue;
        }
        ctx->plot_char(_ctx, &q->c, q->x, q->y);
ffffffff800017bb:	48 8d 75 10          	lea    0x10(%rbp),%rsi
ffffffff800017bf:	48 89 df             	mov    %rbx,%rdi
ffffffff800017c2:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
        ctx->grid[offset] = q->c;
ffffffff800017c8:	48 8b 93 c0 02 00 00 	mov    0x2c0(%rbx),%rdx
ffffffff800017cf:	4b 8d 04 64          	lea    (%r12,%r12,2),%rax
ffffffff800017d3:	48 8d 04 82          	lea    (%rdx,%rax,4),%rax
ffffffff800017d7:	48 8b 55 10          	mov    0x10(%rbp),%rdx
ffffffff800017db:	48 89 10             	mov    %rdx,(%rax)
ffffffff800017de:	8b 55 18             	mov    0x18(%rbp),%edx
ffffffff800017e1:	89 50 08             	mov    %edx,0x8(%rax)
        ctx->map[offset] = NULL;
ffffffff800017e4:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff800017eb:	4a c7 04 e0 00 00 00 	movq   $0x0,(%rax,%r12,8)
ffffffff800017f2:	00 
    for (size_t i = 0; i < ctx->queue_i; i++) {
ffffffff800017f3:	49 83 c5 01          	add    $0x1,%r13
ffffffff800017f7:	4c 3b ab d0 02 00 00 	cmp    0x2d0(%rbx),%r13
ffffffff800017fe:	72 90                	jb     ffffffff80001790 <flanterm_fb_double_buffer_flush+0x30>
    }

    if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {
ffffffff80001800:	48 8b 93 10 03 00 00 	mov    0x310(%rbx),%rdx
ffffffff80001807:	48 8b 8b e8 02 00 00 	mov    0x2e8(%rbx),%rcx
ffffffff8000180e:	48 39 ca             	cmp    %rcx,%rdx
ffffffff80001811:	74 7d                	je     ffffffff80001890 <flanterm_fb_double_buffer_flush+0x130>
        if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {
ffffffff80001813:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000181a:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000181d:	73 3c                	jae    ffffffff8000185b <flanterm_fb_double_buffer_flush+0xfb>
ffffffff8000181f:	48 8b b3 18 03 00 00 	mov    0x318(%rbx),%rsi
ffffffff80001826:	48 3b b3 e0 00 00 00 	cmp    0xe0(%rbx),%rsi
ffffffff8000182d:	73 2c                	jae    ffffffff8000185b <flanterm_fb_double_buffer_flush+0xfb>
            ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);
ffffffff8000182f:	48 0f af c6          	imul   %rsi,%rax
ffffffff80001833:	48 89 df             	mov    %rbx,%rdi
ffffffff80001836:	48 01 d0             	add    %rdx,%rax
ffffffff80001839:	48 8d 0c 40          	lea    (%rax,%rax,2),%rcx
ffffffff8000183d:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff80001844:	48 8d 04 88          	lea    (%rax,%rcx,4),%rax
ffffffff80001848:	48 89 f1             	mov    %rsi,%rcx
ffffffff8000184b:	48 89 c6             	mov    %rax,%rsi
ffffffff8000184e:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
        }
    }

    ctx->old_cursor_x = ctx->cursor_x;
ffffffff80001854:	48 8b 8b e8 02 00 00 	mov    0x2e8(%rbx),%rcx
    ctx->old_cursor_y = ctx->cursor_y;
ffffffff8000185b:	48 8b 83 f0 02 00 00 	mov    0x2f0(%rbx),%rax
    ctx->old_cursor_x = ctx->cursor_x;
ffffffff80001862:	48 89 8b 10 03 00 00 	mov    %rcx,0x310(%rbx)
    ctx->old_cursor_y = ctx->cursor_y;
ffffffff80001869:	48 89 83 18 03 00 00 	mov    %rax,0x318(%rbx)

    ctx->queue_i = 0;
ffffffff80001870:	48 c7 83 d0 02 00 00 	movq   $0x0,0x2d0(%rbx)
ffffffff80001877:	00 00 00 00 
}
ffffffff8000187b:	48 83 c4 08          	add    $0x8,%rsp
ffffffff8000187f:	5b                   	pop    %rbx
ffffffff80001880:	5d                   	pop    %rbp
ffffffff80001881:	41 5c                	pop    %r12
ffffffff80001883:	41 5d                	pop    %r13
ffffffff80001885:	c3                   	ret
ffffffff80001886:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000188d:	00 00 00 
    if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {
ffffffff80001890:	48 8b 83 f0 02 00 00 	mov    0x2f0(%rbx),%rax
ffffffff80001897:	48 39 83 18 03 00 00 	cmp    %rax,0x318(%rbx)
ffffffff8000189e:	0f 85 6f ff ff ff    	jne    ffffffff80001813 <flanterm_fb_double_buffer_flush+0xb3>
ffffffff800018a4:	80 7b 09 00          	cmpb   $0x0,0x9(%rbx)
ffffffff800018a8:	75 b8                	jne    ffffffff80001862 <flanterm_fb_double_buffer_flush+0x102>
ffffffff800018aa:	e9 64 ff ff ff       	jmp    ffffffff80001813 <flanterm_fb_double_buffer_flush+0xb3>
ffffffff800018af:	90                   	nop
        draw_cursor(_ctx);
ffffffff800018b0:	e8 ab fd ff ff       	call   ffffffff80001660 <draw_cursor>
ffffffff800018b5:	e9 c1 fe ff ff       	jmp    ffffffff8000177b <flanterm_fb_double_buffer_flush+0x1b>
ffffffff800018ba:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800018c0 <flanterm_fb_raw_putchar>:

static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) {
ffffffff800018c0:	f3 0f 1e fa          	endbr64
ffffffff800018c4:	55                   	push   %rbp
ffffffff800018c5:	53                   	push   %rbx
ffffffff800018c6:	89 f3                	mov    %esi,%ebx
ffffffff800018c8:	48 83 ec 20          	sub    $0x20,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {
ffffffff800018cc:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
ffffffff800018d3:	48 8b af e8 00 00 00 	mov    0xe8(%rdi),%rbp
ffffffff800018da:	48 8b 8f f0 02 00 00 	mov    0x2f0(%rdi),%rcx
ffffffff800018e1:	48 39 ea             	cmp    %rbp,%rdx
ffffffff800018e4:	72 50                	jb     ffffffff80001936 <flanterm_fb_raw_putchar+0x76>
ffffffff800018e6:	48 8b 47 70          	mov    0x70(%rdi),%rax
ffffffff800018ea:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
ffffffff800018ee:	48 39 f1             	cmp    %rsi,%rcx
ffffffff800018f1:	73 3d                	jae    ffffffff80001930 <flanterm_fb_raw_putchar+0x70>
        ctx->cursor_x = 0;
ffffffff800018f3:	48 c7 87 e8 02 00 00 	movq   $0x0,0x2e8(%rdi)
ffffffff800018fa:	00 00 00 00 
        ctx->cursor_y++;
ffffffff800018fe:	48 8d 51 01          	lea    0x1(%rcx),%rdx
        if (ctx->cursor_y == _ctx->scroll_bottom_margin) {
ffffffff80001902:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001905:	0f 84 7d 00 00 00    	je     ffffffff80001988 <flanterm_fb_raw_putchar+0xc8>
        ctx->cursor_y++;
ffffffff8000190b:	48 89 97 f0 02 00 00 	mov    %rdx,0x2f0(%rdi)
ffffffff80001912:	48 89 d1             	mov    %rdx,%rcx
            ctx->cursor_y--;
            flanterm_fb_scroll(_ctx);
        }
        if (ctx->cursor_y >= _ctx->cols) {
ffffffff80001915:	48 39 e9             	cmp    %rbp,%rcx
ffffffff80001918:	72 5e                	jb     ffffffff80001978 <flanterm_fb_raw_putchar+0xb8>
            ctx->cursor_y = _ctx->cols - 1;
ffffffff8000191a:	48 8d 4d ff          	lea    -0x1(%rbp),%rcx
ffffffff8000191e:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80001923:	31 d2                	xor    %edx,%edx
ffffffff80001925:	48 89 8f f0 02 00 00 	mov    %rcx,0x2f0(%rdi)
ffffffff8000192c:	eb 0c                	jmp    ffffffff8000193a <flanterm_fb_raw_putchar+0x7a>
ffffffff8000192e:	66 90                	xchg   %ax,%ax
    if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {
ffffffff80001930:	80 7f 0a 00          	cmpb   $0x0,0xa(%rdi)
ffffffff80001934:	75 bd                	jne    ffffffff800018f3 <flanterm_fb_raw_putchar+0x33>

    struct flanterm_fb_char ch;
    ch.c  = c;
    ch.fg = ctx->text_fg;
    ch.bg = ctx->text_bg;
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001936:	48 8d 72 01          	lea    0x1(%rdx),%rsi
    ch.c  = c;
ffffffff8000193a:	8b 87 e0 02 00 00    	mov    0x2e0(%rdi),%eax
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001940:	48 89 b7 e8 02 00 00 	mov    %rsi,0x2e8(%rdi)
    ch.c  = c;
ffffffff80001947:	0f b6 db             	movzbl %bl,%ebx
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff8000194a:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
    ch.c  = c;
ffffffff8000194f:	48 c1 e0 20          	shl    $0x20,%rax
ffffffff80001953:	48 09 c3             	or     %rax,%rbx
    ch.bg = ctx->text_bg;
ffffffff80001956:	8b 87 e4 02 00 00    	mov    0x2e4(%rdi),%eax
    ch.c  = c;
ffffffff8000195c:	48 89 5c 24 10       	mov    %rbx,0x10(%rsp)
    ch.bg = ctx->text_bg;
ffffffff80001961:	89 44 24 18          	mov    %eax,0x18(%rsp)
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001965:	e8 66 f7 ff ff       	call   ffffffff800010d0 <push_to_queue>
}
ffffffff8000196a:	48 83 c4 20          	add    $0x20,%rsp
ffffffff8000196e:	5b                   	pop    %rbx
ffffffff8000196f:	5d                   	pop    %rbp
ffffffff80001970:	c3                   	ret
ffffffff80001971:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80001978:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff8000197d:	31 d2                	xor    %edx,%edx
ffffffff8000197f:	eb b9                	jmp    ffffffff8000193a <flanterm_fb_raw_putchar+0x7a>
ffffffff80001981:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80001988:	48 89 4c 24 08       	mov    %rcx,0x8(%rsp)
            flanterm_fb_scroll(_ctx);
ffffffff8000198d:	48 89 3c 24          	mov    %rdi,(%rsp)
ffffffff80001991:	e8 ca f8 ff ff       	call   ffffffff80001260 <flanterm_fb_scroll>
ffffffff80001996:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
ffffffff8000199b:	48 8b 3c 24          	mov    (%rsp),%rdi
ffffffff8000199f:	e9 71 ff ff ff       	jmp    ffffffff80001915 <flanterm_fb_raw_putchar+0x55>
ffffffff800019a4:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800019ab:	00 00 00 
ffffffff800019ae:	66 90                	xchg   %ax,%ax

ffffffff800019b0 <flanterm_fb_full_refresh>:

static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {
ffffffff800019b0:	f3 0f 1e fa          	endbr64
ffffffff800019b4:	41 55                	push   %r13
ffffffff800019b6:	41 54                	push   %r12
ffffffff800019b8:	55                   	push   %rbp
ffffffff800019b9:	53                   	push   %rbx
ffffffff800019ba:	48 89 fb             	mov    %rdi,%rbx
ffffffff800019bd:	48 83 ec 08          	sub    $0x8,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    uint32_t default_bg = ctx->default_bg;

    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019c1:	4c 8b a7 10 02 00 00 	mov    0x210(%rdi),%r12
    uint32_t default_bg = ctx->default_bg;
ffffffff800019c8:	8b af 8c 02 00 00    	mov    0x28c(%rdi),%ebp
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019ce:	4d 85 e4             	test   %r12,%r12
ffffffff800019d1:	0f 84 7c 00 00 00    	je     ffffffff80001a53 <flanterm_fb_full_refresh+0xa3>
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff800019d7:	48 8b bf 08 02 00 00 	mov    0x208(%rdi),%rdi
ffffffff800019de:	45 31 db             	xor    %r11d,%r11d
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019e1:	45 31 d2             	xor    %r10d,%r10d
ffffffff800019e4:	4c 8d 2c bd 00 00 00 	lea    0x0(,%rdi,4),%r13
ffffffff800019eb:	00 
ffffffff800019ec:	0f 1f 40 00          	nopl   0x0(%rax)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff800019f0:	48 85 ff             	test   %rdi,%rdi
ffffffff800019f3:	74 52                	je     ffffffff80001a47 <flanterm_fb_full_refresh+0x97>
            if (ctx->canvas != NULL) {
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff800019f5:	48 8b 8b 00 02 00 00 	mov    0x200(%rbx),%rcx
ffffffff800019fc:	4c 8b 83 f8 01 00 00 	mov    0x1f8(%rbx),%r8
ffffffff80001a03:	31 c0                	xor    %eax,%eax
            if (ctx->canvas != NULL) {
ffffffff80001a05:	48 8b b3 a0 02 00 00 	mov    0x2a0(%rbx),%rsi
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a0c:	48 c1 e9 02          	shr    $0x2,%rcx
ffffffff80001a10:	49 0f af ca          	imul   %r10,%rcx
ffffffff80001a14:	49 8d 14 88          	lea    (%r8,%rcx,4),%rdx
            if (ctx->canvas != NULL) {
ffffffff80001a18:	48 85 f6             	test   %rsi,%rsi
ffffffff80001a1b:	0f 84 a7 00 00 00    	je     ffffffff80001ac8 <flanterm_fb_full_refresh+0x118>
ffffffff80001a21:	4e 8d 0c 1e          	lea    (%rsi,%r11,1),%r9
ffffffff80001a25:	eb 11                	jmp    ffffffff80001a38 <flanterm_fb_full_refresh+0x88>
ffffffff80001a27:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80001a2e:	00 00 
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a30:	48 8d 14 08          	lea    (%rax,%rcx,1),%rdx
ffffffff80001a34:	49 8d 14 90          	lea    (%r8,%rdx,4),%rdx
ffffffff80001a38:	41 8b 34 81          	mov    (%r9,%rax,4),%esi
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001a3c:	48 83 c0 01          	add    $0x1,%rax
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a40:	89 32                	mov    %esi,(%rdx)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001a42:	48 39 c7             	cmp    %rax,%rdi
ffffffff80001a45:	75 e9                	jne    ffffffff80001a30 <flanterm_fb_full_refresh+0x80>
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff80001a47:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001a4b:	4d 01 eb             	add    %r13,%r11
ffffffff80001a4e:	4d 39 e2             	cmp    %r12,%r10
ffffffff80001a51:	75 9d                	jne    ffffffff800019f0 <flanterm_fb_full_refresh+0x40>
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;
            }
        }
    }

    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a53:	48 8b 8b e8 00 00 00 	mov    0xe8(%rbx),%rcx
ffffffff80001a5a:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80001a61:	31 ed                	xor    %ebp,%ebp
ffffffff80001a63:	48 0f af c1          	imul   %rcx,%rax
ffffffff80001a67:	48 85 c0             	test   %rax,%rax
ffffffff80001a6a:	74 43                	je     ffffffff80001aaf <flanterm_fb_full_refresh+0xff>
ffffffff80001a6c:	0f 1f 40 00          	nopl   0x0(%rax)
        size_t x = i % _ctx->cols;
ffffffff80001a70:	48 89 e8             	mov    %rbp,%rax
ffffffff80001a73:	31 d2                	xor    %edx,%edx
        size_t y = i / _ctx->cols;

        ctx->plot_char(_ctx, &ctx->grid[i], x, y);
ffffffff80001a75:	48 8d 74 6d 00       	lea    0x0(%rbp,%rbp,2),%rsi
ffffffff80001a7a:	48 89 df             	mov    %rbx,%rdi
ffffffff80001a7d:	48 f7 f1             	div    %rcx
    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a80:	48 83 c5 01          	add    $0x1,%rbp
ffffffff80001a84:	48 89 c1             	mov    %rax,%rcx
        ctx->plot_char(_ctx, &ctx->grid[i], x, y);
ffffffff80001a87:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff80001a8e:	48 8d 34 b0          	lea    (%rax,%rsi,4),%rsi
ffffffff80001a92:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a98:	48 8b 8b e8 00 00 00 	mov    0xe8(%rbx),%rcx
ffffffff80001a9f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80001aa6:	48 0f af c1          	imul   %rcx,%rax
ffffffff80001aaa:	48 39 c5             	cmp    %rax,%rbp
ffffffff80001aad:	72 c1                	jb     ffffffff80001a70 <flanterm_fb_full_refresh+0xc0>
    }

    if (_ctx->cursor_enabled) {
ffffffff80001aaf:	80 7b 09 00          	cmpb   $0x0,0x9(%rbx)
ffffffff80001ab3:	75 33                	jne    ffffffff80001ae8 <flanterm_fb_full_refresh+0x138>
        draw_cursor(_ctx);
    }
}
ffffffff80001ab5:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80001ab9:	5b                   	pop    %rbx
ffffffff80001aba:	5d                   	pop    %rbp
ffffffff80001abb:	41 5c                	pop    %r12
ffffffff80001abd:	41 5d                	pop    %r13
ffffffff80001abf:	c3                   	ret
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001ac0:	48 8d 14 08          	lea    (%rax,%rcx,1),%rdx
ffffffff80001ac4:	49 8d 14 90          	lea    (%r8,%rdx,4),%rdx
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001ac8:	48 83 c0 01          	add    $0x1,%rax
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;
ffffffff80001acc:	89 2a                	mov    %ebp,(%rdx)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001ace:	48 39 f8             	cmp    %rdi,%rax
ffffffff80001ad1:	75 ed                	jne    ffffffff80001ac0 <flanterm_fb_full_refresh+0x110>
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff80001ad3:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001ad7:	4d 01 eb             	add    %r13,%r11
ffffffff80001ada:	4d 39 e2             	cmp    %r12,%r10
ffffffff80001add:	0f 85 0d ff ff ff    	jne    ffffffff800019f0 <flanterm_fb_full_refresh+0x40>
ffffffff80001ae3:	e9 6b ff ff ff       	jmp    ffffffff80001a53 <flanterm_fb_full_refresh+0xa3>
}
ffffffff80001ae8:	48 83 c4 08          	add    $0x8,%rsp
        draw_cursor(_ctx);
ffffffff80001aec:	48 89 df             	mov    %rbx,%rdi
}
ffffffff80001aef:	5b                   	pop    %rbx
ffffffff80001af0:	5d                   	pop    %rbp
ffffffff80001af1:	41 5c                	pop    %r12
ffffffff80001af3:	41 5d                	pop    %r13
        draw_cursor(_ctx);
ffffffff80001af5:	e9 66 fb ff ff       	jmp    ffffffff80001660 <draw_cursor>
ffffffff80001afa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80001b00 <flanterm_fb_deinit>:

static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {
ffffffff80001b00:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (_free == NULL) {
ffffffff80001b04:	48 85 f6             	test   %rsi,%rsi
ffffffff80001b07:	0f 84 8b 00 00 00    	je     ffffffff80001b98 <flanterm_fb_deinit+0x98>
static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {
ffffffff80001b0d:	55                   	push   %rbp
ffffffff80001b0e:	48 89 f5             	mov    %rsi,%rbp
ffffffff80001b11:	53                   	push   %rbx
ffffffff80001b12:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001b15:	48 83 ec 08          	sub    $0x8,%rsp
        }
#endif
        return;
    }

    _free(ctx->font_bits, ctx->font_bits_size);
ffffffff80001b19:	48 8b b7 28 02 00 00 	mov    0x228(%rdi),%rsi
ffffffff80001b20:	48 8b bf 30 02 00 00 	mov    0x230(%rdi),%rdi
ffffffff80001b27:	ff d5                	call   *%rbp
    _free(ctx->font_bool, ctx->font_bool_size);
ffffffff80001b29:	48 8b b3 38 02 00 00 	mov    0x238(%rbx),%rsi
ffffffff80001b30:	48 8b bb 40 02 00 00 	mov    0x240(%rbx),%rdi
ffffffff80001b37:	ff d5                	call   *%rbp
    _free(ctx->grid, ctx->grid_size);
ffffffff80001b39:	48 8b b3 a8 02 00 00 	mov    0x2a8(%rbx),%rsi
ffffffff80001b40:	48 8b bb c0 02 00 00 	mov    0x2c0(%rbx),%rdi
ffffffff80001b47:	ff d5                	call   *%rbp
    _free(ctx->queue, ctx->queue_size);
ffffffff80001b49:	48 8b b3 b0 02 00 00 	mov    0x2b0(%rbx),%rsi
ffffffff80001b50:	48 8b bb c8 02 00 00 	mov    0x2c8(%rbx),%rdi
ffffffff80001b57:	ff d5                	call   *%rbp
    _free(ctx->map, ctx->map_size);
ffffffff80001b59:	48 8b bb d8 02 00 00 	mov    0x2d8(%rbx),%rdi
ffffffff80001b60:	48 8b b3 b8 02 00 00 	mov    0x2b8(%rbx),%rsi
ffffffff80001b67:	ff d5                	call   *%rbp

    if (ctx->canvas != NULL) {
ffffffff80001b69:	48 8b bb a0 02 00 00 	mov    0x2a0(%rbx),%rdi
ffffffff80001b70:	48 85 ff             	test   %rdi,%rdi
ffffffff80001b73:	74 09                	je     ffffffff80001b7e <flanterm_fb_deinit+0x7e>
        _free(ctx->canvas, ctx->canvas_size);
ffffffff80001b75:	48 8b b3 98 02 00 00 	mov    0x298(%rbx),%rsi
ffffffff80001b7c:	ff d5                	call   *%rbp
    }

    _free(ctx, sizeof(struct flanterm_fb_context));
}
ffffffff80001b7e:	48 83 c4 08          	add    $0x8,%rsp
    _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80001b82:	48 89 df             	mov    %rbx,%rdi
ffffffff80001b85:	48 89 e8             	mov    %rbp,%rax
ffffffff80001b88:	be 20 03 00 00       	mov    $0x320,%esi
}
ffffffff80001b8d:	5b                   	pop    %rbx
ffffffff80001b8e:	5d                   	pop    %rbp
    _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80001b8f:	ff e0                	jmp    *%rax
ffffffff80001b91:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        if (bump_allocated_instance == true) {
ffffffff80001b98:	80 3d 62 a5 00 00 00 	cmpb   $0x0,0xa562(%rip)        # ffffffff8000c101 <bump_allocated_instance>
ffffffff80001b9f:	74 17                	je     ffffffff80001bb8 <flanterm_fb_deinit+0xb8>
            bump_alloc_ptr = 0;
ffffffff80001ba1:	48 c7 05 5c a5 00 00 	movq   $0x0,0xa55c(%rip)        # ffffffff8000c108 <bump_alloc_ptr>
ffffffff80001ba8:	00 00 00 00 
            bump_allocated_instance = false;
ffffffff80001bac:	c6 05 4e a5 00 00 00 	movb   $0x0,0xa54e(%rip)        # ffffffff8000c101 <bump_allocated_instance>
ffffffff80001bb3:	c3                   	ret
ffffffff80001bb4:	0f 1f 40 00          	nopl   0x0(%rax)
ffffffff80001bb8:	c3                   	ret
ffffffff80001bb9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80001bc0 <plot_char_scaled_canvas>:
static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001bc0:	f3 0f 1e fa          	endbr64
ffffffff80001bc4:	41 57                	push   %r15
ffffffff80001bc6:	41 56                	push   %r14
ffffffff80001bc8:	41 55                	push   %r13
ffffffff80001bca:	41 54                	push   %r12
ffffffff80001bcc:	55                   	push   %rbp
ffffffff80001bcd:	53                   	push   %rbx
ffffffff80001bce:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001bd1:	48 83 ec 48          	sub    $0x48,%rsp
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001bd5:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001bdc:	0f 83 9b 01 00 00    	jae    ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
ffffffff80001be2:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001be9:	0f 83 8e 01 00 00    	jae    ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
ffffffff80001bef:	48 89 f7             	mov    %rsi,%rdi
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001bf2:	48 8b b3 d0 01 00 00 	mov    0x1d0(%rbx),%rsi
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001bf9:	48 0f af 93 c8 01 00 	imul   0x1c8(%rbx),%rdx
ffffffff80001c00:	00 
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c01:	48 8b ab b8 01 00 00 	mov    0x1b8(%rbx),%rbp
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001c08:	48 03 93 e8 01 00 00 	add    0x1e8(%rbx),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001c0f:	48 89 f0             	mov    %rsi,%rax
ffffffff80001c12:	48 89 74 24 10       	mov    %rsi,0x10(%rsp)
ffffffff80001c17:	48 0f af c1          	imul   %rcx,%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c1b:	48 8b 8b 40 02 00 00 	mov    0x240(%rbx),%rcx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001c22:	48 03 83 f0 01 00 00 	add    0x1f0(%rbx),%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c29:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
ffffffff80001c2e:	8b 0f                	mov    (%rdi),%ecx
ffffffff80001c30:	48 0f af 8b c0 01 00 	imul   0x1c0(%rbx),%rcx
ffffffff80001c37:	00 
ffffffff80001c38:	48 89 4c 24 20       	mov    %rcx,0x20(%rsp)
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c3d:	48 85 f6             	test   %rsi,%rsi
ffffffff80001c40:	0f 84 37 01 00 00    	je     ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001c46:	48 8b b3 e0 01 00 00 	mov    0x1e0(%rbx),%rsi
        uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;
ffffffff80001c4d:	48 8b 8b 08 02 00 00 	mov    0x208(%rbx),%rcx
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c54:	45 31 c9             	xor    %r9d,%r9d
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001c57:	4c 8b 93 00 02 00 00 	mov    0x200(%rbx),%r10
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001c5e:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001c63:	48 8b b3 f8 01 00 00 	mov    0x1f8(%rbx),%rsi
ffffffff80001c6a:	49 c1 ea 02          	shr    $0x2,%r10
ffffffff80001c6e:	48 89 74 24 40       	mov    %rsi,0x40(%rsp)
ffffffff80001c73:	48 8d 34 8d 00 00 00 	lea    0x0(,%rcx,4),%rsi
ffffffff80001c7a:	00 
ffffffff80001c7b:	48 0f af c8          	imul   %rax,%rcx
ffffffff80001c7f:	48 89 74 24 38       	mov    %rsi,0x38(%rsp)
ffffffff80001c84:	48 8b b3 a0 02 00 00 	mov    0x2a0(%rbx),%rsi
ffffffff80001c8b:	49 0f af c2          	imul   %r10,%rax
ffffffff80001c8f:	4c 89 54 24 30       	mov    %r10,0x30(%rsp)
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c94:	49 89 da             	mov    %rbx,%r10
ffffffff80001c97:	48 01 d1             	add    %rdx,%rcx
ffffffff80001c9a:	4c 8d 34 8e          	lea    (%rsi,%rcx,4),%r14
ffffffff80001c9e:	4c 8d 3c 10          	lea    (%rax,%rdx,1),%r15
ffffffff80001ca2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001ca8:	4c 89 c8             	mov    %r9,%rax
ffffffff80001cab:	31 d2                	xor    %edx,%edx
ffffffff80001cad:	48 f7 74 24 28       	divq   0x28(%rsp)
        bool *glyph_pointer = glyph + (fy * ctx->font_width);
ffffffff80001cb2:	0f b6 c8             	movzbl %al,%ecx
ffffffff80001cb5:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
ffffffff80001cba:	48 01 c1             	add    %rax,%rcx
ffffffff80001cbd:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80001cc2:	48 0f af cd          	imul   %rbp,%rcx
ffffffff80001cc6:	48 01 c1             	add    %rax,%rcx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001cc9:	48 85 ed             	test   %rbp,%rbp
ffffffff80001ccc:	0f 84 8c 00 00 00    	je     ffffffff80001d5e <plot_char_scaled_canvas+0x19e>
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001cd2:	4d 8b a2 d8 01 00 00 	mov    0x1d8(%r10),%r12
ffffffff80001cd9:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
ffffffff80001cde:	4c 8d 2c 29          	lea    (%rcx,%rbp,1),%r13
ffffffff80001ce2:	4c 89 ce             	mov    %r9,%rsi
ffffffff80001ce5:	48 89 6c 24 08       	mov    %rbp,0x8(%rsp)
ffffffff80001cea:	4e 8d 1c a5 00 00 00 	lea    0x0(,%r12,4),%r11
ffffffff80001cf1:	00 
ffffffff80001cf2:	4a 8d 1c b8          	lea    (%rax,%r15,4),%rbx
ffffffff80001cf6:	4f 8d 04 33          	lea    (%r11,%r14,1),%r8
ffffffff80001cfa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff80001d00:	4d 85 e4             	test   %r12,%r12
ffffffff80001d03:	74 42                	je     ffffffff80001d47 <plot_char_scaled_canvas+0x187>
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d05:	48 89 0c 24          	mov    %rcx,(%rsp)
ffffffff80001d09:	4c 89 c2             	mov    %r8,%rdx
ffffffff80001d0c:	0f b6 29             	movzbl (%rcx),%ebp
ffffffff80001d0f:	49 89 d9             	mov    %rbx,%r9
ffffffff80001d12:	4c 29 da             	sub    %r11,%rdx
ffffffff80001d15:	0f 1f 00             	nopl   (%rax)
                uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;
ffffffff80001d18:	8b 47 08             	mov    0x8(%rdi),%eax
ffffffff80001d1b:	83 f8 ff             	cmp    $0xffffffff,%eax
ffffffff80001d1e:	75 02                	jne    ffffffff80001d22 <plot_char_scaled_canvas+0x162>
ffffffff80001d20:	8b 02                	mov    (%rdx),%eax
                uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;
ffffffff80001d22:	8b 4f 04             	mov    0x4(%rdi),%ecx
ffffffff80001d25:	83 f9 ff             	cmp    $0xffffffff,%ecx
ffffffff80001d28:	75 02                	jne    ffffffff80001d2c <plot_char_scaled_canvas+0x16c>
ffffffff80001d2a:	8b 0a                	mov    (%rdx),%ecx
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d2c:	40 84 ed             	test   %bpl,%bpl
ffffffff80001d2f:	0f 45 c1             	cmovne %ecx,%eax
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001d32:	48 83 c2 04          	add    $0x4,%rdx
ffffffff80001d36:	49 83 c1 04          	add    $0x4,%r9
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d3a:	41 89 41 fc          	mov    %eax,-0x4(%r9)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001d3e:	49 39 d0             	cmp    %rdx,%r8
ffffffff80001d41:	75 d5                	jne    ffffffff80001d18 <plot_char_scaled_canvas+0x158>
ffffffff80001d43:	48 8b 0c 24          	mov    (%rsp),%rcx
            glyph_pointer++;
ffffffff80001d47:	48 83 c1 01          	add    $0x1,%rcx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001d4b:	4d 01 d8             	add    %r11,%r8
ffffffff80001d4e:	4c 01 db             	add    %r11,%rbx
ffffffff80001d51:	4c 39 e9             	cmp    %r13,%rcx
ffffffff80001d54:	75 aa                	jne    ffffffff80001d00 <plot_char_scaled_canvas+0x140>
ffffffff80001d56:	48 8b 6c 24 08       	mov    0x8(%rsp),%rbp
ffffffff80001d5b:	49 89 f1             	mov    %rsi,%r9
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001d5e:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
ffffffff80001d63:	49 83 c1 01          	add    $0x1,%r9
ffffffff80001d67:	49 01 c6             	add    %rax,%r14
ffffffff80001d6a:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
ffffffff80001d6f:	49 01 c7             	add    %rax,%r15
ffffffff80001d72:	4c 39 4c 24 10       	cmp    %r9,0x10(%rsp)
ffffffff80001d77:	0f 85 2b ff ff ff    	jne    ffffffff80001ca8 <plot_char_scaled_canvas+0xe8>
}
ffffffff80001d7d:	48 83 c4 48          	add    $0x48,%rsp
ffffffff80001d81:	5b                   	pop    %rbx
ffffffff80001d82:	5d                   	pop    %rbp
ffffffff80001d83:	41 5c                	pop    %r12
ffffffff80001d85:	41 5d                	pop    %r13
ffffffff80001d87:	41 5e                	pop    %r14
ffffffff80001d89:	41 5f                	pop    %r15
ffffffff80001d8b:	c3                   	ret
ffffffff80001d8c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001d90 <plot_char_unscaled_canvas>:
static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001d90:	f3 0f 1e fa          	endbr64
ffffffff80001d94:	48 89 f8             	mov    %rdi,%rax
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001d97:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001d9e:	0f 83 0c 01 00 00    	jae    ffffffff80001eb0 <plot_char_unscaled_canvas+0x120>
ffffffff80001da4:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001dab:	0f 83 ff 00 00 00    	jae    ffffffff80001eb0 <plot_char_unscaled_canvas+0x120>
static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001db1:	41 56                	push   %r14
ffffffff80001db3:	48 89 f7             	mov    %rsi,%rdi
ffffffff80001db6:	41 55                	push   %r13
ffffffff80001db8:	41 54                	push   %r12
ffffffff80001dba:	55                   	push   %rbp
ffffffff80001dbb:	53                   	push   %rbx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001dbc:	4c 8b a0 d0 01 00 00 	mov    0x1d0(%rax),%r12
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001dc3:	8b 1e                	mov    (%rsi),%ebx
ffffffff80001dc5:	4c 8b 88 b8 01 00 00 	mov    0x1b8(%rax),%r9
ffffffff80001dcc:	48 8b b0 c0 01 00 00 	mov    0x1c0(%rax),%rsi
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001dd3:	48 0f af 90 c8 01 00 	imul   0x1c8(%rax),%rdx
ffffffff80001dda:	00 
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001ddb:	49 0f af cc          	imul   %r12,%rcx
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001ddf:	4c 8b 80 40 02 00 00 	mov    0x240(%rax),%r8
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001de6:	48 03 90 e8 01 00 00 	add    0x1e8(%rax),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001ded:	49 0f af f1          	imul   %r9,%rsi
ffffffff80001df1:	48 03 88 f0 01 00 00 	add    0x1f0(%rax),%rcx
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001df8:	4d 85 e4             	test   %r12,%r12
ffffffff80001dfb:	0f 84 a1 00 00 00    	je     ffffffff80001ea2 <plot_char_unscaled_canvas+0x112>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e01:	48 8b a8 00 02 00 00 	mov    0x200(%rax),%rbp
        uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;
ffffffff80001e08:	4c 8b 90 08 02 00 00 	mov    0x208(%rax),%r10
ffffffff80001e0f:	49 89 cb             	mov    %rcx,%r11
ffffffff80001e12:	48 0f af f3          	imul   %rbx,%rsi
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e16:	4c 8b b0 f8 01 00 00 	mov    0x1f8(%rax),%r14
ffffffff80001e1d:	48 8b 80 a0 02 00 00 	mov    0x2a0(%rax),%rax
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001e24:	31 db                	xor    %ebx,%ebx
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e26:	48 c1 ed 02          	shr    $0x2,%rbp
ffffffff80001e2a:	49 0f af ca          	imul   %r10,%rcx
ffffffff80001e2e:	4e 8d 2c 95 00 00 00 	lea    0x0(,%r10,4),%r13
ffffffff80001e35:	00 
ffffffff80001e36:	4c 0f af dd          	imul   %rbp,%r11
ffffffff80001e3a:	49 01 f0             	add    %rsi,%r8
ffffffff80001e3d:	49 01 d3             	add    %rdx,%r11
ffffffff80001e40:	48 01 ca             	add    %rcx,%rdx
ffffffff80001e43:	4c 8d 14 90          	lea    (%rax,%rdx,4),%r10
ffffffff80001e47:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80001e4e:	00 00 
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e50:	4d 85 c9             	test   %r9,%r9
ffffffff80001e53:	74 3b                	je     ffffffff80001e90 <plot_char_unscaled_canvas+0x100>
ffffffff80001e55:	4b 8d 34 9e          	lea    (%r14,%r11,4),%rsi
ffffffff80001e59:	31 d2                	xor    %edx,%edx
ffffffff80001e5b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg;
ffffffff80001e60:	8b 47 08             	mov    0x8(%rdi),%eax
ffffffff80001e63:	83 f8 ff             	cmp    $0xffffffff,%eax
ffffffff80001e66:	75 04                	jne    ffffffff80001e6c <plot_char_unscaled_canvas+0xdc>
ffffffff80001e68:	41 8b 04 92          	mov    (%r10,%rdx,4),%eax
            uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg;
ffffffff80001e6c:	8b 4f 04             	mov    0x4(%rdi),%ecx
ffffffff80001e6f:	83 f9 ff             	cmp    $0xffffffff,%ecx
ffffffff80001e72:	75 04                	jne    ffffffff80001e78 <plot_char_unscaled_canvas+0xe8>
ffffffff80001e74:	41 8b 0c 92          	mov    (%r10,%rdx,4),%ecx
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001e78:	41 80 3c 10 00       	cmpb   $0x0,(%r8,%rdx,1)
ffffffff80001e7d:	0f 45 c1             	cmovne %ecx,%eax
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e80:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001e84:	48 83 c6 04          	add    $0x4,%rsi
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001e88:	89 46 fc             	mov    %eax,-0x4(%rsi)
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e8b:	49 39 d1             	cmp    %rdx,%r9
ffffffff80001e8e:	75 d0                	jne    ffffffff80001e60 <plot_char_unscaled_canvas+0xd0>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001e90:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80001e94:	49 01 eb             	add    %rbp,%r11
ffffffff80001e97:	4d 01 c8             	add    %r9,%r8
ffffffff80001e9a:	4d 01 ea             	add    %r13,%r10
ffffffff80001e9d:	49 39 dc             	cmp    %rbx,%r12
ffffffff80001ea0:	75 ae                	jne    ffffffff80001e50 <plot_char_unscaled_canvas+0xc0>
}
ffffffff80001ea2:	5b                   	pop    %rbx
ffffffff80001ea3:	5d                   	pop    %rbp
ffffffff80001ea4:	41 5c                	pop    %r12
ffffffff80001ea6:	41 5d                	pop    %r13
ffffffff80001ea8:	41 5e                	pop    %r14
ffffffff80001eaa:	c3                   	ret
ffffffff80001eab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff80001eb0:	c3                   	ret
ffffffff80001eb1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001eb8:	00 00 00 
ffffffff80001ebb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001ec0 <plot_char_unscaled_uncanvas>:
static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ec0:	f3 0f 1e fa          	endbr64
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001ec4:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001ecb:	0f 83 ff 00 00 00    	jae    ffffffff80001fd0 <plot_char_unscaled_uncanvas+0x110>
ffffffff80001ed1:	48 89 f8             	mov    %rdi,%rax
ffffffff80001ed4:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001edb:	0f 83 ef 00 00 00    	jae    ffffffff80001fd0 <plot_char_unscaled_uncanvas+0x110>
static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ee1:	41 57                	push   %r15
ffffffff80001ee3:	41 56                	push   %r14
ffffffff80001ee5:	41 55                	push   %r13
ffffffff80001ee7:	41 54                	push   %r12
ffffffff80001ee9:	55                   	push   %rbp
ffffffff80001eea:	53                   	push   %rbx
ffffffff80001eeb:	44 8b 46 08          	mov    0x8(%rsi),%r8d
    uint32_t default_bg = ctx->default_bg;
ffffffff80001eef:	44 8b 88 8c 02 00 00 	mov    0x28c(%rax),%r9d
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80001ef6:	8b 7e 04             	mov    0x4(%rsi),%edi
ffffffff80001ef9:	41 83 f8 ff          	cmp    $0xffffffff,%r8d
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001efd:	4c 8b a0 d0 01 00 00 	mov    0x1d0(%rax),%r12
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f04:	44 8b 3e             	mov    (%rsi),%r15d
ffffffff80001f07:	48 8b 98 b8 01 00 00 	mov    0x1b8(%rax),%rbx
ffffffff80001f0e:	4c 8b 90 c0 01 00 00 	mov    0x1c0(%rax),%r10
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80001f15:	45 0f 44 c1          	cmove  %r9d,%r8d
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff80001f19:	83 ff ff             	cmp    $0xffffffff,%edi
ffffffff80001f1c:	41 0f 44 f9          	cmove  %r9d,%edi
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f20:	4c 8b 88 40 02 00 00 	mov    0x240(%rax),%r9
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001f27:	48 0f af 90 c8 01 00 	imul   0x1c8(%rax),%rdx
ffffffff80001f2e:	00 
ffffffff80001f2f:	48 03 90 e8 01 00 00 	add    0x1e8(%rax),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001f36:	49 0f af cc          	imul   %r12,%rcx
ffffffff80001f3a:	48 03 88 f0 01 00 00 	add    0x1f0(%rax),%rcx
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f41:	4c 0f af d3          	imul   %rbx,%r10
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001f45:	4d 85 e4             	test   %r12,%r12
ffffffff80001f48:	74 7a                	je     ffffffff80001fc4 <plot_char_unscaled_uncanvas+0x104>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001f4a:	48 8b a8 00 02 00 00 	mov    0x200(%rax),%rbp
ffffffff80001f51:	4d 0f af d7          	imul   %r15,%r10
ffffffff80001f55:	4c 8b b0 f8 01 00 00 	mov    0x1f8(%rax),%r14
ffffffff80001f5c:	48 8d 04 1a          	lea    (%rdx,%rbx,1),%rax
ffffffff80001f60:	48 c1 ed 02          	shr    $0x2,%rbp
ffffffff80001f64:	48 0f af cd          	imul   %rbp,%rcx
ffffffff80001f68:	4d 01 d1             	add    %r10,%r9
ffffffff80001f6b:	4c 8d 2c ad 00 00 00 	lea    0x0(,%rbp,4),%r13
ffffffff80001f72:	00 
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001f73:	45 31 d2             	xor    %r10d,%r10d
ffffffff80001f76:	48 01 c8             	add    %rcx,%rax
ffffffff80001f79:	4c 8d 1c 0a          	lea    (%rdx,%rcx,1),%r11
ffffffff80001f7d:	49 8d 34 86          	lea    (%r14,%rax,4),%rsi
ffffffff80001f81:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        bool *glyph_pointer = glyph + (gy * ctx->font_width);
ffffffff80001f88:	4c 89 ca             	mov    %r9,%rdx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001f8b:	48 85 db             	test   %rbx,%rbx
ffffffff80001f8e:	74 22                	je     ffffffff80001fb2 <plot_char_unscaled_uncanvas+0xf2>
ffffffff80001f90:	4b 8d 04 9e          	lea    (%r14,%r11,4),%rax
ffffffff80001f94:	0f 1f 40 00          	nopl   0x0(%rax)
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001f98:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001f9c:	89 f9                	mov    %edi,%ecx
ffffffff80001f9e:	80 7a ff 00          	cmpb   $0x0,-0x1(%rdx)
ffffffff80001fa2:	41 0f 44 c8          	cmove  %r8d,%ecx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001fa6:	48 83 c0 04          	add    $0x4,%rax
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001faa:	89 48 fc             	mov    %ecx,-0x4(%rax)
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001fad:	48 39 f0             	cmp    %rsi,%rax
ffffffff80001fb0:	75 e6                	jne    ffffffff80001f98 <plot_char_unscaled_uncanvas+0xd8>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001fb2:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001fb6:	49 01 eb             	add    %rbp,%r11
ffffffff80001fb9:	4c 01 ee             	add    %r13,%rsi
ffffffff80001fbc:	49 01 d9             	add    %rbx,%r9
ffffffff80001fbf:	4d 39 d4             	cmp    %r10,%r12
ffffffff80001fc2:	75 c4                	jne    ffffffff80001f88 <plot_char_unscaled_uncanvas+0xc8>
}
ffffffff80001fc4:	5b                   	pop    %rbx
ffffffff80001fc5:	5d                   	pop    %rbp
ffffffff80001fc6:	41 5c                	pop    %r12
ffffffff80001fc8:	41 5d                	pop    %r13
ffffffff80001fca:	41 5e                	pop    %r14
ffffffff80001fcc:	41 5f                	pop    %r15
ffffffff80001fce:	c3                   	ret
ffffffff80001fcf:	90                   	nop
ffffffff80001fd0:	c3                   	ret
ffffffff80001fd1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001fd8:	00 00 00 
ffffffff80001fdb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001fe0 <plot_char_scaled_uncanvas>:
static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001fe0:	f3 0f 1e fa          	endbr64
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001fe4:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001feb:	0f 83 69 01 00 00    	jae    ffffffff8000215a <plot_char_scaled_uncanvas+0x17a>
static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ff1:	41 57                	push   %r15
ffffffff80001ff3:	41 56                	push   %r14
ffffffff80001ff5:	41 55                	push   %r13
ffffffff80001ff7:	41 54                	push   %r12
ffffffff80001ff9:	55                   	push   %rbp
ffffffff80001ffa:	48 89 fd             	mov    %rdi,%rbp
ffffffff80001ffd:	53                   	push   %rbx
ffffffff80001ffe:	48 83 ec 20          	sub    $0x20,%rsp
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80002002:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80002009:	0f 83 3c 01 00 00    	jae    ffffffff8000214b <plot_char_scaled_uncanvas+0x16b>
ffffffff8000200f:	44 8b 7e 08          	mov    0x8(%rsi),%r15d
    uint32_t default_bg = ctx->default_bg;
ffffffff80002013:	8b 87 8c 02 00 00    	mov    0x28c(%rdi),%eax
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80002019:	44 8b 76 04          	mov    0x4(%rsi),%r14d
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000201d:	48 8b 9d 40 02 00 00 	mov    0x240(%rbp),%rbx
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80002024:	41 83 ff ff          	cmp    $0xffffffff,%r15d
ffffffff80002028:	44 0f 44 f8          	cmove  %eax,%r15d
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff8000202c:	41 83 fe ff          	cmp    $0xffffffff,%r14d
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80002030:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
ffffffff80002035:	48 8b 9d b8 01 00 00 	mov    0x1b8(%rbp),%rbx
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff8000203c:	44 0f 44 f0          	cmove  %eax,%r14d
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80002040:	48 8b 87 c8 01 00 00 	mov    0x1c8(%rdi),%rax
ffffffff80002047:	48 0f af c2          	imul   %rdx,%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000204b:	8b 16                	mov    (%rsi),%edx
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff8000204d:	48 03 87 e8 01 00 00 	add    0x1e8(%rdi),%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80002054:	48 0f af 95 c0 01 00 	imul   0x1c0(%rbp),%rdx
ffffffff8000205b:	00 
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff8000205c:	48 8b bf d0 01 00 00 	mov    0x1d0(%rdi),%rdi
ffffffff80002063:	49 89 fb             	mov    %rdi,%r11
ffffffff80002066:	48 89 3c 24          	mov    %rdi,(%rsp)
ffffffff8000206a:	4c 0f af d9          	imul   %rcx,%r11
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000206e:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80002073:	4c 03 9d f0 01 00 00 	add    0x1f0(%rbp),%r11
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff8000207a:	48 85 ff             	test   %rdi,%rdi
ffffffff8000207d:	0f 84 c8 00 00 00    	je     ffffffff8000214b <plot_char_scaled_uncanvas+0x16b>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80002083:	4c 8b ad 00 02 00 00 	mov    0x200(%rbp),%r13
ffffffff8000208a:	48 8b bd f8 01 00 00 	mov    0x1f8(%rbp),%rdi
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80002091:	45 31 d2             	xor    %r10d,%r10d
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80002094:	4c 8b a5 e0 01 00 00 	mov    0x1e0(%rbp),%r12
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff8000209b:	49 c1 ed 02          	shr    $0x2,%r13
ffffffff8000209f:	48 89 7c 24 18       	mov    %rdi,0x18(%rsp)
ffffffff800020a4:	4d 0f af dd          	imul   %r13,%r11
ffffffff800020a8:	49 01 c3             	add    %rax,%r11
ffffffff800020ab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff800020b0:	4c 89 d0             	mov    %r10,%rax
ffffffff800020b3:	31 d2                	xor    %edx,%edx
ffffffff800020b5:	49 f7 f4             	div    %r12
        bool *glyph_pointer = glyph + (fy * ctx->font_width);
ffffffff800020b8:	0f b6 f0             	movzbl %al,%esi
ffffffff800020bb:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800020c0:	48 01 c6             	add    %rax,%rsi
ffffffff800020c3:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
ffffffff800020c8:	48 0f af f3          	imul   %rbx,%rsi
ffffffff800020cc:	48 01 c6             	add    %rax,%rsi
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff800020cf:	48 85 db             	test   %rbx,%rbx
ffffffff800020d2:	74 66                	je     ffffffff8000213a <plot_char_scaled_uncanvas+0x15a>
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff800020d4:	4c 8b 85 d8 01 00 00 	mov    0x1d8(%rbp),%r8
ffffffff800020db:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800020e0:	4c 8d 0c 1e          	lea    (%rsi,%rbx,1),%r9
ffffffff800020e4:	4b 8d 04 18          	lea    (%r8,%r11,1),%rax
ffffffff800020e8:	4a 8d 3c 85 00 00 00 	lea    0x0(,%r8,4),%rdi
ffffffff800020ef:	00 
ffffffff800020f0:	48 8d 0c 81          	lea    (%rcx,%rax,4),%rcx
ffffffff800020f4:	0f 1f 40 00          	nopl   0x0(%rax)
ffffffff800020f8:	4d 85 c0             	test   %r8,%r8
ffffffff800020fb:	74 31                	je     ffffffff8000212e <plot_char_scaled_uncanvas+0x14e>
ffffffff800020fd:	80 3e 00             	cmpb   $0x0,(%rsi)
ffffffff80002100:	44 89 fa             	mov    %r15d,%edx
ffffffff80002103:	48 89 c8             	mov    %rcx,%rax
ffffffff80002106:	41 0f 45 d6          	cmovne %r14d,%edx
ffffffff8000210a:	48 29 f8             	sub    %rdi,%rax
ffffffff8000210d:	40 f6 c7 04          	test   $0x4,%dil
ffffffff80002111:	74 0d                	je     ffffffff80002120 <plot_char_scaled_uncanvas+0x140>
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002113:	89 10                	mov    %edx,(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002115:	48 83 c0 04          	add    $0x4,%rax
ffffffff80002119:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000211c:	74 10                	je     ffffffff8000212e <plot_char_scaled_uncanvas+0x14e>
ffffffff8000211e:	66 90                	xchg   %ax,%ax
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002120:	89 10                	mov    %edx,(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002122:	48 83 c0 08          	add    $0x8,%rax
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002126:	89 50 fc             	mov    %edx,-0x4(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002129:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000212c:	75 f2                	jne    ffffffff80002120 <plot_char_scaled_uncanvas+0x140>
            glyph_pointer++;
ffffffff8000212e:	48 83 c6 01          	add    $0x1,%rsi
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80002132:	48 01 f9             	add    %rdi,%rcx
ffffffff80002135:	4c 39 ce             	cmp    %r9,%rsi
ffffffff80002138:	75 be                	jne    ffffffff800020f8 <plot_char_scaled_uncanvas+0x118>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff8000213a:	49 83 c2 01          	add    $0x1,%r10
ffffffff8000213e:	4d 01 eb             	add    %r13,%r11
ffffffff80002141:	4c 39 14 24          	cmp    %r10,(%rsp)
ffffffff80002145:	0f 85 65 ff ff ff    	jne    ffffffff800020b0 <plot_char_scaled_uncanvas+0xd0>
}
ffffffff8000214b:	48 83 c4 20          	add    $0x20,%rsp
ffffffff8000214f:	5b                   	pop    %rbx
ffffffff80002150:	5d                   	pop    %rbp
ffffffff80002151:	41 5c                	pop    %r12
ffffffff80002153:	41 5d                	pop    %r13
ffffffff80002155:	41 5e                	pop    %r14
ffffffff80002157:	41 5f                	pop    %r15
ffffffff80002159:	c3                   	ret
ffffffff8000215a:	c3                   	ret
ffffffff8000215b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80002160 <flanterm_fb_init>:
    uint32_t *default_bg, uint32_t *default_fg,
    uint32_t *default_bg_bright, uint32_t *default_fg_bright,
    void *font, size_t font_width, size_t font_height, size_t font_spacing,
    size_t font_scale_x, size_t font_scale_y,
    size_t margin
) {
ffffffff80002160:	f3 0f 1e fa          	endbr64
ffffffff80002164:	41 57                	push   %r15
ffffffff80002166:	49 89 ff             	mov    %rdi,%r15
ffffffff80002169:	41 56                	push   %r14
ffffffff8000216b:	41 55                	push   %r13
ffffffff8000216d:	49 89 cd             	mov    %rcx,%r13
ffffffff80002170:	41 54                	push   %r12
ffffffff80002172:	4d 89 c4             	mov    %r8,%r12
ffffffff80002175:	55                   	push   %rbp
ffffffff80002176:	53                   	push   %rbx
ffffffff80002177:	48 83 ec 48          	sub    $0x48,%rsp
ffffffff8000217b:	8b 84 24 88 00 00 00 	mov    0x88(%rsp),%eax
ffffffff80002182:	44 8b b4 24 80 00 00 	mov    0x80(%rsp),%r14d
ffffffff80002189:	00 
ffffffff8000218a:	48 89 74 24 18       	mov    %rsi,0x18(%rsp)
    if (font_scale_x == 0 || font_scale_y == 0) {
ffffffff8000218f:	48 83 bc 24 08 01 00 	cmpq   $0x0,0x108(%rsp)
ffffffff80002196:	00 00 
) {
ffffffff80002198:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
ffffffff8000219d:	89 44 24 34          	mov    %eax,0x34(%rsp)
ffffffff800021a1:	8b 84 24 90 00 00 00 	mov    0x90(%rsp),%eax
ffffffff800021a8:	4c 89 4c 24 20       	mov    %r9,0x20(%rsp)
ffffffff800021ad:	48 8b ac 24 f8 00 00 	mov    0xf8(%rsp),%rbp
ffffffff800021b4:	00 
ffffffff800021b5:	89 44 24 10          	mov    %eax,0x10(%rsp)
ffffffff800021b9:	8b 84 24 98 00 00 00 	mov    0x98(%rsp),%eax
ffffffff800021c0:	44 88 74 24 33       	mov    %r14b,0x33(%rsp)
ffffffff800021c5:	89 44 24 38          	mov    %eax,0x38(%rsp)
ffffffff800021c9:	8b 84 24 a0 00 00 00 	mov    0xa0(%rsp),%eax
ffffffff800021d0:	89 44 24 2c          	mov    %eax,0x2c(%rsp)
ffffffff800021d4:	8b 84 24 a8 00 00 00 	mov    0xa8(%rsp),%eax
ffffffff800021db:	89 44 24 3c          	mov    %eax,0x3c(%rsp)
    if (font_scale_x == 0 || font_scale_y == 0) {
ffffffff800021df:	0f 84 b4 07 00 00    	je     ffffffff80002999 <flanterm_fb_init+0x839>
ffffffff800021e5:	48 83 bc 24 10 01 00 	cmpq   $0x0,0x110(%rsp)
ffffffff800021ec:	00 00 
ffffffff800021ee:	0f 84 a5 07 00 00    	je     ffffffff80002999 <flanterm_fb_init+0x839>
            font_scale_x = 4;
            font_scale_y = 4;
        }
    }

    if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {
ffffffff800021f4:	41 80 fe 07          	cmp    $0x7,%r14b
ffffffff800021f8:	0f 96 c0             	setbe  %al
ffffffff800021fb:	44 3a 74 24 10       	cmp    0x10(%rsp),%r14b
ffffffff80002200:	0f 95 c2             	setne  %dl
ffffffff80002203:	08 d0                	or     %dl,%al
ffffffff80002205:	0f 85 d0 08 00 00    	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
ffffffff8000220b:	44 3a 74 24 2c       	cmp    0x2c(%rsp),%r14b
ffffffff80002210:	0f 85 c5 08 00 00    	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
        return NULL;
    }

    if (_malloc == NULL) {
ffffffff80002216:	4d 85 ff             	test   %r15,%r15
ffffffff80002219:	0f 84 c9 08 00 00    	je     ffffffff80002ae8 <flanterm_fb_init+0x988>
        return NULL;
#endif
    }

    struct flanterm_fb_context *ctx = NULL;
    ctx = _malloc(sizeof(struct flanterm_fb_context));
ffffffff8000221f:	bf 20 03 00 00       	mov    $0x320,%edi
ffffffff80002224:	41 ff d7             	call   *%r15
ffffffff80002227:	48 89 c3             	mov    %rax,%rbx
    if (ctx == NULL) {
ffffffff8000222a:	48 85 c0             	test   %rax,%rax
ffffffff8000222d:	0f 84 a8 08 00 00    	je     ffffffff80002adb <flanterm_fb_init+0x97b>
        goto fail;
    }

    struct flanterm_context *_ctx = (void *)ctx;
    memset(ctx, 0, sizeof(struct flanterm_fb_context));
ffffffff80002233:	31 f6                	xor    %esi,%esi
ffffffff80002235:	ba 20 03 00 00       	mov    $0x320,%edx
ffffffff8000223a:	48 89 c7             	mov    %rax,%rdi
ffffffff8000223d:	e8 2e 45 00 00       	call   ffffffff80006770 <memset>

    ctx->red_mask_size = red_mask_size;
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
    ctx->green_mask_size = green_mask_size;
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002242:	8b 74 24 10          	mov    0x10(%rsp),%esi
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
ffffffff80002246:	0f b6 44 24 34       	movzbl 0x34(%rsp),%eax
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff8000224b:	0f b6 54 24 38       	movzbl 0x38(%rsp),%edx
    ctx->red_mask_size = red_mask_size;
ffffffff80002250:	0f b6 4c 24 33       	movzbl 0x33(%rsp),%ecx
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002255:	89 f7                	mov    %esi,%edi
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
ffffffff80002257:	42 8d 44 30 f8       	lea    -0x8(%rax,%r14,1),%eax
    ctx->red_mask_size = red_mask_size;
ffffffff8000225c:	40 0f b6 f6          	movzbl %sil,%esi
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002260:	8d 54 3a f8          	lea    -0x8(%rdx,%rdi,1),%edx
    ctx->red_mask_size = red_mask_size;
ffffffff80002264:	88 c5                	mov    %al,%ch
ffffffff80002266:	c1 e6 10             	shl    $0x10,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002269:	44 0f b6 f0          	movzbl %al,%r14d
    ctx->red_mask_size = red_mask_size;
ffffffff8000226d:	0f b7 c9             	movzwl %cx,%ecx
ffffffff80002270:	89 d7                	mov    %edx,%edi
ffffffff80002272:	44 0f b6 da          	movzbl %dl,%r11d
ffffffff80002276:	c1 e7 18             	shl    $0x18,%edi
ffffffff80002279:	09 f1                	or     %esi,%ecx
    ctx->blue_mask_size = blue_mask_size;
ffffffff8000227b:	8b 74 24 2c          	mov    0x2c(%rsp),%esi
    ctx->red_mask_size = red_mask_size;
ffffffff8000227f:	09 f9                	or     %edi,%ecx
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff80002281:	0f b6 7c 24 3c       	movzbl 0x3c(%rsp),%edi

    if (ansi_colours != NULL) {
ffffffff80002286:	48 83 bc 24 b8 00 00 	cmpq   $0x0,0xb8(%rsp)
ffffffff8000228d:	00 00 
    ctx->blue_mask_size = blue_mask_size;
ffffffff8000228f:	40 88 b3 24 02 00 00 	mov    %sil,0x224(%rbx)
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff80002296:	8d 74 37 f8          	lea    -0x8(%rdi,%rsi,1),%esi
    ctx->red_mask_size = red_mask_size;
ffffffff8000229a:	89 8b 20 02 00 00    	mov    %ecx,0x220(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022a0:	40 0f b6 fe          	movzbl %sil,%edi
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff800022a4:	40 88 b3 25 02 00 00 	mov    %sil,0x225(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022ab:	89 7c 24 10          	mov    %edi,0x10(%rsp)
    if (ansi_colours != NULL) {
ffffffff800022af:	0f 84 d6 08 00 00    	je     ffffffff80002b8b <flanterm_fb_init+0xa2b>
        for (size_t i = 0; i < 8; i++) {
ffffffff800022b5:	45 31 c9             	xor    %r9d,%r9d
            ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]);
ffffffff800022b8:	48 8b bc 24 b8 00 00 	mov    0xb8(%rsp),%rdi
ffffffff800022bf:	00 
ffffffff800022c0:	46 8b 04 8f          	mov    (%rdi,%r9,4),%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800022c4:	44 89 c1             	mov    %r8d,%ecx
ffffffff800022c7:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022ca:	44 89 d9             	mov    %r11d,%ecx
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800022cd:	41 89 fa             	mov    %edi,%r10d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022d0:	44 89 c7             	mov    %r8d,%edi
    uint32_t b =  colour & 0xff;
ffffffff800022d3:	45 0f b6 c0          	movzbl %r8b,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022d7:	c1 ef 10             	shr    $0x10,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022da:	41 d3 e2             	shl    %cl,%r10d
ffffffff800022dd:	44 89 f1             	mov    %r14d,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022e0:	40 0f b6 ff          	movzbl %dil,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022e4:	d3 e7                	shl    %cl,%edi
ffffffff800022e6:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
ffffffff800022eb:	44 09 d7             	or     %r10d,%edi
ffffffff800022ee:	41 d3 e0             	shl    %cl,%r8d
ffffffff800022f1:	44 09 c7             	or     %r8d,%edi
ffffffff800022f4:	42 89 bc 8b 48 02 00 	mov    %edi,0x248(%rbx,%r9,4)
ffffffff800022fb:	00 
        for (size_t i = 0; i < 8; i++) {
ffffffff800022fc:	49 83 c1 01          	add    $0x1,%r9
ffffffff80002300:	49 83 f9 08          	cmp    $0x8,%r9
ffffffff80002304:	75 b2                	jne    ffffffff800022b8 <flanterm_fb_init+0x158>
        ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta
        ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan
        ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey
    }

    if (ansi_bright_colours != NULL) {
ffffffff80002306:	48 83 bc 24 c0 00 00 	cmpq   $0x0,0xc0(%rsp)
ffffffff8000230d:	00 00 
ffffffff8000230f:	0f 84 ee 08 00 00    	je     ffffffff80002c03 <flanterm_fb_init+0xaa3>
        for (size_t i = 0; i < 8; i++) {
ffffffff80002315:	45 31 c9             	xor    %r9d,%r9d
            ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);
ffffffff80002318:	48 8b bc 24 c0 00 00 	mov    0xc0(%rsp),%rdi
ffffffff8000231f:	00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002320:	44 89 f1             	mov    %r14d,%ecx
            ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);
ffffffff80002323:	46 8b 04 8f          	mov    (%rdi,%r9,4),%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002327:	45 89 c2             	mov    %r8d,%r10d
ffffffff8000232a:	41 c1 ea 10          	shr    $0x10,%r10d
ffffffff8000232e:	45 0f b6 d2          	movzbl %r10b,%r10d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002332:	41 d3 e2             	shl    %cl,%r10d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002335:	44 89 c1             	mov    %r8d,%ecx
    uint32_t b =  colour & 0xff;
ffffffff80002338:	45 0f b6 c0          	movzbl %r8b,%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000233c:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000233f:	44 89 d9             	mov    %r11d,%ecx
ffffffff80002342:	d3 e7                	shl    %cl,%edi
ffffffff80002344:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
ffffffff80002349:	44 09 d7             	or     %r10d,%edi
ffffffff8000234c:	41 d3 e0             	shl    %cl,%r8d
ffffffff8000234f:	44 09 c7             	or     %r8d,%edi
ffffffff80002352:	42 89 bc 8b 68 02 00 	mov    %edi,0x268(%rbx,%r9,4)
ffffffff80002359:	00 
        for (size_t i = 0; i < 8; i++) {
ffffffff8000235a:	49 83 c1 01          	add    $0x1,%r9
ffffffff8000235e:	49 83 f9 08          	cmp    $0x8,%r9
ffffffff80002362:	75 b4                	jne    ffffffff80002318 <flanterm_fb_init+0x1b8>
    }

    if (default_bg != NULL) {
        ctx->default_bg = convert_colour(_ctx, *default_bg);
    } else {
        ctx->default_bg = 0x00000000; // background (black)
ffffffff80002364:	45 31 c0             	xor    %r8d,%r8d
    if (default_bg != NULL) {
ffffffff80002367:	48 83 bc 24 c8 00 00 	cmpq   $0x0,0xc8(%rsp)
ffffffff8000236e:	00 00 
ffffffff80002370:	74 31                	je     ffffffff800023a3 <flanterm_fb_init+0x243>
        ctx->default_bg = convert_colour(_ctx, *default_bg);
ffffffff80002372:	48 8b bc 24 c8 00 00 	mov    0xc8(%rsp),%rdi
ffffffff80002379:	00 
ffffffff8000237a:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000237c:	89 f9                	mov    %edi,%ecx
    uint32_t b =  colour & 0xff;
ffffffff8000237e:	44 0f b6 c7          	movzbl %dil,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002382:	c1 ef 10             	shr    $0x10,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002385:	0f b6 cd             	movzbl %ch,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002388:	40 0f b6 ff          	movzbl %dil,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000238c:	41 89 c9             	mov    %ecx,%r9d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000238f:	89 d1                	mov    %edx,%ecx
ffffffff80002391:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002394:	89 f1                	mov    %esi,%ecx
ffffffff80002396:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002399:	89 c1                	mov    %eax,%ecx
ffffffff8000239b:	45 09 c8             	or     %r9d,%r8d
ffffffff8000239e:	d3 e7                	shl    %cl,%edi
ffffffff800023a0:	41 09 f8             	or     %edi,%r8d
    }

    if (default_fg != NULL) {
ffffffff800023a3:	48 83 bc 24 d0 00 00 	cmpq   $0x0,0xd0(%rsp)
ffffffff800023aa:	00 00 
ffffffff800023ac:	44 89 83 8c 02 00 00 	mov    %r8d,0x28c(%rbx)
ffffffff800023b3:	0f 84 a3 09 00 00    	je     ffffffff80002d5c <flanterm_fb_init+0xbfc>
        ctx->default_fg = convert_colour(_ctx, *default_fg);
ffffffff800023b9:	48 8b bc 24 d0 00 00 	mov    0xd0(%rsp),%rdi
ffffffff800023c0:	00 
ffffffff800023c1:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023c3:	89 f9                	mov    %edi,%ecx
    uint32_t b =  colour & 0xff;
ffffffff800023c5:	44 0f b6 c7          	movzbl %dil,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800023c9:	c1 ef 10             	shr    $0x10,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023cc:	0f b6 cd             	movzbl %ch,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800023cf:	40 0f b6 ff          	movzbl %dil,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023d3:	41 89 c9             	mov    %ecx,%r9d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800023d6:	89 d1                	mov    %edx,%ecx
ffffffff800023d8:	41 d3 e1             	shl    %cl,%r9d
ffffffff800023db:	89 f1                	mov    %esi,%ecx
ffffffff800023dd:	41 d3 e0             	shl    %cl,%r8d
ffffffff800023e0:	89 c1                	mov    %eax,%ecx
ffffffff800023e2:	45 09 c8             	or     %r9d,%r8d
ffffffff800023e5:	d3 e7                	shl    %cl,%edi
ffffffff800023e7:	41 09 f8             	or     %edi,%r8d
ffffffff800023ea:	45 89 c2             	mov    %r8d,%r10d
    } else {
        ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey)
    }

    if (default_bg_bright != NULL) {
ffffffff800023ed:	48 83 bc 24 d8 00 00 	cmpq   $0x0,0xd8(%rsp)
ffffffff800023f4:	00 00 
ffffffff800023f6:	44 89 93 88 02 00 00 	mov    %r10d,0x288(%rbx)
ffffffff800023fd:	0f 84 cf 08 00 00    	je     ffffffff80002cd2 <flanterm_fb_init+0xb72>
        ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright);
ffffffff80002403:	48 8b bc 24 d8 00 00 	mov    0xd8(%rsp),%rdi
ffffffff8000240a:	00 
ffffffff8000240b:	44 8b 07             	mov    (%rdi),%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000240e:	44 89 c1             	mov    %r8d,%ecx
ffffffff80002411:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002414:	89 d1                	mov    %edx,%ecx
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002416:	41 89 f9             	mov    %edi,%r9d
    uint32_t b =  colour & 0xff;
ffffffff80002419:	41 0f b6 f8          	movzbl %r8b,%edi
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000241d:	41 c1 e8 10          	shr    $0x10,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002421:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002424:	89 f1                	mov    %esi,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002426:	45 0f b6 c0          	movzbl %r8b,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000242a:	d3 e7                	shl    %cl,%edi
ffffffff8000242c:	89 c1                	mov    %eax,%ecx
ffffffff8000242e:	44 09 cf             	or     %r9d,%edi
ffffffff80002431:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002434:	44 09 c7             	or     %r8d,%edi
    } else {
        ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black)
    }

    if (default_fg_bright != NULL) {
ffffffff80002437:	48 83 bc 24 e0 00 00 	cmpq   $0x0,0xe0(%rsp)
ffffffff8000243e:	00 00 
ffffffff80002440:	89 bb 94 02 00 00    	mov    %edi,0x294(%rbx)
ffffffff80002446:	0f 84 60 08 00 00    	je     ffffffff80002cac <flanterm_fb_init+0xb4c>
        ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright);
ffffffff8000244c:	48 8b bc 24 e0 00 00 	mov    0xe0(%rsp),%rdi
ffffffff80002453:	00 
ffffffff80002454:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002456:	89 f9                	mov    %edi,%ecx
ffffffff80002458:	0f b6 cd             	movzbl %ch,%ecx
ffffffff8000245b:	41 89 c8             	mov    %ecx,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000245e:	89 d1                	mov    %edx,%ecx
    uint32_t b =  colour & 0xff;
ffffffff80002460:	40 0f b6 d7          	movzbl %dil,%edx
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002464:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002467:	89 f1                	mov    %esi,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002469:	89 fe                	mov    %edi,%esi
ffffffff8000246b:	c1 ee 10             	shr    $0x10,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000246e:	d3 e2                	shl    %cl,%edx
ffffffff80002470:	89 c1                	mov    %eax,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002472:	40 0f b6 f6          	movzbl %sil,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002476:	44 09 c2             	or     %r8d,%edx
ffffffff80002479:	d3 e6                	shl    %cl,%esi
ffffffff8000247b:	09 f2                	or     %esi,%edx
    }

    ctx->text_fg = ctx->default_fg;
    ctx->text_bg = 0xffffffff;

    ctx->framebuffer = (void *)framebuffer;
ffffffff8000247d:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
ffffffff80002482:	89 93 90 02 00 00    	mov    %edx,0x290(%rbx)
    ctx->height = height;
    ctx->pitch = pitch;

#define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8)

    if (font != NULL) {
ffffffff80002488:	48 83 bc 24 e8 00 00 	cmpq   $0x0,0xe8(%rsp)
ffffffff8000248f:	00 00 
    ctx->text_fg = ctx->default_fg;
ffffffff80002491:	44 89 93 e0 02 00 00 	mov    %r10d,0x2e0(%rbx)
    ctx->framebuffer = (void *)framebuffer;
ffffffff80002498:	48 89 83 f8 01 00 00 	mov    %rax,0x1f8(%rbx)
    ctx->pitch = pitch;
ffffffff8000249f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    ctx->text_bg = 0xffffffff;
ffffffff800024a4:	c7 83 e4 02 00 00 ff 	movl   $0xffffffff,0x2e4(%rbx)
ffffffff800024ab:	ff ff ff 
    ctx->width = width;
ffffffff800024ae:	4c 89 ab 08 02 00 00 	mov    %r13,0x208(%rbx)
    ctx->height = height;
ffffffff800024b5:	4c 89 a3 10 02 00 00 	mov    %r12,0x210(%rbx)
    ctx->pitch = pitch;
ffffffff800024bc:	48 89 83 00 02 00 00 	mov    %rax,0x200(%rbx)
    if (font != NULL) {
ffffffff800024c3:	0f 84 2e 08 00 00    	je     ffffffff80002cf7 <flanterm_fb_init+0xb97>
        ctx->font_width = font_width;
ffffffff800024c9:	48 8b 84 24 f0 00 00 	mov    0xf0(%rsp),%rax
ffffffff800024d0:	00 
        ctx->font_height = font_height;
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024d1:	48 89 ef             	mov    %rbp,%rdi
        ctx->font_height = font_height;
ffffffff800024d4:	48 89 ab c0 01 00 00 	mov    %rbp,0x1c0(%rbx)
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024db:	48 0f af f8          	imul   %rax,%rdi
        ctx->font_width = font_width;
ffffffff800024df:	48 89 83 b8 01 00 00 	mov    %rax,0x1b8(%rbx)
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024e6:	48 c1 e7 08          	shl    $0x8,%rdi
ffffffff800024ea:	48 c1 ef 03          	shr    $0x3,%rdi
ffffffff800024ee:	48 89 bb 28 02 00 00 	mov    %rdi,0x228(%rbx)
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff800024f5:	41 ff d7             	call   *%r15
ffffffff800024f8:	48 89 83 30 02 00 00 	mov    %rax,0x230(%rbx)
ffffffff800024ff:	48 89 c7             	mov    %rax,%rdi
        if (ctx->font_bits == NULL) {
ffffffff80002502:	48 85 c0             	test   %rax,%rax
ffffffff80002505:	0f 84 0f 05 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
            goto fail;
        }
        memcpy(ctx->font_bits, font, ctx->font_bits_size);
ffffffff8000250b:	48 8b 93 28 02 00 00 	mov    0x228(%rbx),%rdx
ffffffff80002512:	48 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%rsi
ffffffff80002519:	00 
ffffffff8000251a:	e8 21 42 00 00       	call   ffffffff80006740 <memcpy>
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
    }

#undef FONT_BYTES

    ctx->font_width += font_spacing;
ffffffff8000251f:	48 8b 84 24 00 01 00 	mov    0x100(%rsp),%rax
ffffffff80002526:	00 
ffffffff80002527:	48 03 83 b8 01 00 00 	add    0x1b8(%rbx),%rax
ffffffff8000252e:	48 89 83 b8 01 00 00 	mov    %rax,0x1b8(%rbx)

    ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool);
ffffffff80002535:	48 0f af c5          	imul   %rbp,%rax
ffffffff80002539:	48 c1 e0 08          	shl    $0x8,%rax
ffffffff8000253d:	48 89 83 38 02 00 00 	mov    %rax,0x238(%rbx)
ffffffff80002544:	48 89 c7             	mov    %rax,%rdi
    ctx->font_bool = _malloc(ctx->font_bool_size);
ffffffff80002547:	41 ff d7             	call   *%r15
ffffffff8000254a:	48 89 83 40 02 00 00 	mov    %rax,0x240(%rbx)
ffffffff80002551:	48 89 c2             	mov    %rax,%rdx
    if (ctx->font_bool == NULL) {
ffffffff80002554:	48 85 c0             	test   %rax,%rax
ffffffff80002557:	0f 84 bd 04 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
    }

    ctx->font_scale_x = font_scale_x;
    ctx->font_scale_y = font_scale_y;

    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff8000255d:	4c 8b 93 b8 01 00 00 	mov    0x1b8(%rbx),%r10
ffffffff80002564:	49 89 ee             	mov    %rbp,%r14
ffffffff80002567:	45 31 e4             	xor    %r12d,%r12d
                if ((glyph[y] & (0x80 >> x))) {
ffffffff8000256a:	48 89 de             	mov    %rbx,%rsi
ffffffff8000256d:	4c 8b ab 30 02 00 00 	mov    0x230(%rbx),%r13
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002574:	49 c7 c1 40 ff ff ff 	mov    $0xffffffffffffff40,%r9
                if ((glyph[y] & (0x80 >> x))) {
ffffffff8000257b:	41 b8 80 00 00 00    	mov    $0x80,%r8d
ffffffff80002581:	4d 0f af f2          	imul   %r10,%r14
ffffffff80002585:	4e 8d 5c 2d 00       	lea    0x0(%rbp,%r13,1),%r11
ffffffff8000258a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        for (size_t y = 0; y < font_height; y++) {
ffffffff80002590:	4a 8d 3c 12          	lea    (%rdx,%r10,1),%rdi
ffffffff80002594:	4b 8d 04 2c          	lea    (%r12,%r13,1),%rax
ffffffff80002598:	48 89 d3             	mov    %rdx,%rbx
ffffffff8000259b:	48 85 ed             	test   %rbp,%rbp
ffffffff8000259e:	74 64                	je     ffffffff80002604 <flanterm_fb_init+0x4a4>
ffffffff800025a0:	4c 89 64 24 10       	mov    %r12,0x10(%rsp)
ffffffff800025a5:	0f 1f 00             	nopl   (%rax)
            for (size_t x = 0; x < 8; x++) {
ffffffff800025a8:	4c 89 74 24 08       	mov    %r14,0x8(%rsp)
ffffffff800025ad:	31 c9                	xor    %ecx,%ecx
ffffffff800025af:	90                   	nop
                if ((glyph[y] & (0x80 >> x))) {
ffffffff800025b0:	44 0f b6 20          	movzbl (%rax),%r12d
ffffffff800025b4:	45 89 c6             	mov    %r8d,%r14d
ffffffff800025b7:	41 d3 fe             	sar    %cl,%r14d
ffffffff800025ba:	45 85 e6             	test   %r12d,%r14d
                    ctx->font_bool[offset] = true;
ffffffff800025bd:	0f 95 04 0b          	setne  (%rbx,%rcx,1)
            for (size_t x = 0; x < 8; x++) {
ffffffff800025c1:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800025c5:	48 83 f9 08          	cmp    $0x8,%rcx
ffffffff800025c9:	75 e5                	jne    ffffffff800025b0 <flanterm_fb_init+0x450>
ffffffff800025cb:	4c 8b 74 24 08       	mov    0x8(%rsp),%r14
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff800025d0:	48 8d 4b 08          	lea    0x8(%rbx),%rcx
ffffffff800025d4:	49 83 fa 08          	cmp    $0x8,%r10
ffffffff800025d8:	76 16                	jbe    ffffffff800025f0 <flanterm_fb_init+0x490>
                if (i >= 0xc0 && i <= 0xdf) {
ffffffff800025da:	49 83 f9 1f          	cmp    $0x1f,%r9
ffffffff800025de:	0f 86 1c 04 00 00    	jbe    ffffffff80002a00 <flanterm_fb_init+0x8a0>
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff800025e4:	c6 01 00             	movb   $0x0,(%rcx)
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff800025e7:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800025eb:	48 39 f9             	cmp    %rdi,%rcx
ffffffff800025ee:	75 ea                	jne    ffffffff800025da <flanterm_fb_init+0x47a>
        for (size_t y = 0; y < font_height; y++) {
ffffffff800025f0:	48 83 c0 01          	add    $0x1,%rax
ffffffff800025f4:	4c 01 d7             	add    %r10,%rdi
ffffffff800025f7:	4c 01 d3             	add    %r10,%rbx
ffffffff800025fa:	49 39 c3             	cmp    %rax,%r11
ffffffff800025fd:	75 a9                	jne    ffffffff800025a8 <flanterm_fb_init+0x448>
ffffffff800025ff:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
    for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) {
ffffffff80002604:	49 83 c1 01          	add    $0x1,%r9
ffffffff80002608:	49 01 eb             	add    %rbp,%r11
ffffffff8000260b:	4c 01 f2             	add    %r14,%rdx
ffffffff8000260e:	49 01 ec             	add    %rbp,%r12
ffffffff80002611:	49 83 f9 40          	cmp    $0x40,%r9
ffffffff80002615:	0f 85 75 ff ff ff    	jne    ffffffff80002590 <flanterm_fb_init+0x430>
    ctx->font_scale_x = font_scale_x;
ffffffff8000261b:	48 8b 84 24 08 01 00 	mov    0x108(%rsp),%rax
ffffffff80002622:	00 
ffffffff80002623:	31 d2                	xor    %edx,%edx
ffffffff80002625:	48 89 f3             	mov    %rsi,%rbx
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002628:	4c 0f af 94 24 08 01 	imul   0x108(%rsp),%r10
ffffffff8000262f:	00 00 
    ctx->font_scale_x = font_scale_x;
ffffffff80002631:	48 89 86 d8 01 00 00 	mov    %rax,0x1d8(%rsi)
    ctx->font_scale_y = font_scale_y;
ffffffff80002638:	48 8b 84 24 10 01 00 	mov    0x110(%rsp),%rax
ffffffff8000263f:	00 
ffffffff80002640:	48 89 86 e0 01 00 00 	mov    %rax,0x1e0(%rsi)
    ctx->glyph_height = font_height * font_scale_y;
ffffffff80002647:	48 0f af e8          	imul   %rax,%rbp

    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000264b:	48 8b 84 24 18 01 00 	mov    0x118(%rsp),%rax
ffffffff80002652:	00 
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002653:	4c 89 96 c8 01 00 00 	mov    %r10,0x1c8(%rsi)
    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000265a:	48 8d 3c 00          	lea    (%rax,%rax,1),%rdi
ffffffff8000265e:	48 8b 86 08 02 00 00 	mov    0x208(%rsi),%rax
    ctx->glyph_height = font_height * font_scale_y;
ffffffff80002665:	48 89 ae d0 01 00 00 	mov    %rbp,0x1d0(%rsi)
    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000266c:	48 29 f8             	sub    %rdi,%rax
ffffffff8000266f:	49 f7 f2             	div    %r10
ffffffff80002672:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff80002679:	48 89 c1             	mov    %rax,%rcx
ffffffff8000267c:	48 89 d6             	mov    %rdx,%rsi
ffffffff8000267f:	31 d2                	xor    %edx,%edx
ffffffff80002681:	48 8b 83 10 02 00 00 	mov    0x210(%rbx),%rax

    ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2;
ffffffff80002688:	48 d1 ee             	shr    $1,%rsi
ffffffff8000268b:	48 03 b4 24 18 01 00 	add    0x118(%rsp),%rsi
ffffffff80002692:	00 
ffffffff80002693:	48 89 b3 e8 01 00 00 	mov    %rsi,0x1e8(%rbx)
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff8000269a:	48 29 f8             	sub    %rdi,%rax
ffffffff8000269d:	48 f7 f5             	div    %rbp
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;

    ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);
ffffffff800026a0:	48 0f af c8          	imul   %rax,%rcx
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;
ffffffff800026a4:	48 d1 ea             	shr    $1,%rdx
ffffffff800026a7:	48 03 94 24 18 01 00 	add    0x118(%rsp),%rdx
ffffffff800026ae:	00 
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff800026af:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;
ffffffff800026b6:	48 89 93 f0 01 00 00 	mov    %rdx,0x1f0(%rbx)
    ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);
ffffffff800026bd:	48 8d 3c 49          	lea    (%rcx,%rcx,2),%rdi
ffffffff800026c1:	48 c1 e7 02          	shl    $0x2,%rdi
ffffffff800026c5:	48 89 bb a8 02 00 00 	mov    %rdi,0x2a8(%rbx)
    ctx->grid = _malloc(ctx->grid_size);
ffffffff800026cc:	41 ff d7             	call   *%r15
ffffffff800026cf:	48 89 83 c0 02 00 00 	mov    %rax,0x2c0(%rbx)
    if (ctx->grid == NULL) {
ffffffff800026d6:	48 85 c0             	test   %rax,%rax
ffffffff800026d9:	0f 84 3b 03 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800026df:	48 8b bb e0 00 00 00 	mov    0xe0(%rbx),%rdi
ffffffff800026e6:	48 0f af bb e8 00 00 	imul   0xe8(%rbx),%rdi
ffffffff800026ed:	00 
ffffffff800026ee:	48 85 ff             	test   %rdi,%rdi
ffffffff800026f1:	74 2d                	je     ffffffff80002720 <flanterm_fb_init+0x5c0>
ffffffff800026f3:	48 8d 14 7f          	lea    (%rdi,%rdi,2),%rdx
        ctx->grid[i].c = ' ';
        ctx->grid[i].fg = ctx->text_fg;
ffffffff800026f7:	8b b3 e0 02 00 00    	mov    0x2e0(%rbx),%esi
        ctx->grid[i].bg = ctx->text_bg;
ffffffff800026fd:	8b 8b e4 02 00 00    	mov    0x2e4(%rbx),%ecx
ffffffff80002703:	48 8d 14 90          	lea    (%rax,%rdx,4),%rdx
        ctx->grid[i].c = ' ';
ffffffff80002707:	c7 00 20 00 00 00    	movl   $0x20,(%rax)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff8000270d:	48 83 c0 0c          	add    $0xc,%rax
        ctx->grid[i].fg = ctx->text_fg;
ffffffff80002711:	89 70 f8             	mov    %esi,-0x8(%rax)
        ctx->grid[i].bg = ctx->text_bg;
ffffffff80002714:	89 48 fc             	mov    %ecx,-0x4(%rax)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80002717:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000271a:	75 eb                	jne    ffffffff80002707 <flanterm_fb_init+0x5a7>
    }

    ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item);
ffffffff8000271c:	48 c1 e7 05          	shl    $0x5,%rdi
ffffffff80002720:	48 89 bb b0 02 00 00 	mov    %rdi,0x2b0(%rbx)
    ctx->queue = _malloc(ctx->queue_size);
ffffffff80002727:	41 ff d7             	call   *%r15
ffffffff8000272a:	48 89 83 c8 02 00 00 	mov    %rax,0x2c8(%rbx)
ffffffff80002731:	48 89 c7             	mov    %rax,%rdi
    if (ctx->queue == NULL) {
ffffffff80002734:	48 85 c0             	test   %rax,%rax
ffffffff80002737:	0f 84 dd 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    ctx->queue_i = 0;
ffffffff8000273d:	48 c7 83 d0 02 00 00 	movq   $0x0,0x2d0(%rbx)
ffffffff80002744:	00 00 00 00 
    memset(ctx->queue, 0, ctx->queue_size);
ffffffff80002748:	48 8b 93 b0 02 00 00 	mov    0x2b0(%rbx),%rdx
ffffffff8000274f:	31 f6                	xor    %esi,%esi
ffffffff80002751:	e8 1a 40 00 00       	call   ffffffff80006770 <memset>

    ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *);
ffffffff80002756:	48 8b bb e0 00 00 00 	mov    0xe0(%rbx),%rdi
ffffffff8000275d:	48 0f af bb e8 00 00 	imul   0xe8(%rbx),%rdi
ffffffff80002764:	00 
ffffffff80002765:	48 c1 e7 03          	shl    $0x3,%rdi
ffffffff80002769:	48 89 bb b8 02 00 00 	mov    %rdi,0x2b8(%rbx)
    ctx->map = _malloc(ctx->map_size);
ffffffff80002770:	41 ff d7             	call   *%r15
ffffffff80002773:	48 89 83 d8 02 00 00 	mov    %rax,0x2d8(%rbx)
ffffffff8000277a:	48 89 c7             	mov    %rax,%rdi
    if (ctx->map == NULL) {
ffffffff8000277d:	48 85 c0             	test   %rax,%rax
ffffffff80002780:	0f 84 94 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    memset(ctx->map, 0, ctx->map_size);
ffffffff80002786:	48 8b 93 b8 02 00 00 	mov    0x2b8(%rbx),%rdx
ffffffff8000278d:	31 f6                	xor    %esi,%esi
ffffffff8000278f:	e8 dc 3f 00 00       	call   ffffffff80006770 <memset>

    if (canvas != NULL) {
ffffffff80002794:	48 83 bc 24 b0 00 00 	cmpq   $0x0,0xb0(%rsp)
ffffffff8000279b:	00 00 
ffffffff8000279d:	0f 84 e0 05 00 00    	je     ffffffff80002d83 <flanterm_fb_init+0xc23>
        ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);
ffffffff800027a3:	48 8b bb 08 02 00 00 	mov    0x208(%rbx),%rdi
ffffffff800027aa:	48 0f af bb 10 02 00 	imul   0x210(%rbx),%rdi
ffffffff800027b1:	00 
ffffffff800027b2:	48 c1 e7 02          	shl    $0x2,%rdi
ffffffff800027b6:	48 89 bb 98 02 00 00 	mov    %rdi,0x298(%rbx)
        ctx->canvas = _malloc(ctx->canvas_size);
ffffffff800027bd:	41 ff d7             	call   *%r15
ffffffff800027c0:	48 89 83 a0 02 00 00 	mov    %rax,0x2a0(%rbx)
ffffffff800027c7:	48 89 c7             	mov    %rax,%rdi
        if (ctx->canvas == NULL) {
ffffffff800027ca:	48 85 c0             	test   %rax,%rax
ffffffff800027cd:	0f 84 47 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
            goto fail;
        }
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff800027d3:	4c 8b 9b 08 02 00 00 	mov    0x208(%rbx),%r11
ffffffff800027da:	4c 0f af 9b 10 02 00 	imul   0x210(%rbx),%r11
ffffffff800027e1:	00 
ffffffff800027e2:	4d 85 db             	test   %r11,%r11
ffffffff800027e5:	74 5a                	je     ffffffff80002841 <flanterm_fb_init+0x6e1>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800027e7:	44 0f b6 93 21 02 00 	movzbl 0x221(%rbx),%r10d
ffffffff800027ee:	00 
ffffffff800027ef:	44 0f b6 8b 23 02 00 	movzbl 0x223(%rbx),%r9d
ffffffff800027f6:	00 
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff800027f7:	31 f6                	xor    %esi,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800027f9:	44 0f b6 83 25 02 00 	movzbl 0x225(%rbx),%r8d
ffffffff80002800:	00 
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff80002801:	48 8b 94 24 b0 00 00 	mov    0xb0(%rsp),%rdx
ffffffff80002808:	00 
            ctx->canvas[i] = convert_colour(_ctx, canvas[i]);
ffffffff80002809:	8b 2c b2             	mov    (%rdx,%rsi,4),%ebp
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000280c:	44 89 d1             	mov    %r10d,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000280f:	89 e8                	mov    %ebp,%eax
ffffffff80002811:	c1 e8 10             	shr    $0x10,%eax
ffffffff80002814:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002817:	d3 e0                	shl    %cl,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002819:	89 e9                	mov    %ebp,%ecx
    uint32_t b =  colour & 0xff;
ffffffff8000281b:	40 0f b6 ed          	movzbl %bpl,%ebp
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000281f:	0f b6 cd             	movzbl %ch,%ecx
ffffffff80002822:	41 89 cc             	mov    %ecx,%r12d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002825:	44 89 c9             	mov    %r9d,%ecx
ffffffff80002828:	41 d3 e4             	shl    %cl,%r12d
ffffffff8000282b:	44 89 c1             	mov    %r8d,%ecx
ffffffff8000282e:	44 09 e0             	or     %r12d,%eax
ffffffff80002831:	d3 e5                	shl    %cl,%ebp
ffffffff80002833:	09 e8                	or     %ebp,%eax
ffffffff80002835:	89 04 b7             	mov    %eax,(%rdi,%rsi,4)
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff80002838:	48 83 c6 01          	add    $0x1,%rsi
ffffffff8000283c:	49 39 f3             	cmp    %rsi,%r11
ffffffff8000283f:	75 c8                	jne    ffffffff80002809 <flanterm_fb_init+0x6a9>
        }
    }

    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002841:	48 83 bc 24 08 01 00 	cmpq   $0x1,0x108(%rsp)
ffffffff80002848:	00 01 
ffffffff8000284a:	0f 85 6c 05 00 00    	jne    ffffffff80002dbc <flanterm_fb_init+0xc5c>
ffffffff80002850:	48 83 bc 24 10 01 00 	cmpq   $0x1,0x110(%rsp)
ffffffff80002857:	00 01 
ffffffff80002859:	48 c7 c0 90 1d 00 80 	mov    $0xffffffff80001d90,%rax
ffffffff80002860:	0f 85 56 05 00 00    	jne    ffffffff80002dbc <flanterm_fb_init+0xc5c>
        if (canvas == NULL) {
            ctx->plot_char = plot_char_unscaled_uncanvas;
        } else {
            ctx->plot_char = plot_char_unscaled_canvas;
ffffffff80002866:	48 89 83 b0 01 00 00 	mov    %rax,0x1b0(%rbx)
    _ctx->restore_state = flanterm_fb_restore_state;
    _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;
    _ctx->full_refresh = flanterm_fb_full_refresh;
    _ctx->deinit = flanterm_fb_deinit;

    flanterm_context_reinit(_ctx);
ffffffff8000286d:	48 89 df             	mov    %rbx,%rdi
    _ctx->raw_putchar = flanterm_fb_raw_putchar;
ffffffff80002870:	48 c7 83 f0 00 00 00 	movq   $0xffffffff800018c0,0xf0(%rbx)
ffffffff80002877:	c0 18 00 80 
    _ctx->clear = flanterm_fb_clear;
ffffffff8000287b:	48 c7 83 f8 00 00 00 	movq   $0xffffffff80001350,0xf8(%rbx)
ffffffff80002882:	50 13 00 80 
    _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos;
ffffffff80002886:	48 c7 83 00 01 00 00 	movq   $0xffffffff800013e0,0x100(%rbx)
ffffffff8000288d:	e0 13 00 80 
    _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos;
ffffffff80002891:	48 c7 83 08 01 00 00 	movq   $0xffffffff80001430,0x108(%rbx)
ffffffff80002898:	30 14 00 80 
    _ctx->set_text_fg = flanterm_fb_set_text_fg;
ffffffff8000289c:	48 c7 83 10 01 00 00 	movq   $0xffffffff800014f0,0x110(%rbx)
ffffffff800028a3:	f0 14 00 80 
    _ctx->set_text_bg = flanterm_fb_set_text_bg;
ffffffff800028a7:	48 c7 83 18 01 00 00 	movq   $0xffffffff80001510,0x118(%rbx)
ffffffff800028ae:	10 15 00 80 
    _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright;
ffffffff800028b2:	48 c7 83 20 01 00 00 	movq   $0xffffffff80001530,0x120(%rbx)
ffffffff800028b9:	30 15 00 80 
    _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright;
ffffffff800028bd:	48 c7 83 28 01 00 00 	movq   $0xffffffff80001550,0x128(%rbx)
ffffffff800028c4:	50 15 00 80 
    _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb;
ffffffff800028c8:	48 c7 83 30 01 00 00 	movq   $0xffffffff80001570,0x130(%rbx)
ffffffff800028cf:	70 15 00 80 
    _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb;
ffffffff800028d3:	48 c7 83 38 01 00 00 	movq   $0xffffffff800015b0,0x138(%rbx)
ffffffff800028da:	b0 15 00 80 
    _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default;
ffffffff800028de:	48 c7 83 40 01 00 00 	movq   $0xffffffff800015f0,0x140(%rbx)
ffffffff800028e5:	f0 15 00 80 
    _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default;
ffffffff800028e9:	48 c7 83 48 01 00 00 	movq   $0xffffffff80001610,0x148(%rbx)
ffffffff800028f0:	10 16 00 80 
    _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright;
ffffffff800028f4:	48 c7 83 50 01 00 00 	movq   $0xffffffff80001620,0x150(%rbx)
ffffffff800028fb:	20 16 00 80 
    _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright;
ffffffff800028ff:	48 c7 83 58 01 00 00 	movq   $0xffffffff80001640,0x158(%rbx)
ffffffff80002906:	40 16 00 80 
    _ctx->move_character = flanterm_fb_move_character;
ffffffff8000290a:	48 c7 83 60 01 00 00 	movq   $0xffffffff80001470,0x160(%rbx)
ffffffff80002911:	70 14 00 80 
    _ctx->scroll = flanterm_fb_scroll;
ffffffff80002915:	48 c7 83 68 01 00 00 	movq   $0xffffffff80001260,0x168(%rbx)
ffffffff8000291c:	60 12 00 80 
    _ctx->revscroll = flanterm_fb_revscroll;
ffffffff80002920:	48 c7 83 70 01 00 00 	movq   $0xffffffff80001180,0x170(%rbx)
ffffffff80002927:	80 11 00 80 
    _ctx->swap_palette = flanterm_fb_swap_palette;
ffffffff8000292b:	48 c7 83 78 01 00 00 	movq   $0xffffffff800010b0,0x178(%rbx)
ffffffff80002932:	b0 10 00 80 
    _ctx->save_state = flanterm_fb_save_state;
ffffffff80002936:	48 c7 83 80 01 00 00 	movq   $0xffffffff80001050,0x180(%rbx)
ffffffff8000293d:	50 10 00 80 
    _ctx->restore_state = flanterm_fb_restore_state;
ffffffff80002941:	48 c7 83 88 01 00 00 	movq   $0xffffffff80001080,0x188(%rbx)
ffffffff80002948:	80 10 00 80 
    _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;
ffffffff8000294c:	48 c7 83 90 01 00 00 	movq   $0xffffffff80001760,0x190(%rbx)
ffffffff80002953:	60 17 00 80 
    _ctx->full_refresh = flanterm_fb_full_refresh;
ffffffff80002957:	48 c7 83 98 01 00 00 	movq   $0xffffffff800019b0,0x198(%rbx)
ffffffff8000295e:	b0 19 00 80 
    _ctx->deinit = flanterm_fb_deinit;
ffffffff80002962:	48 c7 83 a0 01 00 00 	movq   $0xffffffff80001b00,0x1a0(%rbx)
ffffffff80002969:	00 1b 00 80 
    flanterm_context_reinit(_ctx);
ffffffff8000296d:	e8 6e 04 00 00       	call   ffffffff80002de0 <flanterm_context_reinit>
    flanterm_fb_full_refresh(_ctx);
ffffffff80002972:	48 89 df             	mov    %rbx,%rdi
ffffffff80002975:	e8 36 f0 ff ff       	call   ffffffff800019b0 <flanterm_fb_full_refresh>

#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC
    if (_malloc == bump_alloc) {
ffffffff8000297a:	49 81 ff 00 10 00 80 	cmp    $0xffffffff80001000,%r15
ffffffff80002981:	0f 84 29 04 00 00    	je     ffffffff80002db0 <flanterm_fb_init+0xc50>
    if (ctx != NULL) {
        _free(ctx, sizeof(struct flanterm_fb_context));
    }

    return NULL;
}
ffffffff80002987:	48 83 c4 48          	add    $0x48,%rsp
ffffffff8000298b:	48 89 d8             	mov    %rbx,%rax
ffffffff8000298e:	5b                   	pop    %rbx
ffffffff8000298f:	5d                   	pop    %rbp
ffffffff80002990:	41 5c                	pop    %r12
ffffffff80002992:	41 5d                	pop    %r13
ffffffff80002994:	41 5e                	pop    %r14
ffffffff80002996:	41 5f                	pop    %r15
ffffffff80002998:	c3                   	ret
        if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {
ffffffff80002999:	49 81 fd ff 13 00 00 	cmp    $0x13ff,%r13
ffffffff800029a0:	76 25                	jbe    ffffffff800029c7 <flanterm_fb_init+0x867>
            font_scale_y = 4;
ffffffff800029a2:	48 c7 84 24 10 01 00 	movq   $0x4,0x110(%rsp)
ffffffff800029a9:	00 04 00 00 00 
            font_scale_x = 4;
ffffffff800029ae:	48 c7 84 24 08 01 00 	movq   $0x4,0x108(%rsp)
ffffffff800029b5:	00 04 00 00 00 
        if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {
ffffffff800029ba:	49 81 fc 3f 0b 00 00 	cmp    $0xb3f,%r12
ffffffff800029c1:	0f 87 2d f8 ff ff    	ja     ffffffff800021f4 <flanterm_fb_init+0x94>
        if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) {
ffffffff800029c7:	49 81 fd ff 09 00 00 	cmp    $0x9ff,%r13
ffffffff800029ce:	0f 97 c2             	seta   %dl
ffffffff800029d1:	31 c0                	xor    %eax,%eax
ffffffff800029d3:	49 81 fc 9f 05 00 00 	cmp    $0x59f,%r12
ffffffff800029da:	0f 97 c0             	seta   %al
ffffffff800029dd:	48 21 d0             	and    %rdx,%rax
ffffffff800029e0:	48 83 c0 01          	add    $0x1,%rax
ffffffff800029e4:	48 89 84 24 08 01 00 	mov    %rax,0x108(%rsp)
ffffffff800029eb:	00 
ffffffff800029ec:	48 89 84 24 10 01 00 	mov    %rax,0x110(%rsp)
ffffffff800029f3:	00 
ffffffff800029f4:	e9 fb f7 ff ff       	jmp    ffffffff800021f4 <flanterm_fb_init+0x94>
ffffffff800029f9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff80002a00:	44 0f b6 20          	movzbl (%rax),%r12d
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff80002a04:	48 83 c1 01          	add    $0x1,%rcx
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff80002a08:	41 83 e4 01          	and    $0x1,%r12d
ffffffff80002a0c:	44 88 61 ff          	mov    %r12b,-0x1(%rcx)
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff80002a10:	48 39 f9             	cmp    %rdi,%rcx
ffffffff80002a13:	75 eb                	jne    ffffffff80002a00 <flanterm_fb_init+0x8a0>
ffffffff80002a15:	e9 d6 fb ff ff       	jmp    ffffffff800025f0 <flanterm_fb_init+0x490>
    if (_malloc == bump_alloc) {
ffffffff80002a1a:	49 81 ff 00 10 00 80 	cmp    $0xffffffff80001000,%r15
ffffffff80002a21:	0f 84 a1 03 00 00    	je     ffffffff80002dc8 <flanterm_fb_init+0xc68>
    if (_free == NULL) {
ffffffff80002a27:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a2c:	48 85 c0             	test   %rax,%rax
ffffffff80002a2f:	0f 84 a6 00 00 00    	je     ffffffff80002adb <flanterm_fb_init+0x97b>
    if (ctx->canvas != NULL) {
ffffffff80002a35:	48 8b bb a0 02 00 00 	mov    0x2a0(%rbx),%rdi
ffffffff80002a3c:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a3f:	74 09                	je     ffffffff80002a4a <flanterm_fb_init+0x8ea>
        _free(ctx->canvas, ctx->canvas_size);
ffffffff80002a41:	48 8b b3 98 02 00 00 	mov    0x298(%rbx),%rsi
ffffffff80002a48:	ff d0                	call   *%rax
    if (ctx->map != NULL) {
ffffffff80002a4a:	48 8b bb d8 02 00 00 	mov    0x2d8(%rbx),%rdi
ffffffff80002a51:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a54:	74 0e                	je     ffffffff80002a64 <flanterm_fb_init+0x904>
        _free(ctx->map, ctx->map_size);
ffffffff80002a56:	48 8b b3 b8 02 00 00 	mov    0x2b8(%rbx),%rsi
ffffffff80002a5d:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a62:	ff d0                	call   *%rax
    if (ctx->queue != NULL) {
ffffffff80002a64:	48 8b bb c8 02 00 00 	mov    0x2c8(%rbx),%rdi
ffffffff80002a6b:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a6e:	74 0e                	je     ffffffff80002a7e <flanterm_fb_init+0x91e>
        _free(ctx->queue, ctx->queue_size);
ffffffff80002a70:	48 8b b3 b0 02 00 00 	mov    0x2b0(%rbx),%rsi
ffffffff80002a77:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a7c:	ff d0                	call   *%rax
    if (ctx->grid != NULL) {
ffffffff80002a7e:	48 8b bb c0 02 00 00 	mov    0x2c0(%rbx),%rdi
ffffffff80002a85:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a88:	74 0e                	je     ffffffff80002a98 <flanterm_fb_init+0x938>
        _free(ctx->grid, ctx->grid_size);
ffffffff80002a8a:	48 8b b3 a8 02 00 00 	mov    0x2a8(%rbx),%rsi
ffffffff80002a91:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a96:	ff d0                	call   *%rax
    if (ctx->font_bool != NULL) {
ffffffff80002a98:	48 8b bb 40 02 00 00 	mov    0x240(%rbx),%rdi
ffffffff80002a9f:	48 85 ff             	test   %rdi,%rdi
ffffffff80002aa2:	74 0e                	je     ffffffff80002ab2 <flanterm_fb_init+0x952>
        _free(ctx->font_bool, ctx->font_bool_size);
ffffffff80002aa4:	48 8b b3 38 02 00 00 	mov    0x238(%rbx),%rsi
ffffffff80002aab:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002ab0:	ff d0                	call   *%rax
    if (ctx->font_bits != NULL) {
ffffffff80002ab2:	48 8b bb 30 02 00 00 	mov    0x230(%rbx),%rdi
ffffffff80002ab9:	48 85 ff             	test   %rdi,%rdi
ffffffff80002abc:	74 0e                	je     ffffffff80002acc <flanterm_fb_init+0x96c>
        _free(ctx->font_bits, ctx->font_bits_size);
ffffffff80002abe:	48 8b b3 28 02 00 00 	mov    0x228(%rbx),%rsi
ffffffff80002ac5:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002aca:	ff d0                	call   *%rax
        _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80002acc:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002ad1:	be 20 03 00 00       	mov    $0x320,%esi
ffffffff80002ad6:	48 89 df             	mov    %rbx,%rdi
ffffffff80002ad9:	ff d0                	call   *%rax
        return NULL;
ffffffff80002adb:	31 db                	xor    %ebx,%ebx
ffffffff80002add:	e9 a5 fe ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
ffffffff80002ae2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        if (bump_allocated_instance == true) {
ffffffff80002ae8:	80 3d 12 96 00 00 00 	cmpb   $0x0,0x9612(%rip)        # ffffffff8000c101 <bump_allocated_instance>
ffffffff80002aef:	75 ea                	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
        if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) {
ffffffff80002af1:	49 81 fd 80 07 00 00 	cmp    $0x780,%r13
ffffffff80002af8:	77 20                	ja     ffffffff80002b1a <flanterm_fb_init+0x9ba>
        canvas = NULL;
ffffffff80002afa:	48 c7 84 24 b0 00 00 	movq   $0x0,0xb0(%rsp)
ffffffff80002b01:	00 00 00 00 00 
        _malloc = bump_alloc;
ffffffff80002b06:	49 c7 c7 00 10 00 80 	mov    $0xffffffff80001000,%r15
        if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) {
ffffffff80002b0d:	49 81 fc b0 04 00 00 	cmp    $0x4b0,%r12
ffffffff80002b14:	0f 86 05 f7 ff ff    	jbe    ffffffff8000221f <flanterm_fb_init+0xbf>
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b1a:	ba 80 07 00 00       	mov    $0x780,%edx
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b1f:	4c 89 e0             	mov    %r12,%rax
            size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height;
ffffffff80002b22:	be b0 04 00 00       	mov    $0x4b0,%esi
        canvas = NULL;
ffffffff80002b27:	48 c7 84 24 b0 00 00 	movq   $0x0,0xb0(%rsp)
ffffffff80002b2e:	00 00 00 00 00 
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b33:	49 39 d5             	cmp    %rdx,%r13
        _malloc = bump_alloc;
ffffffff80002b36:	49 c7 c7 00 10 00 80 	mov    $0xffffffff80001000,%r15
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b3d:	49 0f 46 d5          	cmovbe %r13,%rdx
            size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height;
ffffffff80002b41:	49 39 f4             	cmp    %rsi,%r12
ffffffff80002b44:	49 0f 46 f4          	cmovbe %r12,%rsi
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b48:	48 d1 e8             	shr    $1,%rax
ffffffff80002b4b:	49 89 d0             	mov    %rdx,%r8
ffffffff80002b4e:	48 89 f7             	mov    %rsi,%rdi
ffffffff80002b51:	49 d1 e8             	shr    $1,%r8
            height = height_limit;
ffffffff80002b54:	49 89 f4             	mov    %rsi,%r12
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b57:	48 d1 ef             	shr    $1,%rdi
ffffffff80002b5a:	48 29 f8             	sub    %rdi,%rax
ffffffff80002b5d:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
ffffffff80002b62:	48 0f af c7          	imul   %rdi,%rax
ffffffff80002b66:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
ffffffff80002b6b:	48 01 c7             	add    %rax,%rdi
ffffffff80002b6e:	48 89 f8             	mov    %rdi,%rax
ffffffff80002b71:	4c 89 ef             	mov    %r13,%rdi
            width = width_limit;
ffffffff80002b74:	49 89 d5             	mov    %rdx,%r13
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b77:	48 d1 ef             	shr    $1,%rdi
ffffffff80002b7a:	4c 29 c7             	sub    %r8,%rdi
ffffffff80002b7d:	48 8d 04 b8          	lea    (%rax,%rdi,4),%rax
ffffffff80002b81:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
            height = height_limit;
ffffffff80002b86:	e9 94 f6 ff ff       	jmp    ffffffff8000221f <flanterm_fb_init+0xbf>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002b8b:	bf aa 00 00 00       	mov    $0xaa,%edi
ffffffff80002b90:	89 c1                	mov    %eax,%ecx
ffffffff80002b92:	41 b8 55 00 00 00    	mov    $0x55,%r8d
        ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black
ffffffff80002b98:	c7 83 48 02 00 00 00 	movl   $0x0,0x248(%rbx)
ffffffff80002b9f:	00 00 00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002ba2:	41 89 f9             	mov    %edi,%r9d
ffffffff80002ba5:	41 89 fa             	mov    %edi,%r10d
ffffffff80002ba8:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002bab:	89 d1                	mov    %edx,%ecx
ffffffff80002bad:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002bb0:	41 d3 e2             	shl    %cl,%r10d
        ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red
ffffffff80002bb3:	44 89 8b 4c 02 00 00 	mov    %r9d,0x24c(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bba:	44 89 c1             	mov    %r8d,%ecx
        ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green
ffffffff80002bbd:	44 89 93 50 02 00 00 	mov    %r10d,0x250(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bc4:	44 09 c9             	or     %r9d,%ecx
ffffffff80002bc7:	89 8b 54 02 00 00    	mov    %ecx,0x254(%rbx)
ffffffff80002bcd:	89 f1                	mov    %esi,%ecx
ffffffff80002bcf:	d3 e7                	shl    %cl,%edi
ffffffff80002bd1:	89 f9                	mov    %edi,%ecx
        ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue
ffffffff80002bd3:	89 bb 58 02 00 00    	mov    %edi,0x258(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bd9:	44 09 d7             	or     %r10d,%edi
ffffffff80002bdc:	44 09 c9             	or     %r9d,%ecx
        ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan
ffffffff80002bdf:	89 bb 60 02 00 00    	mov    %edi,0x260(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002be5:	44 09 cf             	or     %r9d,%edi
    if (ansi_bright_colours != NULL) {
ffffffff80002be8:	48 83 bc 24 c0 00 00 	cmpq   $0x0,0xc0(%rsp)
ffffffff80002bef:	00 00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bf1:	89 8b 5c 02 00 00    	mov    %ecx,0x25c(%rbx)
ffffffff80002bf7:	89 bb 64 02 00 00    	mov    %edi,0x264(%rbx)
    if (ansi_bright_colours != NULL) {
ffffffff80002bfd:	0f 85 12 f7 ff ff    	jne    ffffffff80002315 <flanterm_fb_init+0x1b5>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002c03:	bf 55 00 00 00       	mov    $0x55,%edi
ffffffff80002c08:	41 b8 ff 00 00 00    	mov    $0xff,%r8d
ffffffff80002c0e:	89 c1                	mov    %eax,%ecx
ffffffff80002c10:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002c13:	41 89 fb             	mov    %edi,%r11d
ffffffff80002c16:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002c19:	41 d3 e3             	shl    %cl,%r11d
ffffffff80002c1c:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c20:	4c 89 d9             	mov    %r11,%rcx
ffffffff80002c23:	41 89 fb             	mov    %edi,%r11d
ffffffff80002c26:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c29:	49 89 ca             	mov    %rcx,%r10
ffffffff80002c2c:	89 d1                	mov    %edx,%ecx
ffffffff80002c2e:	41 d3 e3             	shl    %cl,%r11d
ffffffff80002c31:	4d 89 d9             	mov    %r11,%r9
ffffffff80002c34:	4c 89 d9             	mov    %r11,%rcx
ffffffff80002c37:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c3b:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c3e:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002c41:	4c 09 d1             	or     %r10,%rcx
ffffffff80002c44:	49 89 cb             	mov    %rcx,%r11
ffffffff80002c47:	89 d1                	mov    %edx,%ecx
ffffffff80002c49:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002c4c:	4c 89 c9             	mov    %r9,%rcx
ffffffff80002c4f:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c53:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c56:	4c 09 d1             	or     %r10,%rcx
ffffffff80002c59:	49 89 c9             	mov    %rcx,%r9
ffffffff80002c5c:	89 f1                	mov    %esi,%ecx
ffffffff80002c5e:	d3 e7                	shl    %cl,%edi
ffffffff80002c60:	48 89 f9             	mov    %rdi,%rcx
ffffffff80002c63:	48 c1 e1 20          	shl    $0x20,%rcx
ffffffff80002c67:	48 09 cf             	or     %rcx,%rdi
ffffffff80002c6a:	89 f1                	mov    %esi,%ecx
ffffffff80002c6c:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002c6f:	4c 89 c1             	mov    %r8,%rcx
ffffffff80002c72:	48 c1 e1 20          	shl    $0x20,%rcx
ffffffff80002c76:	4c 09 c1             	or     %r8,%rcx
ffffffff80002c79:	4d 89 d8             	mov    %r11,%r8
ffffffff80002c7c:	49 09 f8             	or     %rdi,%r8
ffffffff80002c7f:	4c 09 cf             	or     %r9,%rdi
        ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black
ffffffff80002c82:	48 89 bb 70 02 00 00 	mov    %rdi,0x270(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002c89:	4c 89 df             	mov    %r11,%rdi
ffffffff80002c8c:	48 09 cf             	or     %rcx,%rdi
ffffffff80002c8f:	4c 09 c9             	or     %r9,%rcx
        ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black
ffffffff80002c92:	4c 89 83 68 02 00 00 	mov    %r8,0x268(%rbx)
ffffffff80002c99:	48 89 bb 78 02 00 00 	mov    %rdi,0x278(%rbx)
ffffffff80002ca0:	48 89 8b 80 02 00 00 	mov    %rcx,0x280(%rbx)
ffffffff80002ca7:	e9 b8 f6 ff ff       	jmp    ffffffff80002364 <flanterm_fb_init+0x204>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002cac:	bf ff 00 00 00       	mov    $0xff,%edi
ffffffff80002cb1:	89 d1                	mov    %edx,%ecx
ffffffff80002cb3:	41 89 f8             	mov    %edi,%r8d
ffffffff80002cb6:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cb9:	89 f1                	mov    %esi,%ecx
ffffffff80002cbb:	44 89 c2             	mov    %r8d,%edx
ffffffff80002cbe:	41 89 f8             	mov    %edi,%r8d
ffffffff80002cc1:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cc4:	89 c1                	mov    %eax,%ecx
ffffffff80002cc6:	44 09 c2             	or     %r8d,%edx
ffffffff80002cc9:	d3 e7                	shl    %cl,%edi
ffffffff80002ccb:	09 fa                	or     %edi,%edx
ffffffff80002ccd:	e9 ab f7 ff ff       	jmp    ffffffff8000247d <flanterm_fb_init+0x31d>
ffffffff80002cd2:	41 b8 55 00 00 00    	mov    $0x55,%r8d
ffffffff80002cd8:	89 d1                	mov    %edx,%ecx
ffffffff80002cda:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002cdd:	44 89 c7             	mov    %r8d,%edi
ffffffff80002ce0:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002ce3:	89 f1                	mov    %esi,%ecx
ffffffff80002ce5:	d3 e7                	shl    %cl,%edi
ffffffff80002ce7:	89 c1                	mov    %eax,%ecx
ffffffff80002ce9:	44 09 cf             	or     %r9d,%edi
ffffffff80002cec:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cef:	44 09 c7             	or     %r8d,%edi
ffffffff80002cf2:	e9 40 f7 ff ff       	jmp    ffffffff80002437 <flanterm_fb_init+0x2d7>
        ctx->font_width = font_width = 8;
ffffffff80002cf7:	48 c7 83 b8 01 00 00 	movq   $0x8,0x1b8(%rbx)
ffffffff80002cfe:	08 00 00 00 
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff80002d02:	bf 00 10 00 00       	mov    $0x1000,%edi
        ctx->font_height = font_height = 16;
ffffffff80002d07:	48 c7 83 c0 01 00 00 	movq   $0x10,0x1c0(%rbx)
ffffffff80002d0e:	10 00 00 00 
        ctx->font_bits_size = FONT_BYTES;
ffffffff80002d12:	48 c7 83 28 02 00 00 	movq   $0x1000,0x228(%rbx)
ffffffff80002d19:	00 10 00 00 
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff80002d1d:	41 ff d7             	call   *%r15
ffffffff80002d20:	48 89 83 30 02 00 00 	mov    %rax,0x230(%rbx)
ffffffff80002d27:	48 89 c7             	mov    %rax,%rdi
        if (ctx->font_bits == NULL) {
ffffffff80002d2a:	48 85 c0             	test   %rax,%rax
ffffffff80002d2d:	0f 84 e7 fc ff ff    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
ffffffff80002d33:	48 8b 93 28 02 00 00 	mov    0x228(%rbx),%rdx
ffffffff80002d3a:	48 c7 c6 00 80 00 80 	mov    $0xffffffff80008000,%rsi
        ctx->font_height = font_height = 16;
ffffffff80002d41:	bd 10 00 00 00       	mov    $0x10,%ebp
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
ffffffff80002d46:	e8 f5 39 00 00       	call   ffffffff80006740 <memcpy>
        font_spacing = 1;
ffffffff80002d4b:	48 c7 84 24 00 01 00 	movq   $0x1,0x100(%rsp)
ffffffff80002d52:	00 01 00 00 00 
ffffffff80002d57:	e9 c3 f7 ff ff       	jmp    ffffffff8000251f <flanterm_fb_init+0x3bf>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002d5c:	bf aa 00 00 00       	mov    $0xaa,%edi
ffffffff80002d61:	89 d1                	mov    %edx,%ecx
ffffffff80002d63:	41 89 f9             	mov    %edi,%r9d
ffffffff80002d66:	41 89 f8             	mov    %edi,%r8d
ffffffff80002d69:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002d6c:	89 f1                	mov    %esi,%ecx
ffffffff80002d6e:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002d71:	89 c1                	mov    %eax,%ecx
ffffffff80002d73:	45 09 c8             	or     %r9d,%r8d
ffffffff80002d76:	d3 e7                	shl    %cl,%edi
ffffffff80002d78:	41 09 f8             	or     %edi,%r8d
ffffffff80002d7b:	45 89 c2             	mov    %r8d,%r10d
ffffffff80002d7e:	e9 6a f6 ff ff       	jmp    ffffffff800023ed <flanterm_fb_init+0x28d>
    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002d83:	48 83 bc 24 10 01 00 	cmpq   $0x1,0x110(%rsp)
ffffffff80002d8a:	00 01 
ffffffff80002d8c:	75 16                	jne    ffffffff80002da4 <flanterm_fb_init+0xc44>
ffffffff80002d8e:	48 83 bc 24 08 01 00 	cmpq   $0x1,0x108(%rsp)
ffffffff80002d95:	00 01 
ffffffff80002d97:	48 c7 c0 c0 1e 00 80 	mov    $0xffffffff80001ec0,%rax
ffffffff80002d9e:	0f 84 c2 fa ff ff    	je     ffffffff80002866 <flanterm_fb_init+0x706>
ffffffff80002da4:	48 c7 c0 e0 1f 00 80 	mov    $0xffffffff80001fe0,%rax
ffffffff80002dab:	e9 b6 fa ff ff       	jmp    ffffffff80002866 <flanterm_fb_init+0x706>
        bump_allocated_instance = true;
ffffffff80002db0:	c6 05 4a 93 00 00 01 	movb   $0x1,0x934a(%rip)        # ffffffff8000c101 <bump_allocated_instance>
ffffffff80002db7:	e9 cb fb ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002dbc:	48 c7 c0 c0 1b 00 80 	mov    $0xffffffff80001bc0,%rax
ffffffff80002dc3:	e9 9e fa ff ff       	jmp    ffffffff80002866 <flanterm_fb_init+0x706>
        bump_alloc_ptr = 0;
ffffffff80002dc8:	48 c7 05 35 93 00 00 	movq   $0x0,0x9335(%rip)        # ffffffff8000c108 <bump_alloc_ptr>
ffffffff80002dcf:	00 00 00 00 
        return NULL;
ffffffff80002dd3:	31 db                	xor    %ebx,%ebx
ffffffff80002dd5:	e9 ad fb ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
ffffffff80002dda:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80002de0 <flanterm_context_reinit>:
};

#define CHARSET_DEFAULT 0
#define CHARSET_DEC_SPECIAL 1

void flanterm_context_reinit(struct flanterm_context *ctx) {
ffffffff80002de0:	f3 0f 1e fa          	endbr64
    ctx->rrr = false;
    ctx->discard_next = false;
    ctx->bold = false;
    ctx->bg_bold = false;
    ctx->reverse_video = false;
    ctx->dec_private = false;
ffffffff80002de4:	0f b7 05 b5 8b 00 00 	movzwl 0x8bb5(%rip),%eax        # ffffffff8000b9a0 <col256+0x3c0>
    ctx->tab_size = 8;
ffffffff80002deb:	48 c7 07 08 00 00 00 	movq   $0x8,(%rdi)
    ctx->autoflush = true;
ffffffff80002df2:	48 c7 47 08 01 01 01 	movq   $0x10101,0x8(%rdi)
ffffffff80002df9:	00 
    ctx->dec_private = false;
ffffffff80002dfa:	66 89 47 14          	mov    %ax,0x14(%rdi)
    ctx->insert_mode = false;
    ctx->unicode_remaining = 0;
    ctx->g_select = 0;
ffffffff80002dfe:	66 89 47 28          	mov    %ax,0x28(%rdi)
    ctx->saved_cursor_x = 0;
    ctx->saved_cursor_y = 0;
    ctx->current_primary = (size_t)-1;
    ctx->current_bg = (size_t)-1;
    ctx->scroll_top_margin = 0;
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80002e02:	48 8b 87 e0 00 00 00 	mov    0xe0(%rdi),%rax
    ctx->discard_next = false;
ffffffff80002e09:	c7 47 10 00 00 00 00 	movl   $0x0,0x10(%rdi)
    ctx->unicode_remaining = 0;
ffffffff80002e10:	48 c7 47 20 00 00 00 	movq   $0x0,0x20(%rdi)
ffffffff80002e17:	00 
    ctx->charsets[1] = CHARSET_DEC_SPECIAL;
ffffffff80002e18:	c6 47 2a 01          	movb   $0x1,0x2a(%rdi)
    ctx->current_charset = 0;
ffffffff80002e1c:	48 c7 47 30 00 00 00 	movq   $0x0,0x30(%rdi)
ffffffff80002e23:	00 
    ctx->escape_offset = 0;
ffffffff80002e24:	48 c7 47 38 00 00 00 	movq   $0x0,0x38(%rdi)
ffffffff80002e2b:	00 
    ctx->esc_values_i = 0;
ffffffff80002e2c:	48 c7 47 40 00 00 00 	movq   $0x0,0x40(%rdi)
ffffffff80002e33:	00 
    ctx->saved_cursor_x = 0;
ffffffff80002e34:	48 c7 47 48 00 00 00 	movq   $0x0,0x48(%rdi)
ffffffff80002e3b:	00 
    ctx->saved_cursor_y = 0;
ffffffff80002e3c:	48 c7 47 50 00 00 00 	movq   $0x0,0x50(%rdi)
ffffffff80002e43:	00 
    ctx->current_primary = (size_t)-1;
ffffffff80002e44:	48 c7 47 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rdi)
ffffffff80002e4b:	ff 
    ctx->current_bg = (size_t)-1;
ffffffff80002e4c:	48 c7 47 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rdi)
ffffffff80002e53:	ff 
    ctx->scroll_top_margin = 0;
ffffffff80002e54:	48 c7 47 68 00 00 00 	movq   $0x0,0x68(%rdi)
ffffffff80002e5b:	00 
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80002e5c:	48 89 47 70          	mov    %rax,0x70(%rdi)
    ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;
ffffffff80002e60:	48 c7 87 b8 00 00 00 	movq   $0x10,0xb8(%rdi)
ffffffff80002e67:	10 00 00 00 
}
ffffffff80002e6b:	c3                   	ret
ffffffff80002e6c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80002e70 <mk_wcwidth>:
  }

  return 0;
}

int mk_wcwidth(uint32_t ucs) {
ffffffff80002e70:	f3 0f 1e fa          	endbr64
ffffffff80002e74:	89 fa                	mov    %edi,%edx
    { 0xE0100, 0xE01EF }
  };

  /* test for 8-bit control characters */
  if (ucs == 0)
    return 0;
ffffffff80002e76:	31 c0                	xor    %eax,%eax
  if (ucs == 0)
ffffffff80002e78:	85 ff                	test   %edi,%edi
ffffffff80002e7a:	74 71                	je     ffffffff80002eed <mk_wcwidth+0x7d>
  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
ffffffff80002e7c:	8d 47 81             	lea    -0x7f(%rdi),%eax
ffffffff80002e7f:	83 f8 20             	cmp    $0x20,%eax
    return 1;
ffffffff80002e82:	b8 01 00 00 00       	mov    $0x1,%eax
  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
ffffffff80002e87:	76 67                	jbe    ffffffff80002ef0 <mk_wcwidth+0x80>
ffffffff80002e89:	83 ff 1f             	cmp    $0x1f,%edi
ffffffff80002e8c:	76 62                	jbe    ffffffff80002ef0 <mk_wcwidth+0x80>
  if (ucs < table[0].first || ucs > table[max].last)
ffffffff80002e8e:	81 ff ff 02 00 00    	cmp    $0x2ff,%edi
ffffffff80002e94:	76 57                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
ffffffff80002e96:	81 ff ef 01 0e 00    	cmp    $0xe01ef,%edi
ffffffff80002e9c:	0f 87 be 00 00 00    	ja     ffffffff80002f60 <mk_wcwidth+0xf0>
  int min = 0;
ffffffff80002ea2:	31 f6                	xor    %esi,%esi
ffffffff80002ea4:	bf 8d 00 00 00       	mov    $0x8d,%edi
ffffffff80002ea9:	eb 0c                	jmp    ffffffff80002eb7 <mk_wcwidth+0x47>
ffffffff80002eab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
      min = mid + 1;
ffffffff80002eb0:	8d 70 01             	lea    0x1(%rax),%esi
  while (max >= min) {
ffffffff80002eb3:	39 f7                	cmp    %esi,%edi
ffffffff80002eb5:	7c 41                	jl     ffffffff80002ef8 <mk_wcwidth+0x88>
    mid = (min + max) / 2;
ffffffff80002eb7:	8d 0c 37             	lea    (%rdi,%rsi,1),%ecx
ffffffff80002eba:	89 c8                	mov    %ecx,%eax
ffffffff80002ebc:	c1 e8 1f             	shr    $0x1f,%eax
ffffffff80002ebf:	01 c8                	add    %ecx,%eax
ffffffff80002ec1:	d1 f8                	sar    $1,%eax
    if (ucs > table[mid].last)
ffffffff80002ec3:	48 63 c8             	movslq %eax,%rcx
ffffffff80002ec6:	39 14 cd 64 b1 00 80 	cmp    %edx,-0x7fff4e9c(,%rcx,8)
ffffffff80002ecd:	72 e1                	jb     ffffffff80002eb0 <mk_wcwidth+0x40>
    else if (ucs < table[mid].first)
ffffffff80002ecf:	3b 14 cd 60 b1 00 80 	cmp    -0x7fff4ea0(,%rcx,8),%edx
ffffffff80002ed6:	0f 83 d4 00 00 00    	jae    ffffffff80002fb0 <mk_wcwidth+0x140>
      max = mid - 1;
ffffffff80002edc:	8d 78 ff             	lea    -0x1(%rax),%edi
ffffffff80002edf:	eb d2                	jmp    ffffffff80002eb3 <mk_wcwidth+0x43>
ffffffff80002ee1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80002ee8:	b8 01 00 00 00       	mov    $0x1,%eax
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
      (ucs >= 0x20000 && ucs <= 0x2fffd) ||
      (ucs >= 0x30000 && ucs <= 0x3fffd)));
}
ffffffff80002eed:	c3                   	ret
ffffffff80002eee:	66 90                	xchg   %ax,%ax
ffffffff80002ef0:	c3                   	ret
ffffffff80002ef1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    (ucs >= 0x1100 &&
ffffffff80002ef8:	81 fa ff 10 00 00    	cmp    $0x10ff,%edx
ffffffff80002efe:	76 e8                	jbe    ffffffff80002ee8 <mk_wcwidth+0x78>
      ucs == 0x2329 || ucs == 0x232a ||
ffffffff80002f00:	8d 82 d7 dc ff ff    	lea    -0x2329(%rdx),%eax
ffffffff80002f06:	83 f8 01             	cmp    $0x1,%eax
ffffffff80002f09:	76 08                	jbe    ffffffff80002f13 <mk_wcwidth+0xa3>
ffffffff80002f0b:	81 fa 5f 11 00 00    	cmp    $0x115f,%edx
ffffffff80002f11:	77 06                	ja     ffffffff80002f19 <mk_wcwidth+0xa9>
ffffffff80002f13:	b8 02 00 00 00       	mov    $0x2,%eax
ffffffff80002f18:	c3                   	ret
      (ucs >= 0x2e80 && ucs <= 0xa4cf &&
ffffffff80002f19:	8d 82 80 d1 ff ff    	lea    -0x2e80(%rdx),%eax
      ucs == 0x2329 || ucs == 0x232a ||
ffffffff80002f1f:	3d 4f 76 00 00       	cmp    $0x764f,%eax
ffffffff80002f24:	77 08                	ja     ffffffff80002f2e <mk_wcwidth+0xbe>
ffffffff80002f26:	81 fa 3f 30 00 00    	cmp    $0x303f,%edx
ffffffff80002f2c:	75 e5                	jne    ffffffff80002f13 <mk_wcwidth+0xa3>
      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
ffffffff80002f2e:	8d 8a 00 54 ff ff    	lea    -0xac00(%rdx),%ecx
ffffffff80002f34:	b8 02 00 00 00       	mov    $0x2,%eax
       ucs != 0x303f) ||                  /* CJK ... Yi */
ffffffff80002f39:	81 f9 a3 2b 00 00    	cmp    $0x2ba3,%ecx
ffffffff80002f3f:	76 ac                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
ffffffff80002f41:	8d 8a 00 07 ff ff    	lea    -0xf900(%rdx),%ecx
      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
ffffffff80002f47:	81 f9 ff 01 00 00    	cmp    $0x1ff,%ecx
ffffffff80002f4d:	76 9e                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
ffffffff80002f4f:	8d 8a f0 01 ff ff    	lea    -0xfe10(%rdx),%ecx
      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
ffffffff80002f55:	83 f9 09             	cmp    $0x9,%ecx
ffffffff80002f58:	76 93                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
ffffffff80002f5a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
ffffffff80002f60:	8d 8a d0 01 ff ff    	lea    -0xfe30(%rdx),%ecx
ffffffff80002f66:	b8 02 00 00 00       	mov    $0x2,%eax
      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
ffffffff80002f6b:	83 f9 3f             	cmp    $0x3f,%ecx
ffffffff80002f6e:	0f 86 79 ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
ffffffff80002f74:	8d 8a 00 01 ff ff    	lea    -0xff00(%rdx),%ecx
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
ffffffff80002f7a:	83 f9 60             	cmp    $0x60,%ecx
ffffffff80002f7d:	0f 86 6a ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
ffffffff80002f83:	8d 8a 20 00 ff ff    	lea    -0xffe0(%rdx),%ecx
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
ffffffff80002f89:	83 f9 06             	cmp    $0x6,%ecx
ffffffff80002f8c:	0f 86 5b ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
ffffffff80002f92:	89 d0                	mov    %edx,%eax
ffffffff80002f94:	25 ff ff fe ff       	and    $0xfffeffff,%eax
ffffffff80002f99:	2d 00 00 02 00       	sub    $0x20000,%eax
ffffffff80002f9e:	3d fd ff 00 00       	cmp    $0xfffd,%eax
ffffffff80002fa3:	0f 96 c0             	setbe  %al
ffffffff80002fa6:	0f b6 c0             	movzbl %al,%eax
  return 1 +
ffffffff80002fa9:	83 c0 01             	add    $0x1,%eax
ffffffff80002fac:	c3                   	ret
ffffffff80002fad:	0f 1f 00             	nopl   (%rax)
    return 0;
ffffffff80002fb0:	31 c0                	xor    %eax,%eax
ffffffff80002fb2:	c3                   	ret
ffffffff80002fb3:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80002fba:	00 00 00 
ffffffff80002fbd:	0f 1f 00             	nopl   (%rax)

ffffffff80002fc0 <flanterm_write>:
void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) {
ffffffff80002fc0:	f3 0f 1e fa          	endbr64
ffffffff80002fc4:	41 57                	push   %r15
ffffffff80002fc6:	41 56                	push   %r14
ffffffff80002fc8:	41 55                	push   %r13
ffffffff80002fca:	4c 8d 2c 16          	lea    (%rsi,%rdx,1),%r13
ffffffff80002fce:	41 54                	push   %r12
ffffffff80002fd0:	55                   	push   %rbp
ffffffff80002fd1:	48 89 f5             	mov    %rsi,%rbp
ffffffff80002fd4:	53                   	push   %rbx
ffffffff80002fd5:	48 89 fb             	mov    %rdi,%rbx
ffffffff80002fd8:	48 83 ec 28          	sub    $0x28,%rsp
    for (size_t i = 0; i < count; i++) {
ffffffff80002fdc:	48 85 d2             	test   %rdx,%rdx
ffffffff80002fdf:	0f 84 bf 00 00 00    	je     ffffffff800030a4 <flanterm_write+0xe4>
ffffffff80002fe5:	0f 1f 00             	nopl   (%rax)

    return -1;
}

static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) {
    if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {
ffffffff80002fe8:	80 7b 10 00          	cmpb   $0x0,0x10(%rbx)
        flanterm_putchar(ctx, buf[i]);
ffffffff80002fec:	44 0f b6 65 00       	movzbl 0x0(%rbp),%r12d
    if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {
ffffffff80002ff1:	0f 85 89 00 00 00    	jne    ffffffff80003080 <flanterm_write+0xc0>
ffffffff80002ff7:	44 89 e0             	mov    %r12d,%eax
ffffffff80002ffa:	83 e0 fd             	and    $0xfffffffd,%eax
ffffffff80002ffd:	3c 18                	cmp    $0x18,%al
ffffffff80002fff:	74 7f                	je     ffffffff80003080 <flanterm_write+0xc0>
        ctx->osc_escape = false;
        ctx->g_select = 0;
        return;
    }

    if (ctx->unicode_remaining != 0) {
ffffffff80003001:	48 8b 43 20          	mov    0x20(%rbx),%rax
ffffffff80003005:	48 85 c0             	test   %rax,%rax
ffffffff80003008:	74 17                	je     ffffffff80003021 <flanterm_write+0x61>
        if ((c & 0xc0) != 0x80) {
ffffffff8000300a:	44 89 e2             	mov    %r12d,%edx
ffffffff8000300d:	83 e2 c0             	and    $0xffffffc0,%edx
ffffffff80003010:	80 fa 80             	cmp    $0x80,%dl
ffffffff80003013:	0f 84 f7 00 00 00    	je     ffffffff80003110 <flanterm_write+0x150>
            ctx->unicode_remaining = 0;
ffffffff80003019:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff80003020:	00 
        }
        return;
    }

unicode_error:
    if (c >= 0xc0 && c <= 0xf7) {
ffffffff80003021:	41 8d 44 24 40       	lea    0x40(%r12),%eax
ffffffff80003026:	3c 37                	cmp    $0x37,%al
ffffffff80003028:	0f 86 a2 00 00 00    	jbe    ffffffff800030d0 <flanterm_write+0x110>
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
        }
        return;
    }

    if (ctx->escape == true) {
ffffffff8000302e:	80 7b 0c 00          	cmpb   $0x0,0xc(%rbx)
ffffffff80003032:	0f 85 c8 01 00 00    	jne    ffffffff80003200 <flanterm_write+0x240>
        escape_parse(ctx, c);
        return;
    }

    if (ctx->g_select) {
ffffffff80003038:	0f b6 43 28          	movzbl 0x28(%rbx),%eax
ffffffff8000303c:	84 c0                	test   %al,%al
ffffffff8000303e:	0f 85 8c 01 00 00    	jne    ffffffff800031d0 <flanterm_write+0x210>
        ctx->g_select = 0;
        return;
    }

    size_t x, y;
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003044:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
ffffffff80003049:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000304e:	48 89 df             	mov    %rbx,%rdi
ffffffff80003051:	ff 93 08 01 00 00    	call   *0x108(%rbx)

    switch (c) {
ffffffff80003057:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff8000305b:	0f 8f 5f 02 00 00    	jg     ffffffff800032c0 <flanterm_write+0x300>
ffffffff80003061:	45 84 e4             	test   %r12b,%r12b
ffffffff80003064:	0f 88 66 02 00 00    	js     ffffffff800032d0 <flanterm_write+0x310>
ffffffff8000306a:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff8000306e:	0f 87 5c 02 00 00    	ja     ffffffff800032d0 <flanterm_write+0x310>
ffffffff80003074:	41 0f b6 c4          	movzbl %r12b,%eax
ffffffff80003078:	3e ff 24 c5 00 90 00 	notrack jmp *-0x7fff7000(,%rax,8)
ffffffff8000307f:	80 
        ctx->discard_next = false;
ffffffff80003080:	c6 43 10 00          	movb   $0x0,0x10(%rbx)
        ctx->unicode_remaining = 0;
ffffffff80003084:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff8000308b:	00 
        ctx->control_sequence = false;
ffffffff8000308c:	c7 43 0b 00 00 00 00 	movl   $0x0,0xb(%rbx)
        ctx->g_select = 0;
ffffffff80003093:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003097:	48 83 c5 01          	add    $0x1,%rbp
ffffffff8000309b:	49 39 ed             	cmp    %rbp,%r13
ffffffff8000309e:	0f 85 44 ff ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
    if (ctx->autoflush) {
ffffffff800030a4:	80 7b 08 00          	cmpb   $0x0,0x8(%rbx)
ffffffff800030a8:	0f 84 da 00 00 00    	je     ffffffff80003188 <flanterm_write+0x1c8>
        ctx->double_buffer_flush(ctx);
ffffffff800030ae:	48 8b 83 90 01 00 00 	mov    0x190(%rbx),%rax
}
ffffffff800030b5:	48 83 c4 28          	add    $0x28,%rsp
        ctx->double_buffer_flush(ctx);
ffffffff800030b9:	48 89 df             	mov    %rbx,%rdi
}
ffffffff800030bc:	5b                   	pop    %rbx
ffffffff800030bd:	5d                   	pop    %rbp
ffffffff800030be:	41 5c                	pop    %r12
ffffffff800030c0:	41 5d                	pop    %r13
ffffffff800030c2:	41 5e                	pop    %r14
ffffffff800030c4:	41 5f                	pop    %r15
        ctx->double_buffer_flush(ctx);
ffffffff800030c6:	ff e0                	jmp    *%rax
ffffffff800030c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800030cf:	00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800030d0:	41 0f b6 d4          	movzbl %r12b,%edx
        if (c >= 0xc0 && c <= 0xdf) {
ffffffff800030d4:	3c 1f                	cmp    $0x1f,%al
ffffffff800030d6:	0f 86 c4 00 00 00    	jbe    ffffffff800031a0 <flanterm_write+0x1e0>
        } else if (c >= 0xe0 && c <= 0xef) {
ffffffff800030dc:	41 83 c4 20          	add    $0x20,%r12d
ffffffff800030e0:	41 80 fc 0f          	cmp    $0xf,%r12b
ffffffff800030e4:	0f 87 66 01 00 00    	ja     ffffffff80003250 <flanterm_write+0x290>
            ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);
ffffffff800030ea:	48 c1 e2 0c          	shl    $0xc,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff800030ee:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 2;
ffffffff800030f2:	48 c7 43 20 02 00 00 	movq   $0x2,0x20(%rbx)
ffffffff800030f9:	00 
            ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);
ffffffff800030fa:	81 e2 ff ff 00 00    	and    $0xffff,%edx
ffffffff80003100:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003104:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003107:	0f 85 db fe ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff8000310d:	eb 95                	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff8000310f:	90                   	nop
        ctx->unicode_remaining--;
ffffffff80003110:	48 83 e8 01          	sub    $0x1,%rax
        ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);
ffffffff80003114:	41 83 e4 3f          	and    $0x3f,%r12d
ffffffff80003118:	8d 0c 40             	lea    (%rax,%rax,2),%ecx
        ctx->unicode_remaining--;
ffffffff8000311b:	48 89 43 20          	mov    %rax,0x20(%rbx)
        ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);
ffffffff8000311f:	01 c9                	add    %ecx,%ecx
ffffffff80003121:	49 d3 e4             	shl    %cl,%r12
ffffffff80003124:	4c 0b 63 18          	or     0x18(%rbx),%r12
ffffffff80003128:	4c 89 63 18          	mov    %r12,0x18(%rbx)
        if (ctx->unicode_remaining != 0) {
ffffffff8000312c:	48 85 c0             	test   %rax,%rax
ffffffff8000312f:	0f 85 62 ff ff ff    	jne    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff80003135:	49 81 fc 48 22 00 00 	cmp    $0x2248,%r12
ffffffff8000313c:	0f 87 3e 01 00 00    	ja     ffffffff80003280 <flanterm_write+0x2c0>
ffffffff80003142:	49 81 fc 18 22 00 00 	cmp    $0x2218,%r12
ffffffff80003149:	0f 87 38 0e 00 00    	ja     ffffffff80003f87 <flanterm_write+0xfc7>
ffffffff8000314f:	49 81 fc 92 01 00 00 	cmp    $0x192,%r12
ffffffff80003156:	0f 87 12 03 00 00    	ja     ffffffff8000346e <flanterm_write+0x4ae>
ffffffff8000315c:	49 81 fc a0 00 00 00 	cmp    $0xa0,%r12
ffffffff80003163:	0f 86 57 02 00 00    	jbe    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003169:	49 8d 84 24 5f ff ff 	lea    -0xa1(%r12),%rax
ffffffff80003170:	ff 
ffffffff80003171:	48 3d f1 00 00 00    	cmp    $0xf1,%rax
ffffffff80003177:	0f 87 43 02 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000317d:	3e ff 24 c5 e0 90 00 	notrack jmp *-0x7fff6f20(,%rax,8)
ffffffff80003184:	80 
ffffffff80003185:	0f 1f 00             	nopl   (%rax)
}
ffffffff80003188:	48 83 c4 28          	add    $0x28,%rsp
ffffffff8000318c:	5b                   	pop    %rbx
ffffffff8000318d:	5d                   	pop    %rbp
ffffffff8000318e:	41 5c                	pop    %r12
ffffffff80003190:	41 5d                	pop    %r13
ffffffff80003192:	41 5e                	pop    %r14
ffffffff80003194:	41 5f                	pop    %r15
ffffffff80003196:	c3                   	ret
ffffffff80003197:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000319e:	00 00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800031a0:	48 c1 e2 06          	shl    $0x6,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff800031a4:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 1;
ffffffff800031a8:	48 c7 43 20 01 00 00 	movq   $0x1,0x20(%rbx)
ffffffff800031af:	00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800031b0:	81 e2 c0 07 00 00    	and    $0x7c0,%edx
ffffffff800031b6:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff800031ba:	49 39 ed             	cmp    %rbp,%r13
ffffffff800031bd:	0f 85 25 fe ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff800031c3:	e9 dc fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff800031c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800031cf:	00 
        ctx->g_select--;
ffffffff800031d0:	83 e8 01             	sub    $0x1,%eax
        switch (c) {
ffffffff800031d3:	41 80 fc 30          	cmp    $0x30,%r12b
ffffffff800031d7:	0f 84 8b 03 00 00    	je     ffffffff80003568 <flanterm_write+0x5a8>
ffffffff800031dd:	41 80 fc 42          	cmp    $0x42,%r12b
ffffffff800031e1:	0f 84 59 01 00 00    	je     ffffffff80003340 <flanterm_write+0x380>
        ctx->g_select = 0;
ffffffff800031e7:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff800031eb:	48 83 c5 01          	add    $0x1,%rbp
ffffffff800031ef:	49 39 ed             	cmp    %rbp,%r13
ffffffff800031f2:	0f 85 f0 fd ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff800031f8:	e9 a7 fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff800031fd:	0f 1f 00             	nopl   (%rax)
    ctx->escape_offset++;
ffffffff80003200:	48 8b 43 38          	mov    0x38(%rbx),%rax
ffffffff80003204:	48 83 c0 01          	add    $0x1,%rax
    if (ctx->osc == true) {
ffffffff80003208:	80 7b 0d 00          	cmpb   $0x0,0xd(%rbx)
    ctx->escape_offset++;
ffffffff8000320c:	48 89 43 38          	mov    %rax,0x38(%rbx)
    if (ctx->osc == true) {
ffffffff80003210:	0f 85 6a 03 00 00    	jne    ffffffff80003580 <flanterm_write+0x5c0>
    if (ctx->control_sequence == true) {
ffffffff80003216:	80 7b 0b 00          	cmpb   $0x0,0xb(%rbx)
ffffffff8000321a:	0f 85 87 03 00 00    	jne    ffffffff800035a7 <flanterm_write+0x5e7>
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003220:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
ffffffff80003225:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000322a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000322d:	ff 93 08 01 00 00    	call   *0x108(%rbx)
    switch (c) {
ffffffff80003233:	41 8d 44 24 d8       	lea    -0x28(%r12),%eax
ffffffff80003238:	3c 3b                	cmp    $0x3b,%al
ffffffff8000323a:	0f 87 18 02 00 00    	ja     ffffffff80003458 <flanterm_write+0x498>
ffffffff80003240:	0f b6 c0             	movzbl %al,%eax
ffffffff80003243:	3e ff 24 c5 70 98 00 	notrack jmp *-0x7fff6790(,%rax,8)
ffffffff8000324a:	80 
ffffffff8000324b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
ffffffff80003250:	48 c1 e2 12          	shl    $0x12,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff80003254:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 3;
ffffffff80003258:	48 c7 43 20 03 00 00 	movq   $0x3,0x20(%rbx)
ffffffff8000325f:	00 
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
ffffffff80003260:	81 e2 00 00 1c 00    	and    $0x1c0000,%edx
ffffffff80003266:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff8000326a:	49 39 ed             	cmp    %rbp,%r13
ffffffff8000326d:	0f 85 75 fd ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003273:	e9 2c fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff80003278:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff8000327f:	00 
    switch (code_point) {
ffffffff80003280:	49 81 fc 6b 26 00 00 	cmp    $0x266b,%r12
ffffffff80003287:	0f 87 33 01 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000328d:	49 81 fc ff 24 00 00 	cmp    $0x24ff,%r12
ffffffff80003294:	0f 86 95 03 00 00    	jbe    ffffffff8000362f <flanterm_write+0x66f>
ffffffff8000329a:	49 8d 84 24 00 db ff 	lea    -0x2500(%r12),%rax
ffffffff800032a1:	ff 
ffffffff800032a2:	48 3d 6b 01 00 00    	cmp    $0x16b,%rax
ffffffff800032a8:	0f 87 12 01 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff800032ae:	3e ff 24 c5 50 9a 00 	notrack jmp *-0x7fff65b0(,%rax,8)
ffffffff800032b5:	80 
ffffffff800032b6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800032bd:	00 00 00 
    switch (c) {
ffffffff800032c0:	41 80 fc 7f          	cmp    $0x7f,%r12b
ffffffff800032c4:	0f 84 cd fd ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
ffffffff800032ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            // Move to G0 set
            ctx->current_charset = 0;
            return;
    }

    if (ctx->insert_mode == true) {
ffffffff800032d0:	80 7b 15 00          	cmpb   $0x0,0x15(%rbx)
ffffffff800032d4:	74 35                	je     ffffffff8000330b <flanterm_write+0x34b>
        for (size_t i = ctx->cols - 1; ; i--) {
ffffffff800032d6:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff800032dd:	4c 8d 70 ff          	lea    -0x1(%rax),%r14
ffffffff800032e1:	eb 09                	jmp    ffffffff800032ec <flanterm_write+0x32c>
ffffffff800032e3:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff800032e8:	49 83 ee 01          	sub    $0x1,%r14
            ctx->move_character(ctx, i + 1, y, i, y);
ffffffff800032ec:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800032f1:	49 8d 76 01          	lea    0x1(%r14),%rsi
ffffffff800032f5:	4c 89 f1             	mov    %r14,%rcx
ffffffff800032f8:	48 89 df             	mov    %rbx,%rdi
ffffffff800032fb:	49 89 d0             	mov    %rdx,%r8
ffffffff800032fe:	ff 93 60 01 00 00    	call   *0x160(%rbx)
            if (i == x) {
ffffffff80003304:	4c 3b 74 24 10       	cmp    0x10(%rsp),%r14
ffffffff80003309:	75 dd                	jne    ffffffff800032e8 <flanterm_write+0x328>
            }
        }
    }

    // Translate character set
    switch (ctx->charsets[ctx->current_charset]) {
ffffffff8000330b:	48 8b 53 30          	mov    0x30(%rbx),%rdx
        case '`': FLANTERM_DEC_SPCL_PRN(0x04)
ffffffff8000330f:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
    switch (ctx->charsets[ctx->current_charset]) {
ffffffff80003316:	80 7c 13 29 01       	cmpb   $0x1,0x29(%rbx,%rdx,1)
ffffffff8000331b:	0f 84 12 0b 00 00    	je     ffffffff80003e33 <flanterm_write+0xe73>
                return;
            }
            break;
    }

    if (c >= 0x20 && c <= 0x7e) {
ffffffff80003321:	41 8d 54 24 e0       	lea    -0x20(%r12),%edx
ffffffff80003326:	80 fa 5e             	cmp    $0x5e,%dl
ffffffff80003329:	0f 86 be 02 00 00    	jbe    ffffffff800035ed <flanterm_write+0x62d>
        ctx->raw_putchar(ctx, c);
    } else {
        ctx->raw_putchar(ctx, 0xfe);
ffffffff8000332f:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff80003334:	48 89 df             	mov    %rbx,%rdi
ffffffff80003337:	ff d0                	call   *%rax
ffffffff80003339:	e9 59 fd ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff8000333e:	66 90                	xchg   %ax,%ax
                ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break;
ffffffff80003340:	0f b6 c0             	movzbl %al,%eax
ffffffff80003343:	c6 44 03 29 00       	movb   $0x0,0x29(%rbx,%rax,1)
        ctx->g_select = 0;
ffffffff80003348:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
        return;
ffffffff8000334c:	e9 9a fe ff ff       	jmp    ffffffff800031eb <flanterm_write+0x22b>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003351:	48 8b 43 70          	mov    0x70(%rbx),%rax
ffffffff80003355:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000335a:	48 83 e8 01          	sub    $0x1,%rax
ffffffff8000335e:	48 39 d0             	cmp    %rdx,%rax
ffffffff80003361:	0f 84 92 0a 00 00    	je     ffffffff80003df9 <flanterm_write+0xe39>
                ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1);
ffffffff80003367:	48 8b 83 00 01 00 00 	mov    0x100(%rbx),%rax
ffffffff8000336e:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80003372:	31 f6                	xor    %esi,%esi
ffffffff80003374:	f6 83 b8 00 00 00 10 	testb  $0x10,0xb8(%rbx)
ffffffff8000337b:	75 05                	jne    ffffffff80003382 <flanterm_write+0x3c2>
ffffffff8000337d:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff80003382:	48 89 df             	mov    %rbx,%rdi
ffffffff80003385:	ff d0                	call   *%rax
ffffffff80003387:	e9 0b fd ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff8000338c:	49 81 fc 20 23 00 00 	cmp    $0x2320,%r12
ffffffff80003393:	0f 84 59 0e 00 00    	je     ffffffff800041f2 <flanterm_write+0x1232>
ffffffff80003399:	49 81 fc 21 23 00 00 	cmp    $0x2321,%r12
ffffffff800033a0:	0f 84 42 0e 00 00    	je     ffffffff800041e8 <flanterm_write+0x1228>
        case 0x2310: return 169;
ffffffff800033a6:	be a9 00 00 00       	mov    $0xa9,%esi
    switch (code_point) {
ffffffff800033ab:	49 81 fc 10 23 00 00 	cmp    $0x2310,%r12
ffffffff800033b2:	0f 84 b8 02 00 00    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff800033b8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800033bf:	00 
            size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point);
ffffffff800033c0:	44 89 e7             	mov    %r12d,%edi
ffffffff800033c3:	e8 a8 fa ff ff       	call   ffffffff80002e70 <mk_wcwidth>
ffffffff800033c8:	4c 63 f0             	movslq %eax,%r14
            if (replacement_width > 0) {
ffffffff800033cb:	4d 85 f6             	test   %r14,%r14
ffffffff800033ce:	0f 84 c3 fc ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
                ctx->raw_putchar(ctx, 0xfe);
ffffffff800033d4:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff800033d9:	48 89 df             	mov    %rbx,%rdi
ffffffff800033dc:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 1; i < replacement_width; i++) {
ffffffff800033e2:	49 83 fe 01          	cmp    $0x1,%r14
ffffffff800033e6:	0f 84 ab fc ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
ffffffff800033ec:	41 bc 01 00 00 00    	mov    $0x1,%r12d
ffffffff800033f2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff800033f8:	49 83 c4 01          	add    $0x1,%r12
                ctx->raw_putchar(ctx, ' ');
ffffffff800033fc:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80003401:	48 89 df             	mov    %rbx,%rdi
ffffffff80003404:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 1; i < replacement_width; i++) {
ffffffff8000340a:	4d 39 e6             	cmp    %r12,%r14
ffffffff8000340d:	75 e9                	jne    ffffffff800033f8 <flanterm_write+0x438>
ffffffff8000340f:	e9 83 fc ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    ctx->save_state(ctx);
ffffffff80003414:	48 89 df             	mov    %rbx,%rdi
ffffffff80003417:	ff 93 80 01 00 00    	call   *0x180(%rbx)
    ctx->saved_state_bold = ctx->bold;
ffffffff8000341d:	0f b7 43 11          	movzwl 0x11(%rbx),%eax
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003421:	48 8b 53 58          	mov    0x58(%rbx),%rdx
ffffffff80003425:	48 8b 4b 30          	mov    0x30(%rbx),%rcx
    ctx->saved_state_bold = ctx->bold;
ffffffff80003429:	66 89 83 c0 00 00 00 	mov    %ax,0xc0(%rbx)
    ctx->saved_state_reverse_video = ctx->reverse_video;
ffffffff80003430:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003434:	48 89 8b c8 00 00 00 	mov    %rcx,0xc8(%rbx)
    ctx->saved_state_reverse_video = ctx->reverse_video;
ffffffff8000343b:	88 83 c2 00 00 00    	mov    %al,0xc2(%rbx)
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003441:	48 8b 43 60          	mov    0x60(%rbx),%rax
ffffffff80003445:	48 89 93 d0 00 00 00 	mov    %rdx,0xd0(%rbx)
ffffffff8000344c:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
            break;
ffffffff80003453:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    for (size_t i = 0; i < count; i++) {
ffffffff80003458:	48 83 c5 01          	add    $0x1,%rbp
    ctx->escape = false;
ffffffff8000345c:	c6 43 0c 00          	movb   $0x0,0xc(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003460:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003463:	0f 85 7f fb ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003469:	e9 36 fc ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
    switch (code_point) {
ffffffff8000346e:	49 81 fc c6 03 00 00 	cmp    $0x3c6,%r12
ffffffff80003475:	0f 87 80 01 00 00    	ja     ffffffff800035fb <flanterm_write+0x63b>
ffffffff8000347b:	49 81 fc 92 03 00 00 	cmp    $0x392,%r12
ffffffff80003482:	0f 86 38 ff ff ff    	jbe    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003488:	49 8d 84 24 6d fc ff 	lea    -0x393(%r12),%rax
ffffffff8000348f:	ff 
ffffffff80003490:	48 83 f8 33          	cmp    $0x33,%rax
ffffffff80003494:	0f 87 26 ff ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000349a:	3e ff 24 c5 b0 a5 00 	notrack jmp *-0x7fff5a50(,%rax,8)
ffffffff800034a1:	80 
            ctx->set_cursor_pos(ctx, 0, y);
ffffffff800034a2:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800034a7:	31 f6                	xor    %esi,%esi
ffffffff800034a9:	48 89 df             	mov    %rbx,%rdi
ffffffff800034ac:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            return;
ffffffff800034b2:	e9 e0 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->set_cursor_pos(ctx, x - 1, y);
ffffffff800034b7:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800034bc:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800034c1:	48 89 df             	mov    %rbx,%rdi
ffffffff800034c4:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
ffffffff800034c8:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            return;
ffffffff800034ce:	e9 c4 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if ((x / ctx->tab_size + 1) >= ctx->cols) {
ffffffff800034d3:	48 8b 33             	mov    (%rbx),%rsi
ffffffff800034d6:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800034db:	31 d2                	xor    %edx,%edx
                ctx->set_cursor_pos(ctx, ctx->cols - 1, y);
ffffffff800034dd:	48 8b 8b 00 01 00 00 	mov    0x100(%rbx),%rcx
ffffffff800034e4:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
            if ((x / ctx->tab_size + 1) >= ctx->cols) {
ffffffff800034e9:	48 f7 f6             	div    %rsi
ffffffff800034ec:	48 8b 93 e8 00 00 00 	mov    0xe8(%rbx),%rdx
ffffffff800034f3:	48 83 c0 01          	add    $0x1,%rax
ffffffff800034f7:	48 39 d0             	cmp    %rdx,%rax
ffffffff800034fa:	0f 83 22 09 00 00    	jae    ffffffff80003e22 <flanterm_write+0xe62>
            ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y);
ffffffff80003500:	48 89 fa             	mov    %rdi,%rdx
ffffffff80003503:	48 0f af f0          	imul   %rax,%rsi
ffffffff80003507:	48 89 df             	mov    %rbx,%rdi
ffffffff8000350a:	ff d1                	call   *%rcx
            return;
ffffffff8000350c:	e9 86 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if (ctx->callback != NULL) {
ffffffff80003511:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80003518:	48 85 c0             	test   %rax,%rax
ffffffff8000351b:	0f 84 76 fb ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
                ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0);
ffffffff80003521:	45 31 c0             	xor    %r8d,%r8d
ffffffff80003524:	31 c9                	xor    %ecx,%ecx
ffffffff80003526:	31 d2                	xor    %edx,%edx
ffffffff80003528:	be 14 00 00 00       	mov    $0x14,%esi
ffffffff8000352d:	48 89 df             	mov    %rbx,%rdi
ffffffff80003530:	ff d0                	call   *%rax
ffffffff80003532:	e9 60 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->escape_offset = 0;
ffffffff80003537:	48 c7 43 38 00 00 00 	movq   $0x0,0x38(%rbx)
ffffffff8000353e:	00 
            ctx->escape = true;
ffffffff8000353f:	c6 43 0c 01          	movb   $0x1,0xc(%rbx)
            return;
ffffffff80003543:	e9 4f fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->current_charset = 1;
ffffffff80003548:	48 c7 43 30 01 00 00 	movq   $0x1,0x30(%rbx)
ffffffff8000354f:	00 
            return;
ffffffff80003550:	e9 42 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->current_charset = 0;
ffffffff80003555:	48 c7 43 30 00 00 00 	movq   $0x0,0x30(%rbx)
ffffffff8000355c:	00 
            return;
ffffffff8000355d:	e9 35 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff80003562:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break;
ffffffff80003568:	0f b6 c0             	movzbl %al,%eax
ffffffff8000356b:	c6 44 03 29 01       	movb   $0x1,0x29(%rbx,%rax,1)
        ctx->g_select = 0;
ffffffff80003570:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
        return;
ffffffff80003574:	e9 72 fc ff ff       	jmp    ffffffff800031eb <flanterm_write+0x22b>
ffffffff80003579:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    if (ctx->osc_escape && c == '\\') {
ffffffff80003580:	41 80 fc 5c          	cmp    $0x5c,%r12b
ffffffff80003584:	75 06                	jne    ffffffff8000358c <flanterm_write+0x5cc>
ffffffff80003586:	80 7b 0e 00          	cmpb   $0x0,0xe(%rbx)
ffffffff8000358a:	75 0a                	jne    ffffffff80003596 <flanterm_write+0x5d6>
    switch (c) {
ffffffff8000358c:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff80003590:	0f 84 5a 08 00 00    	je     ffffffff80003df0 <flanterm_write+0xe30>
    ctx->escape = false;
ffffffff80003596:	45 31 c9             	xor    %r9d,%r9d
    ctx->osc_escape = false;
ffffffff80003599:	c6 43 0e 00          	movb   $0x0,0xe(%rbx)
    ctx->escape = false;
ffffffff8000359d:	66 44 89 4b 0c       	mov    %r9w,0xc(%rbx)
ffffffff800035a2:	e9 f0 fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    if (ctx->escape_offset == 2) {
ffffffff800035a7:	48 83 f8 02          	cmp    $0x2,%rax
ffffffff800035ab:	0f 84 bc 09 00 00    	je     ffffffff80003f6d <flanterm_write+0xfad>
    if (c >= '0' && c <= '9') {
ffffffff800035b1:	41 8d 44 24 d0       	lea    -0x30(%r12),%eax
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff800035b6:	48 8b 53 40          	mov    0x40(%rbx),%rdx
    if (c >= '0' && c <= '9') {
ffffffff800035ba:	3c 09                	cmp    $0x9,%al
ffffffff800035bc:	0f 87 8a 08 00 00    	ja     ffffffff80003e4c <flanterm_write+0xe8c>
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff800035c2:	48 83 fa 10          	cmp    $0x10,%rdx
ffffffff800035c6:	0f 84 cb fa ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
        ctx->esc_values[ctx->esc_values_i] += c - '0';
ffffffff800035cc:	48 83 c2 1c          	add    $0x1c,%rdx
ffffffff800035d0:	45 0f be e4          	movsbl %r12b,%r12d
        ctx->rrr = true;
ffffffff800035d4:	c6 43 0f 01          	movb   $0x1,0xf(%rbx)
        ctx->esc_values[ctx->esc_values_i] *= 10;
ffffffff800035d8:	8b 44 93 08          	mov    0x8(%rbx,%rdx,4),%eax
ffffffff800035dc:	8d 04 80             	lea    (%rax,%rax,4),%eax
        ctx->esc_values[ctx->esc_values_i] += c - '0';
ffffffff800035df:	41 8d 44 44 d0       	lea    -0x30(%r12,%rax,2),%eax
ffffffff800035e4:	89 44 93 08          	mov    %eax,0x8(%rbx,%rdx,4)
        return;
ffffffff800035e8:	e9 aa fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        ctx->raw_putchar(ctx, c);
ffffffff800035ed:	41 0f be f4          	movsbl %r12b,%esi
ffffffff800035f1:	48 89 df             	mov    %rbx,%rdi
ffffffff800035f4:	ff d0                	call   *%rax
ffffffff800035f6:	e9 9c fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff800035fb:	49 81 fc a8 21 00 00 	cmp    $0x21a8,%r12
ffffffff80003602:	0f 87 b8 fd ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003608:	49 81 fc 8f 21 00 00 	cmp    $0x218f,%r12
ffffffff8000360f:	0f 86 8c 09 00 00    	jbe    ffffffff80003fa1 <flanterm_write+0xfe1>
ffffffff80003615:	49 8d 84 24 70 de ff 	lea    -0x2190(%r12),%rax
ffffffff8000361c:	ff 
ffffffff8000361d:	48 83 f8 18          	cmp    $0x18,%rax
ffffffff80003621:	0f 87 99 fd ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003627:	3e ff 24 c5 50 a7 00 	notrack jmp *-0x7fff58b0(,%rax,8)
ffffffff8000362e:	80 
ffffffff8000362f:	49 81 fc 02 23 00 00 	cmp    $0x2302,%r12
ffffffff80003636:	0f 84 0e 0b 00 00    	je     ffffffff8000414a <flanterm_write+0x118a>
ffffffff8000363c:	0f 87 4a fd ff ff    	ja     ffffffff8000338c <flanterm_write+0x3cc>
ffffffff80003642:	49 81 fc 64 22 00 00 	cmp    $0x2264,%r12
ffffffff80003649:	0f 84 2d 0b 00 00    	je     ffffffff8000417c <flanterm_write+0x11bc>
ffffffff8000364f:	49 81 fc 65 22 00 00 	cmp    $0x2265,%r12
ffffffff80003656:	0f 84 16 0b 00 00    	je     ffffffff80004172 <flanterm_write+0x11b2>
        case 0x2261: return 240;
ffffffff8000365c:	be f0 00 00 00       	mov    $0xf0,%esi
    switch (code_point) {
ffffffff80003661:	49 81 fc 61 22 00 00 	cmp    $0x2261,%r12
ffffffff80003668:	0f 85 52 fd ff ff    	jne    ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000366e:	66 90                	xchg   %ax,%ax
    for (size_t i = 0; i < count; i++) {
ffffffff80003670:	48 83 c5 01          	add    $0x1,%rbp
            ctx->raw_putchar(ctx, cc);
ffffffff80003674:	48 89 df             	mov    %rbx,%rdi
ffffffff80003677:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff8000367d:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003680:	0f 85 62 f9 ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003686:	e9 19 fa ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
            ctx->g_select = c - '\'';
ffffffff8000368b:	41 83 ec 27          	sub    $0x27,%r12d
ffffffff8000368f:	44 88 63 28          	mov    %r12b,0x28(%rbx)
            break;
ffffffff80003693:	e9 c0 fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003698:	48 8b 4b 70          	mov    0x70(%rbx),%rcx
ffffffff8000369c:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff800036a1:	48 8d 51 ff          	lea    -0x1(%rcx),%rdx
ffffffff800036a5:	48 39 c2             	cmp    %rax,%rdx
ffffffff800036a8:	0f 84 e9 09 00 00    	je     ffffffff80004097 <flanterm_write+0x10d7>
                ctx->set_cursor_pos(ctx, x, y + 1);
ffffffff800036ae:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800036b3:	48 8d 50 01          	lea    0x1(%rax),%rdx
ffffffff800036b7:	48 89 df             	mov    %rbx,%rdi
ffffffff800036ba:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800036c0:	e9 93 fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    ctx->bold = ctx->saved_state_bold;
ffffffff800036c5:	0f b7 83 c0 00 00 00 	movzwl 0xc0(%rbx),%eax
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036cc:	48 8b 93 d0 00 00 00 	mov    0xd0(%rbx),%rdx
    ctx->restore_state(ctx);
ffffffff800036d3:	48 89 df             	mov    %rbx,%rdi
    ctx->bold = ctx->saved_state_bold;
ffffffff800036d6:	66 89 43 11          	mov    %ax,0x11(%rbx)
    ctx->reverse_video = ctx->saved_state_reverse_video;
ffffffff800036da:	0f b6 83 c2 00 00 00 	movzbl 0xc2(%rbx),%eax
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036e1:	48 89 53 58          	mov    %rdx,0x58(%rbx)
    ctx->reverse_video = ctx->saved_state_reverse_video;
ffffffff800036e5:	88 43 13             	mov    %al,0x13(%rbx)
    ctx->current_charset = ctx->saved_state_current_charset;
ffffffff800036e8:	48 8b 83 c8 00 00 00 	mov    0xc8(%rbx),%rax
ffffffff800036ef:	48 89 43 30          	mov    %rax,0x30(%rbx)
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036f3:	48 8b 83 d8 00 00 00 	mov    0xd8(%rbx),%rax
ffffffff800036fa:	48 89 43 60          	mov    %rax,0x60(%rbx)
    ctx->restore_state(ctx);
ffffffff800036fe:	ff 93 88 01 00 00    	call   *0x188(%rbx)
}
ffffffff80003704:	e9 4f fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    ctx->tab_size = 8;
ffffffff80003709:	48 c7 03 08 00 00 00 	movq   $0x8,(%rbx)
            ctx->clear(ctx, true);
ffffffff80003710:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80003715:	48 89 df             	mov    %rbx,%rdi
    ctx->dec_private = false;
ffffffff80003718:	0f b7 05 81 82 00 00 	movzwl 0x8281(%rip),%eax        # ffffffff8000b9a0 <col256+0x3c0>
    ctx->autoflush = true;
ffffffff8000371f:	48 c7 43 08 01 01 01 	movq   $0x10101,0x8(%rbx)
ffffffff80003726:	00 
    ctx->dec_private = false;
ffffffff80003727:	66 89 43 14          	mov    %ax,0x14(%rbx)
    ctx->g_select = 0;
ffffffff8000372b:	66 89 43 28          	mov    %ax,0x28(%rbx)
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff8000372f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
    ctx->discard_next = false;
ffffffff80003736:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%rbx)
    ctx->unicode_remaining = 0;
ffffffff8000373d:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff80003744:	00 
    ctx->charsets[1] = CHARSET_DEC_SPECIAL;
ffffffff80003745:	c6 43 2a 01          	movb   $0x1,0x2a(%rbx)
    ctx->current_charset = 0;
ffffffff80003749:	48 c7 43 30 00 00 00 	movq   $0x0,0x30(%rbx)
ffffffff80003750:	00 
    ctx->escape_offset = 0;
ffffffff80003751:	48 c7 43 38 00 00 00 	movq   $0x0,0x38(%rbx)
ffffffff80003758:	00 
    ctx->esc_values_i = 0;
ffffffff80003759:	48 c7 43 40 00 00 00 	movq   $0x0,0x40(%rbx)
ffffffff80003760:	00 
    ctx->saved_cursor_x = 0;
ffffffff80003761:	48 c7 43 48 00 00 00 	movq   $0x0,0x48(%rbx)
ffffffff80003768:	00 
    ctx->saved_cursor_y = 0;
ffffffff80003769:	48 c7 43 50 00 00 00 	movq   $0x0,0x50(%rbx)
ffffffff80003770:	00 
    ctx->current_primary = (size_t)-1;
ffffffff80003771:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80003778:	ff 
    ctx->current_bg = (size_t)-1;
ffffffff80003779:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80003780:	ff 
    ctx->scroll_top_margin = 0;
ffffffff80003781:	48 c7 43 68 00 00 00 	movq   $0x0,0x68(%rbx)
ffffffff80003788:	00 
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80003789:	48 89 43 70          	mov    %rax,0x70(%rbx)
    ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;
ffffffff8000378d:	48 c7 83 b8 00 00 00 	movq   $0x10,0xb8(%rbx)
ffffffff80003794:	10 00 00 00 
            ctx->clear(ctx, true);
ffffffff80003798:	ff 93 f8 00 00 00    	call   *0xf8(%rbx)
            break;
ffffffff8000379e:	e9 b5 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            ctx->osc = true;
ffffffff800037a3:	b8 01 00 00 00       	mov    $0x1,%eax
ffffffff800037a8:	66 89 43 0d          	mov    %ax,0xd(%rbx)
            return;
ffffffff800037ac:	e9 e6 f8 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff800037b1:	48 8d 43 78          	lea    0x78(%rbx),%rax
ffffffff800037b5:	48 8d 93 b8 00 00 00 	lea    0xb8(%rbx),%rdx
                ctx->esc_values[i] = 0;
ffffffff800037bc:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
ffffffff800037c3:	48 83 c0 10          	add    $0x10,%rax
ffffffff800037c7:	48 c7 40 f8 00 00 00 	movq   $0x0,-0x8(%rax)
ffffffff800037ce:	00 
            for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++)
ffffffff800037cf:	48 39 c2             	cmp    %rax,%rdx
ffffffff800037d2:	75 e8                	jne    ffffffff800037bc <flanterm_write+0x7fc>
            ctx->esc_values_i = 0;
ffffffff800037d4:	48 c7 43 40 00 00 00 	movq   $0x0,0x40(%rbx)
ffffffff800037db:	00 
            ctx->rrr = false;
ffffffff800037dc:	c6 43 0f 00          	movb   $0x0,0xf(%rbx)
            ctx->control_sequence = true;
ffffffff800037e0:	c6 43 0b 01          	movb   $0x1,0xb(%rbx)
            return;
ffffffff800037e4:	e9 ae f8 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if (ctx->callback != NULL) {
ffffffff800037e9:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800037f0:	48 85 c0             	test   %rax,%rax
ffffffff800037f3:	0f 84 5f fc ff ff    	je     ffffffff80003458 <flanterm_write+0x498>
                ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);
ffffffff800037f9:	45 31 c0             	xor    %r8d,%r8d
ffffffff800037fc:	31 c9                	xor    %ecx,%ecx
ffffffff800037fe:	31 d2                	xor    %edx,%edx
ffffffff80003800:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80003805:	48 89 df             	mov    %rbx,%rdi
ffffffff80003808:	ff d0                	call   *%rax
ffffffff8000380a:	e9 49 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_top_margin) {
ffffffff8000380f:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80003814:	48 39 43 68          	cmp    %rax,0x68(%rbx)
ffffffff80003818:	0f 84 9a 08 00 00    	je     ffffffff800040b8 <flanterm_write+0x10f8>
                ctx->set_cursor_pos(ctx, 0, y - 1);
ffffffff8000381e:	48 8d 50 ff          	lea    -0x1(%rax),%rdx
ffffffff80003822:	31 f6                	xor    %esi,%esi
ffffffff80003824:	48 89 df             	mov    %rbx,%rdi
ffffffff80003827:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff8000382d:	e9 26 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003832:	48 8b 4b 70          	mov    0x70(%rbx),%rcx
ffffffff80003836:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff8000383b:	48 8d 51 ff          	lea    -0x1(%rcx),%rdx
ffffffff8000383f:	48 39 c2             	cmp    %rax,%rdx
ffffffff80003842:	0f 84 28 08 00 00    	je     ffffffff80004070 <flanterm_write+0x10b0>
                ctx->set_cursor_pos(ctx, 0, y + 1);
ffffffff80003848:	48 8d 50 01          	lea    0x1(%rax),%rdx
ffffffff8000384c:	31 f6                	xor    %esi,%esi
ffffffff8000384e:	48 89 df             	mov    %rbx,%rdi
ffffffff80003851:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff80003857:	e9 fc fb ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
        case 0x00a2: return 155;
ffffffff8000385c:	be 9b 00 00 00       	mov    $0x9b,%esi
ffffffff80003861:	e9 0a fe ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a1: return 173;
ffffffff80003866:	be ad 00 00 00       	mov    $0xad,%esi
ffffffff8000386b:	e9 00 fe ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b1: return 241;
ffffffff80003870:	be f1 00 00 00       	mov    $0xf1,%esi
ffffffff80003875:	e9 f6 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b0: return 248;
ffffffff8000387a:	be f8 00 00 00       	mov    $0xf8,%esi
ffffffff8000387f:	e9 ec fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ac: return 170;
ffffffff80003884:	be aa 00 00 00       	mov    $0xaa,%esi
ffffffff80003889:	e9 e2 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ab: return 174;
ffffffff8000388e:	be ae 00 00 00       	mov    $0xae,%esi
ffffffff80003893:	e9 d8 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00aa: return 166;
ffffffff80003898:	be a6 00 00 00       	mov    $0xa6,%esi
ffffffff8000389d:	e9 ce fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a5: return 157;
ffffffff800038a2:	be 9d 00 00 00       	mov    $0x9d,%esi
ffffffff800038a7:	e9 c4 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a3: return 156;
ffffffff800038ac:	be 9c 00 00 00       	mov    $0x9c,%esi
ffffffff800038b1:	e9 ba fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2663: return 5;
ffffffff800038b6:	be 05 00 00 00       	mov    $0x5,%esi
ffffffff800038bb:	e9 b0 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2660: return 6;
ffffffff800038c0:	be 06 00 00 00       	mov    $0x6,%esi
ffffffff800038c5:	e9 a6 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2642: return 11;
ffffffff800038ca:	be 0b 00 00 00       	mov    $0xb,%esi
ffffffff800038cf:	e9 9c fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2640: return 12;
ffffffff800038d4:	be 0c 00 00 00       	mov    $0xc,%esi
ffffffff800038d9:	e9 92 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x263c: return 15;
ffffffff800038de:	be 0f 00 00 00       	mov    $0xf,%esi
ffffffff800038e3:	e9 88 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x263b: return 2;
ffffffff800038e8:	be 02 00 00 00       	mov    $0x2,%esi
ffffffff800038ed:	e9 7e fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25d9: return 10;
ffffffff800038f2:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff800038f7:	e9 74 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x266b: return 14;
ffffffff800038fc:	be 0e 00 00 00       	mov    $0xe,%esi
ffffffff80003901:	e9 6a fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x266a: return 13;
ffffffff80003906:	be 0d 00 00 00       	mov    $0xd,%esi
ffffffff8000390b:	e9 60 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2524: return 180;
ffffffff80003910:	be b4 00 00 00       	mov    $0xb4,%esi
ffffffff80003915:	e9 56 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x251c: return 195;
ffffffff8000391a:	be c3 00 00 00       	mov    $0xc3,%esi
ffffffff8000391f:	e9 4c fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2518: return 217;
ffffffff80003924:	be d9 00 00 00       	mov    $0xd9,%esi
ffffffff80003929:	e9 42 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2514: return 192;
ffffffff8000392e:	be c0 00 00 00       	mov    $0xc0,%esi
ffffffff80003933:	e9 38 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2510: return 191;
ffffffff80003938:	be bf 00 00 00       	mov    $0xbf,%esi
ffffffff8000393d:	e9 2e fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x250c: return 218;
ffffffff80003942:	be da 00 00 00       	mov    $0xda,%esi
ffffffff80003947:	e9 24 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2502: return 179;
ffffffff8000394c:	be b3 00 00 00       	mov    $0xb3,%esi
ffffffff80003951:	e9 1a fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2500: return 196;
ffffffff80003956:	be c4 00 00 00       	mov    $0xc4,%esi
ffffffff8000395b:	e9 10 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0192: return 159;
ffffffff80003960:	be 9f 00 00 00       	mov    $0x9f,%esi
ffffffff80003965:	e9 06 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ff: return 152;
ffffffff8000396a:	be 98 00 00 00       	mov    $0x98,%esi
ffffffff8000396f:	e9 fc fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fc: return 129;
ffffffff80003974:	be 81 00 00 00       	mov    $0x81,%esi
ffffffff80003979:	e9 f2 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fb: return 150;
ffffffff8000397e:	be 96 00 00 00       	mov    $0x96,%esi
ffffffff80003983:	e9 e8 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fa: return 163;
ffffffff80003988:	be a3 00 00 00       	mov    $0xa3,%esi
ffffffff8000398d:	e9 de fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f9: return 151;
ffffffff80003992:	be 97 00 00 00       	mov    $0x97,%esi
ffffffff80003997:	e9 d4 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f7: return 246;
ffffffff8000399c:	be f6 00 00 00       	mov    $0xf6,%esi
ffffffff800039a1:	e9 ca fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f6: return 148;
ffffffff800039a6:	be 94 00 00 00       	mov    $0x94,%esi
ffffffff800039ab:	e9 c0 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f4: return 147;
ffffffff800039b0:	be 93 00 00 00       	mov    $0x93,%esi
ffffffff800039b5:	e9 b6 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f3: return 162;
ffffffff800039ba:	be a2 00 00 00       	mov    $0xa2,%esi
ffffffff800039bf:	e9 ac fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f2: return 149;
ffffffff800039c4:	be 95 00 00 00       	mov    $0x95,%esi
ffffffff800039c9:	e9 a2 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f1: return 164;
ffffffff800039ce:	be a4 00 00 00       	mov    $0xa4,%esi
ffffffff800039d3:	e9 98 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ef: return 139;
ffffffff800039d8:	be 8b 00 00 00       	mov    $0x8b,%esi
ffffffff800039dd:	e9 8e fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2194: return 29;
ffffffff800039e2:	be 1d 00 00 00       	mov    $0x1d,%esi
ffffffff800039e7:	e9 84 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2193: return 25;
ffffffff800039ec:	be 19 00 00 00       	mov    $0x19,%esi
ffffffff800039f1:	e9 7a fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2192: return 26;
ffffffff800039f6:	be 1a 00 00 00       	mov    $0x1a,%esi
ffffffff800039fb:	e9 70 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2191: return 24;
ffffffff80003a00:	be 18 00 00 00       	mov    $0x18,%esi
ffffffff80003a05:	e9 66 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2190: return 27;
ffffffff80003a0a:	be 1b 00 00 00       	mov    $0x1b,%esi
ffffffff80003a0f:	e9 5c fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ee: return 140;
ffffffff80003a14:	be 8c 00 00 00       	mov    $0x8c,%esi
ffffffff80003a19:	e9 52 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ed: return 161;
ffffffff80003a1e:	be a1 00 00 00       	mov    $0xa1,%esi
ffffffff80003a23:	e9 48 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ec: return 141;
ffffffff80003a28:	be 8d 00 00 00       	mov    $0x8d,%esi
ffffffff80003a2d:	e9 3e fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00eb: return 137;
ffffffff80003a32:	be 89 00 00 00       	mov    $0x89,%esi
ffffffff80003a37:	e9 34 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ea: return 136;
ffffffff80003a3c:	be 88 00 00 00       	mov    $0x88,%esi
ffffffff80003a41:	e9 2a fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e9: return 130;
ffffffff80003a46:	be 82 00 00 00       	mov    $0x82,%esi
ffffffff80003a4b:	e9 20 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e8: return 138;
ffffffff80003a50:	be 8a 00 00 00       	mov    $0x8a,%esi
ffffffff80003a55:	e9 16 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e7: return 135;
ffffffff80003a5a:	be 87 00 00 00       	mov    $0x87,%esi
ffffffff80003a5f:	e9 0c fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e6: return 145;
ffffffff80003a64:	be 91 00 00 00       	mov    $0x91,%esi
ffffffff80003a69:	e9 02 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e5: return 134;
ffffffff80003a6e:	be 86 00 00 00       	mov    $0x86,%esi
ffffffff80003a73:	e9 f8 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e4: return 132;
ffffffff80003a78:	be 84 00 00 00       	mov    $0x84,%esi
ffffffff80003a7d:	e9 ee fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e2: return 131;
ffffffff80003a82:	be 83 00 00 00       	mov    $0x83,%esi
ffffffff80003a87:	e9 e4 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e1: return 160;
ffffffff80003a8c:	be a0 00 00 00       	mov    $0xa0,%esi
ffffffff80003a91:	e9 da fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e0: return 133;
ffffffff80003a96:	be 85 00 00 00       	mov    $0x85,%esi
ffffffff80003a9b:	e9 d0 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00df: return 225;
ffffffff80003aa0:	be e1 00 00 00       	mov    $0xe1,%esi
ffffffff80003aa5:	e9 c6 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00dc: return 154;
ffffffff80003aaa:	be 9a 00 00 00       	mov    $0x9a,%esi
ffffffff80003aaf:	e9 bc fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00d6: return 153;
ffffffff80003ab4:	be 99 00 00 00       	mov    $0x99,%esi
ffffffff80003ab9:	e9 b2 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00d1: return 165;
ffffffff80003abe:	be a5 00 00 00       	mov    $0xa5,%esi
ffffffff80003ac3:	e9 a8 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c9: return 144;
ffffffff80003ac8:	be 90 00 00 00       	mov    $0x90,%esi
ffffffff80003acd:	e9 9e fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c7: return 128;
ffffffff80003ad2:	be 80 00 00 00       	mov    $0x80,%esi
ffffffff80003ad7:	e9 94 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c6: return 146;
ffffffff80003adc:	be 92 00 00 00       	mov    $0x92,%esi
ffffffff80003ae1:	e9 8a fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c5: return 143;
ffffffff80003ae6:	be 8f 00 00 00       	mov    $0x8f,%esi
ffffffff80003aeb:	e9 80 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c4: return 142;
ffffffff80003af0:	be 8e 00 00 00       	mov    $0x8e,%esi
ffffffff80003af5:	e9 76 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bf: return 168;
ffffffff80003afa:	be a8 00 00 00       	mov    $0xa8,%esi
ffffffff80003aff:	e9 6c fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bd: return 171;
ffffffff80003b04:	be ab 00 00 00       	mov    $0xab,%esi
ffffffff80003b09:	e9 62 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bc: return 172;
ffffffff80003b0e:	be ac 00 00 00       	mov    $0xac,%esi
ffffffff80003b13:	e9 58 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bb: return 175;
ffffffff80003b18:	be af 00 00 00       	mov    $0xaf,%esi
ffffffff80003b1d:	e9 4e fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ba: return 167;
ffffffff80003b22:	be a7 00 00 00       	mov    $0xa7,%esi
ffffffff80003b27:	e9 44 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b7: return 250;
ffffffff80003b2c:	be fa 00 00 00       	mov    $0xfa,%esi
ffffffff80003b31:	e9 3a fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b5: return 230;
ffffffff80003b36:	be e6 00 00 00       	mov    $0xe6,%esi
ffffffff80003b3b:	e9 30 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b2: return 253;
ffffffff80003b40:	be fd 00 00 00       	mov    $0xfd,%esi
ffffffff80003b45:	e9 26 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c6: return 237;
ffffffff80003b4a:	be ed 00 00 00       	mov    $0xed,%esi
ffffffff80003b4f:	e9 1c fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c4: return 231;
ffffffff80003b54:	be e7 00 00 00       	mov    $0xe7,%esi
ffffffff80003b59:	e9 12 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c3: return 229;
ffffffff80003b5e:	be e5 00 00 00       	mov    $0xe5,%esi
ffffffff80003b63:	e9 08 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c0: return 227;
ffffffff80003b68:	be e3 00 00 00       	mov    $0xe3,%esi
ffffffff80003b6d:	e9 fe fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b5: return 238;
ffffffff80003b72:	be ee 00 00 00       	mov    $0xee,%esi
ffffffff80003b77:	e9 f4 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b4: return 235;
ffffffff80003b7c:	be eb 00 00 00       	mov    $0xeb,%esi
ffffffff80003b81:	e9 ea fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a9: return 234;
ffffffff80003b86:	be ea 00 00 00       	mov    $0xea,%esi
ffffffff80003b8b:	e9 e0 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a6: return 232;
ffffffff80003b90:	be e8 00 00 00       	mov    $0xe8,%esi
ffffffff80003b95:	e9 d6 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a3: return 228;
ffffffff80003b9a:	be e4 00 00 00       	mov    $0xe4,%esi
ffffffff80003b9f:	e9 cc fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0398: return 233;
ffffffff80003ba4:	be e9 00 00 00       	mov    $0xe9,%esi
ffffffff80003ba9:	e9 c2 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255c: return 189;
ffffffff80003bae:	be bd 00 00 00       	mov    $0xbd,%esi
ffffffff80003bb3:	e9 b8 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255b: return 190;
ffffffff80003bb8:	be be 00 00 00       	mov    $0xbe,%esi
ffffffff80003bbd:	e9 ae fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255a: return 200;
ffffffff80003bc2:	be c8 00 00 00       	mov    $0xc8,%esi
ffffffff80003bc7:	e9 a4 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2559: return 211;
ffffffff80003bcc:	be d3 00 00 00       	mov    $0xd3,%esi
ffffffff80003bd1:	e9 9a fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2558: return 212;
ffffffff80003bd6:	be d4 00 00 00       	mov    $0xd4,%esi
ffffffff80003bdb:	e9 90 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2557: return 187;
ffffffff80003be0:	be bb 00 00 00       	mov    $0xbb,%esi
ffffffff80003be5:	e9 86 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2556: return 183;
ffffffff80003bea:	be b7 00 00 00       	mov    $0xb7,%esi
ffffffff80003bef:	e9 7c fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2555: return 184;
ffffffff80003bf4:	be b8 00 00 00       	mov    $0xb8,%esi
ffffffff80003bf9:	e9 72 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2554: return 201;
ffffffff80003bfe:	be c9 00 00 00       	mov    $0xc9,%esi
ffffffff80003c03:	e9 68 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2553: return 214;
ffffffff80003c08:	be d6 00 00 00       	mov    $0xd6,%esi
ffffffff80003c0d:	e9 5e fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2552: return 213;
ffffffff80003c12:	be d5 00 00 00       	mov    $0xd5,%esi
ffffffff80003c17:	e9 54 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2551: return 186;
ffffffff80003c1c:	be ba 00 00 00       	mov    $0xba,%esi
ffffffff80003c21:	e9 4a fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2550: return 205;
ffffffff80003c26:	be cd 00 00 00       	mov    $0xcd,%esi
ffffffff80003c2b:	e9 40 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x253c: return 197;
ffffffff80003c30:	be c5 00 00 00       	mov    $0xc5,%esi
ffffffff80003c35:	e9 36 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2534: return 193;
ffffffff80003c3a:	be c1 00 00 00       	mov    $0xc1,%esi
ffffffff80003c3f:	e9 2c fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x252c: return 194;
ffffffff80003c44:	be c2 00 00 00       	mov    $0xc2,%esi
ffffffff80003c49:	e9 22 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25d8: return 8;
ffffffff80003c4e:	be 08 00 00 00       	mov    $0x8,%esi
ffffffff80003c53:	e9 18 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25cb: return 9;
ffffffff80003c58:	be 09 00 00 00       	mov    $0x9,%esi
ffffffff80003c5d:	e9 0e fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25c4: return 17;
ffffffff80003c62:	be 11 00 00 00       	mov    $0x11,%esi
ffffffff80003c67:	e9 04 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25bc: return 31;
ffffffff80003c6c:	be 1f 00 00 00       	mov    $0x1f,%esi
ffffffff80003c71:	e9 fa f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25ba: return 16;
ffffffff80003c76:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff80003c7b:	e9 f0 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25b2: return 30;
ffffffff80003c80:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80003c85:	e9 e6 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25ac: return 22;
ffffffff80003c8a:	be 16 00 00 00       	mov    $0x16,%esi
ffffffff80003c8f:	e9 dc f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25a0: return 254;
ffffffff80003c94:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff80003c99:	e9 d2 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2593: return 178;
ffffffff80003c9e:	be b2 00 00 00       	mov    $0xb2,%esi
ffffffff80003ca3:	e9 c8 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2592: return 177;
ffffffff80003ca8:	be b1 00 00 00       	mov    $0xb1,%esi
ffffffff80003cad:	e9 be f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2591: return 176;
ffffffff80003cb2:	be b0 00 00 00       	mov    $0xb0,%esi
ffffffff80003cb7:	e9 b4 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2590: return 222;
ffffffff80003cbc:	be de 00 00 00       	mov    $0xde,%esi
ffffffff80003cc1:	e9 aa f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x258c: return 221;
ffffffff80003cc6:	be dd 00 00 00       	mov    $0xdd,%esi
ffffffff80003ccb:	e9 a0 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2588: return 219;
ffffffff80003cd0:	be db 00 00 00       	mov    $0xdb,%esi
ffffffff80003cd5:	e9 96 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2584: return 220;
ffffffff80003cda:	be dc 00 00 00       	mov    $0xdc,%esi
ffffffff80003cdf:	e9 8c f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2580: return 223;
ffffffff80003ce4:	be df 00 00 00       	mov    $0xdf,%esi
ffffffff80003ce9:	e9 82 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256c: return 206;
ffffffff80003cee:	be ce 00 00 00       	mov    $0xce,%esi
ffffffff80003cf3:	e9 78 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256b: return 215;
ffffffff80003cf8:	be d7 00 00 00       	mov    $0xd7,%esi
ffffffff80003cfd:	e9 6e f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256a: return 216;
ffffffff80003d02:	be d8 00 00 00       	mov    $0xd8,%esi
ffffffff80003d07:	e9 64 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2569: return 202;
ffffffff80003d0c:	be ca 00 00 00       	mov    $0xca,%esi
ffffffff80003d11:	e9 5a f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2568: return 208;
ffffffff80003d16:	be d0 00 00 00       	mov    $0xd0,%esi
ffffffff80003d1b:	e9 50 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2567: return 207;
ffffffff80003d20:	be cf 00 00 00       	mov    $0xcf,%esi
ffffffff80003d25:	e9 46 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2566: return 203;
ffffffff80003d2a:	be cb 00 00 00       	mov    $0xcb,%esi
ffffffff80003d2f:	e9 3c f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2565: return 210;
ffffffff80003d34:	be d2 00 00 00       	mov    $0xd2,%esi
ffffffff80003d39:	e9 32 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2564: return 209;
ffffffff80003d3e:	be d1 00 00 00       	mov    $0xd1,%esi
ffffffff80003d43:	e9 28 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2563: return 185;
ffffffff80003d48:	be b9 00 00 00       	mov    $0xb9,%esi
ffffffff80003d4d:	e9 1e f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2562: return 182;
ffffffff80003d52:	be b6 00 00 00       	mov    $0xb6,%esi
ffffffff80003d57:	e9 14 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2561: return 181;
ffffffff80003d5c:	be b5 00 00 00       	mov    $0xb5,%esi
ffffffff80003d61:	e9 0a f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2560: return 204;
ffffffff80003d66:	be cc 00 00 00       	mov    $0xcc,%esi
ffffffff80003d6b:	e9 00 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255f: return 199;
ffffffff80003d70:	be c7 00 00 00       	mov    $0xc7,%esi
ffffffff80003d75:	e9 f6 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255e: return 198;
ffffffff80003d7a:	be c6 00 00 00       	mov    $0xc6,%esi
ffffffff80003d7f:	e9 ec f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255d: return 188;
ffffffff80003d84:	be bc 00 00 00       	mov    $0xbc,%esi
ffffffff80003d89:	e9 e2 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b1: return 224;
ffffffff80003d8e:	be e0 00 00 00       	mov    $0xe0,%esi
ffffffff80003d93:	e9 d8 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0393: return 226;
ffffffff80003d98:	be e2 00 00 00       	mov    $0xe2,%esi
ffffffff80003d9d:	e9 ce f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b6: return 20;
ffffffff80003da2:	be 14 00 00 00       	mov    $0x14,%esi
ffffffff80003da7:	e9 c4 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    switch (code_point) {
ffffffff80003dac:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80003db1:	e9 ba f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2666: return 4;
ffffffff80003db6:	be 04 00 00 00       	mov    $0x4,%esi
ffffffff80003dbb:	e9 b0 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    switch (code_point) {
ffffffff80003dc0:	be 03 00 00 00       	mov    $0x3,%esi
ffffffff80003dc5:	e9 a6 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x21a8: return 23;
ffffffff80003dca:	be 17 00 00 00       	mov    $0x17,%esi
ffffffff80003dcf:	e9 9c f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2195: return 18;
ffffffff80003dd4:	be 12 00 00 00       	mov    $0x12,%esi
ffffffff80003dd9:	e9 92 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a7: return 21;
ffffffff80003dde:	be 15 00 00 00       	mov    $0x15,%esi
ffffffff80003de3:	e9 88 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
ffffffff80003de8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80003def:	00 
            ctx->osc_escape = true;
ffffffff80003df0:	c6 43 0e 01          	movb   $0x1,0xe(%rbx)
            return;
ffffffff80003df4:	e9 9e f2 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
                ctx->scroll(ctx);
ffffffff80003df9:	48 89 df             	mov    %rbx,%rdi
ffffffff80003dfc:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y);
ffffffff80003e02:	48 8b 83 00 01 00 00 	mov    0x100(%rbx),%rax
ffffffff80003e09:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80003e0e:	31 f6                	xor    %esi,%esi
ffffffff80003e10:	f6 83 b8 00 00 00 10 	testb  $0x10,0xb8(%rbx)
ffffffff80003e17:	0f 85 65 f5 ff ff    	jne    ffffffff80003382 <flanterm_write+0x3c2>
ffffffff80003e1d:	e9 5b f5 ff ff       	jmp    ffffffff8000337d <flanterm_write+0x3bd>
                ctx->set_cursor_pos(ctx, ctx->cols - 1, y);
ffffffff80003e22:	48 8d 72 ff          	lea    -0x1(%rdx),%rsi
ffffffff80003e26:	48 89 fa             	mov    %rdi,%rdx
ffffffff80003e29:	48 89 df             	mov    %rbx,%rdi
ffffffff80003e2c:	ff d1                	call   *%rcx
                return;
ffffffff80003e2e:	e9 64 f2 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (c) {
ffffffff80003e33:	41 8d 54 24 d5       	lea    -0x2b(%r12),%edx
ffffffff80003e38:	80 fa 53             	cmp    $0x53,%dl
ffffffff80003e3b:	0f 87 e0 f4 ff ff    	ja     ffffffff80003321 <flanterm_write+0x361>
ffffffff80003e41:	0f b6 d2             	movzbl %dl,%edx
ffffffff80003e44:	3e ff 24 d5 18 a8 00 	notrack jmp *-0x7fff57e8(,%rdx,8)
ffffffff80003e4b:	80 
    if (ctx->rrr == true) {
ffffffff80003e4c:	80 7b 0f 00          	cmpb   $0x0,0xf(%rbx)
ffffffff80003e50:	0f 84 8a 01 00 00    	je     ffffffff80003fe0 <flanterm_write+0x1020>
        ctx->esc_values_i++;
ffffffff80003e56:	48 83 c2 01          	add    $0x1,%rdx
        ctx->rrr = false;
ffffffff80003e5a:	c6 43 0f 00          	movb   $0x0,0xf(%rbx)
        ctx->esc_values_i++;
ffffffff80003e5e:	48 89 53 40          	mov    %rdx,0x40(%rbx)
        if (c == ';')
ffffffff80003e62:	41 80 fc 3b          	cmp    $0x3b,%r12b
ffffffff80003e66:	0f 84 2b f2 ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
    if (ctx->dec_private == true) {
ffffffff80003e6c:	0f b6 73 14          	movzbl 0x14(%rbx),%esi
    switch (c) {
ffffffff80003e70:	41 80 fc 4b          	cmp    $0x4b,%r12b
ffffffff80003e74:	0f 8f 8f 01 00 00    	jg     ffffffff80004009 <flanterm_write+0x1049>
ffffffff80003e7a:	41 80 fc 49          	cmp    $0x49,%r12b
ffffffff80003e7e:	0f 8f 67 02 00 00    	jg     ffffffff800040eb <flanterm_write+0x112b>
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003e84:	41 b8 01 00 00 00    	mov    $0x1,%r8d
ffffffff80003e8a:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff80003e8e:	0f 87 d2 09 00 00    	ja     ffffffff80004866 <flanterm_write+0x18a6>
ffffffff80003e94:	48 8d bb b8 00 00 00 	lea    0xb8(%rbx),%rdi
ffffffff80003e9b:	48 8d 44 93 78       	lea    0x78(%rbx,%rdx,4),%rax
        ctx->esc_values[i] = esc_default;
ffffffff80003ea0:	44 89 c1             	mov    %r8d,%ecx
ffffffff80003ea3:	49 89 f9             	mov    %rdi,%r9
ffffffff80003ea6:	49 29 c1             	sub    %rax,%r9
ffffffff80003ea9:	41 83 e1 04          	and    $0x4,%r9d
ffffffff80003ead:	74 0c                	je     ffffffff80003ebb <flanterm_write+0xefb>
ffffffff80003eaf:	44 89 00             	mov    %r8d,(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003eb2:	48 83 c0 04          	add    $0x4,%rax
ffffffff80003eb6:	48 39 c7             	cmp    %rax,%rdi
ffffffff80003eb9:	74 0e                	je     ffffffff80003ec9 <flanterm_write+0xf09>
        ctx->esc_values[i] = esc_default;
ffffffff80003ebb:	89 08                	mov    %ecx,(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003ebd:	48 83 c0 08          	add    $0x8,%rax
        ctx->esc_values[i] = esc_default;
ffffffff80003ec1:	89 48 fc             	mov    %ecx,-0x4(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003ec4:	48 39 c7             	cmp    %rax,%rdi
ffffffff80003ec7:	75 f2                	jne    ffffffff80003ebb <flanterm_write+0xefb>
    if (ctx->dec_private == true) {
ffffffff80003ec9:	40 84 f6             	test   %sil,%sil
ffffffff80003ecc:	0f 85 e8 02 00 00    	jne    ffffffff800041ba <flanterm_write+0x11fa>
    bool r = ctx->scroll_enabled;
ffffffff80003ed2:	44 0f b6 73 0a       	movzbl 0xa(%rbx),%r14d
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003ed7:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
    ctx->scroll_enabled = false;
ffffffff80003edc:	c6 43 0a 00          	movb   $0x0,0xa(%rbx)
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003ee0:	48 89 df             	mov    %rbx,%rdi
ffffffff80003ee3:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff80003ee8:	ff 93 08 01 00 00    	call   *0x108(%rbx)
    switch (c) {
ffffffff80003eee:	41 8d 44 24 c0       	lea    -0x40(%r12),%eax
ffffffff80003ef3:	3c 35                	cmp    $0x35,%al
ffffffff80003ef5:	77 67                	ja     ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff80003ef7:	0f b6 c0             	movzbl %al,%eax
ffffffff80003efa:	3e ff 24 c5 b8 aa 00 	notrack jmp *-0x7fff5548(,%rax,8)
ffffffff80003f01:	80 
            x = 0;
ffffffff80003f02:	31 ff                	xor    %edi,%edi
ffffffff80003f04:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
            if (y + ctx->esc_values[0] > ctx->rows - 1)
ffffffff80003f09:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff80003f0e:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80003f15:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80003f18:	48 8d 78 ff          	lea    -0x1(%rax),%rdi
ffffffff80003f1c:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff80003f20:	48 39 f7             	cmp    %rsi,%rdi
ffffffff80003f23:	73 08                	jae    ffffffff80003f2d <flanterm_write+0xf6d>
                ctx->esc_values[0] = (ctx->rows - 1) - y;
ffffffff80003f25:	29 c8                	sub    %ecx,%eax
ffffffff80003f27:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff80003f2a:	89 53 78             	mov    %edx,0x78(%rbx)
            if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)
ffffffff80003f2d:	48 8b 73 68          	mov    0x68(%rbx),%rsi
             || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {
ffffffff80003f31:	48 8b 43 70          	mov    0x70(%rbx),%rax
            size_t dest_y = y + ctx->esc_values[0];
ffffffff80003f35:	48 01 ca             	add    %rcx,%rdx
            if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)
ffffffff80003f38:	48 39 ce             	cmp    %rcx,%rsi
ffffffff80003f3b:	72 05                	jb     ffffffff80003f42 <flanterm_write+0xf82>
ffffffff80003f3d:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80003f40:	73 05                	jae    ffffffff80003f47 <flanterm_write+0xf87>
             || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {
ffffffff80003f42:	48 39 c8             	cmp    %rcx,%rax
ffffffff80003f45:	72 09                	jb     ffffffff80003f50 <flanterm_write+0xf90>
            if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) {
ffffffff80003f47:	48 39 c2             	cmp    %rax,%rdx
ffffffff80003f4a:	0f 83 dc 07 00 00    	jae    ffffffff8000472c <flanterm_write+0x176c>
            ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);
ffffffff80003f50:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff80003f55:	48 89 df             	mov    %rbx,%rdi
ffffffff80003f58:	ff 93 00 01 00 00    	call   *0x100(%rbx)
    ctx->scroll_enabled = r;
ffffffff80003f5e:	44 88 73 0a          	mov    %r14b,0xa(%rbx)
    ctx->control_sequence = false;
ffffffff80003f62:	31 d2                	xor    %edx,%edx
ffffffff80003f64:	66 89 53 0b          	mov    %dx,0xb(%rbx)
ffffffff80003f68:	e9 2a f1 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        switch (c) {
ffffffff80003f6d:	41 80 fc 3f          	cmp    $0x3f,%r12b
ffffffff80003f71:	0f 84 17 01 00 00    	je     ffffffff8000408e <flanterm_write+0x10ce>
ffffffff80003f77:	41 80 fc 5b          	cmp    $0x5b,%r12b
ffffffff80003f7b:	0f 85 30 f6 ff ff    	jne    ffffffff800035b1 <flanterm_write+0x5f1>
                ctx->discard_next = true;
ffffffff80003f81:	c6 43 10 01          	movb   $0x1,0x10(%rbx)
                goto cleanup;
ffffffff80003f85:	eb db                	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
    switch (code_point) {
ffffffff80003f87:	49 8d 84 24 e7 dd ff 	lea    -0x2219(%r12),%rax
ffffffff80003f8e:	ff 
ffffffff80003f8f:	48 83 f8 2f          	cmp    $0x2f,%rax
ffffffff80003f93:	0f 87 27 f4 ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003f99:	3e ff 24 c5 68 ac 00 	notrack jmp *-0x7fff5398(,%rax,8)
ffffffff80003fa0:	80 
ffffffff80003fa1:	49 81 fc 7f 20 00 00 	cmp    $0x207f,%r12
ffffffff80003fa8:	0f 84 02 02 00 00    	je     ffffffff800041b0 <flanterm_write+0x11f0>
ffffffff80003fae:	0f 87 dc 01 00 00    	ja     ffffffff80004190 <flanterm_write+0x11d0>
ffffffff80003fb4:	49 81 fc 22 20 00 00 	cmp    $0x2022,%r12
ffffffff80003fbb:	0f 84 c5 01 00 00    	je     ffffffff80004186 <flanterm_write+0x11c6>
        case 0x203c: return 19;
ffffffff80003fc1:	be 13 00 00 00       	mov    $0x13,%esi
    switch (code_point) {
ffffffff80003fc6:	49 81 fc 3c 20 00 00 	cmp    $0x203c,%r12
ffffffff80003fcd:	0f 84 9d f6 ff ff    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff80003fd3:	e9 e8 f3 ff ff       	jmp    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003fd8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80003fdf:	00 
    } else if (c == ';') {
ffffffff80003fe0:	41 80 fc 3b          	cmp    $0x3b,%r12b
ffffffff80003fe4:	0f 85 82 fe ff ff    	jne    ffffffff80003e6c <flanterm_write+0xeac>
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff80003fea:	48 83 fa 10          	cmp    $0x10,%rdx
ffffffff80003fee:	0f 84 a3 f0 ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
        ctx->esc_values[ctx->esc_values_i] = 0;
ffffffff80003ff4:	c7 44 93 78 00 00 00 	movl   $0x0,0x78(%rbx,%rdx,4)
ffffffff80003ffb:	00 
        ctx->esc_values_i++;
ffffffff80003ffc:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80004000:	48 89 53 40          	mov    %rdx,0x40(%rbx)
        return;
ffffffff80004004:	e9 8e f0 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (c) {
ffffffff80004009:	41 80 fc 71          	cmp    $0x71,%r12b
ffffffff8000400d:	0f 85 c3 00 00 00    	jne    ffffffff800040d6 <flanterm_write+0x1116>
            esc_default = 0; break;
ffffffff80004013:	45 31 c0             	xor    %r8d,%r8d
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80004016:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff8000401a:	0f 86 74 fe ff ff    	jbe    ffffffff80003e94 <flanterm_write+0xed4>
    if (ctx->dec_private == true) {
ffffffff80004020:	40 84 f6             	test   %sil,%sil
ffffffff80004023:	0f 85 46 08 00 00    	jne    ffffffff8000486f <flanterm_write+0x18af>
    bool r = ctx->scroll_enabled;
ffffffff80004029:	44 0f b6 73 0a       	movzbl 0xa(%rbx),%r14d
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff8000402e:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
    ctx->scroll_enabled = false;
ffffffff80004033:	c6 43 0a 00          	movb   $0x0,0xa(%rbx)
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80004037:	48 89 df             	mov    %rbx,%rdi
ffffffff8000403a:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000403f:	ff 93 08 01 00 00    	call   *0x108(%rbx)
            if (ctx->callback != NULL) {
ffffffff80004045:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff8000404c:	48 85 c0             	test   %rax,%rax
ffffffff8000404f:	0f 84 09 ff ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0);
ffffffff80004055:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004058:	45 31 c0             	xor    %r8d,%r8d
ffffffff8000405b:	31 c9                	xor    %ecx,%ecx
ffffffff8000405d:	be 3c 00 00 00       	mov    $0x3c,%esi
ffffffff80004062:	48 89 df             	mov    %rbx,%rdi
ffffffff80004065:	ff d0                	call   *%rax
ffffffff80004067:	e9 f2 fe ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff8000406c:	0f 1f 40 00          	nopl   0x0(%rax)
                ctx->scroll(ctx);
ffffffff80004070:	48 89 df             	mov    %rbx,%rdi
ffffffff80004073:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004079:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000407e:	31 f6                	xor    %esi,%esi
ffffffff80004080:	48 89 df             	mov    %rbx,%rdi
ffffffff80004083:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff80004089:	e9 ca f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
                ctx->dec_private = true;
ffffffff8000408e:	c6 43 14 01          	movb   $0x1,0x14(%rbx)
                return;
ffffffff80004092:	e9 00 f0 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
                ctx->scroll(ctx);
ffffffff80004097:	48 89 df             	mov    %rbx,%rdi
ffffffff8000409a:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, x, y);
ffffffff800040a0:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800040a5:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800040aa:	48 89 df             	mov    %rbx,%rdi
ffffffff800040ad:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800040b3:	e9 a0 f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
                ctx->revscroll(ctx);
ffffffff800040b8:	48 89 df             	mov    %rbx,%rdi
ffffffff800040bb:	ff 93 70 01 00 00    	call   *0x170(%rbx)
                ctx->set_cursor_pos(ctx, 0, y);
ffffffff800040c1:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800040c6:	31 f6                	xor    %esi,%esi
ffffffff800040c8:	48 89 df             	mov    %rbx,%rdi
ffffffff800040cb:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800040d1:	e9 82 f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff800040d6:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff800040da:	0f 87 31 06 00 00    	ja     ffffffff80004711 <flanterm_write+0x1751>
ffffffff800040e0:	41 b8 01 00 00 00    	mov    $0x1,%r8d
ffffffff800040e6:	e9 a9 fd ff ff       	jmp    ffffffff80003e94 <flanterm_write+0xed4>
            esc_default = 0; break;
ffffffff800040eb:	45 31 c0             	xor    %r8d,%r8d
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff800040ee:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff800040f2:	0f 86 9c fd ff ff    	jbe    ffffffff80003e94 <flanterm_write+0xed4>
    if (ctx->dec_private == true) {
ffffffff800040f8:	40 84 f6             	test   %sil,%sil
ffffffff800040fb:	0f 84 d1 fd ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff80004101:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    switch (c) {
ffffffff80004105:	41 80 fc 6c          	cmp    $0x6c,%r12b
ffffffff80004109:	0f 85 53 fe ff ff    	jne    ffffffff80003f62 <flanterm_write+0xfa2>
    switch (ctx->esc_values[0]) {
ffffffff8000410f:	83 7b 78 19          	cmpl   $0x19,0x78(%rbx)
ffffffff80004113:	0f 84 0a 06 00 00    	je     ffffffff80004723 <flanterm_write+0x1763>
    if (ctx->callback != NULL) {
ffffffff80004119:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004120:	48 85 c0             	test   %rax,%rax
ffffffff80004123:	0f 84 39 fe ff ff    	je     ffffffff80003f62 <flanterm_write+0xfa2>
        ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);
ffffffff80004129:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff8000412d:	4d 0f be c4          	movsbq %r12b,%r8
ffffffff80004131:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff80004136:	48 89 df             	mov    %rbx,%rdi
ffffffff80004139:	ff d0                	call   *%rax
ffffffff8000413b:	e9 22 fe ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
        case 0x2248: return 247;
ffffffff80004140:	be f7 00 00 00       	mov    $0xf7,%esi
ffffffff80004145:	e9 26 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2302: return 127;
ffffffff8000414a:	be 7f 00 00 00       	mov    $0x7f,%esi
ffffffff8000414f:	e9 1c f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2229: return 239;
ffffffff80004154:	be ef 00 00 00       	mov    $0xef,%esi
ffffffff80004159:	e9 12 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x221a: return 251;
ffffffff8000415e:	be fb 00 00 00       	mov    $0xfb,%esi
ffffffff80004163:	e9 08 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2219: return 249;
ffffffff80004168:	be f9 00 00 00       	mov    $0xf9,%esi
ffffffff8000416d:	e9 fe f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2265: return 242;
ffffffff80004172:	be f2 00 00 00       	mov    $0xf2,%esi
ffffffff80004177:	e9 f4 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2264: return 243;
ffffffff8000417c:	be f3 00 00 00       	mov    $0xf3,%esi
ffffffff80004181:	e9 ea f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2022: return 7;
ffffffff80004186:	be 07 00 00 00       	mov    $0x7,%esi
ffffffff8000418b:	e9 e0 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x20a7: return 158;
ffffffff80004190:	be 9e 00 00 00       	mov    $0x9e,%esi
    switch (code_point) {
ffffffff80004195:	49 81 fc a7 20 00 00 	cmp    $0x20a7,%r12
ffffffff8000419c:	0f 84 ce f4 ff ff    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff800041a2:	e9 19 f2 ff ff       	jmp    ffffffff800033c0 <flanterm_write+0x400>
ffffffff800041a7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800041ae:	00 00 
        case 0x207f: return 252;
ffffffff800041b0:	be fc 00 00 00       	mov    $0xfc,%esi
ffffffff800041b5:	e9 b6 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    ctx->dec_private = false;
ffffffff800041ba:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    if (ctx->esc_values_i == 0) {
ffffffff800041be:	48 85 d2             	test   %rdx,%rdx
ffffffff800041c1:	0f 84 9b fd ff ff    	je     ffffffff80003f62 <flanterm_write+0xfa2>
    switch (c) {
ffffffff800041c7:	41 80 fc 68          	cmp    $0x68,%r12b
ffffffff800041cb:	0f 85 34 ff ff ff    	jne    ffffffff80004105 <flanterm_write+0x1145>
    switch (ctx->esc_values[0]) {
ffffffff800041d1:	83 7b 78 19          	cmpl   $0x19,0x78(%rbx)
ffffffff800041d5:	0f 85 3e ff ff ff    	jne    ffffffff80004119 <flanterm_write+0x1159>
                ctx->cursor_enabled = true;
ffffffff800041db:	c6 43 09 01          	movb   $0x1,0x9(%rbx)
ffffffff800041df:	e9 7e fd ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
ffffffff800041e4:	0f 1f 40 00          	nopl   0x0(%rax)
        case 0x2321: return 245;
ffffffff800041e8:	be f5 00 00 00       	mov    $0xf5,%esi
ffffffff800041ed:	e9 7e f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2320: return 244;
ffffffff800041f2:	be f4 00 00 00       	mov    $0xf4,%esi
ffffffff800041f7:	e9 74 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff800041fc:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800041ff:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
ffffffff80004204:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000420b:	49 01 d4             	add    %rdx,%r12
ffffffff8000420e:	49 39 c4             	cmp    %rax,%r12
ffffffff80004211:	73 2d                	jae    ffffffff80004240 <flanterm_write+0x1280>
                ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);
ffffffff80004213:	4c 8b 44 24 18       	mov    0x18(%rsp),%r8
ffffffff80004218:	4c 89 e6             	mov    %r12,%rsi
ffffffff8000421b:	4c 89 e1             	mov    %r12,%rcx
ffffffff8000421e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004221:	48 29 d6             	sub    %rdx,%rsi
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff80004224:	49 83 c4 01          	add    $0x1,%r12
                ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);
ffffffff80004228:	4c 89 c2             	mov    %r8,%rdx
ffffffff8000422b:	ff 93 60 01 00 00    	call   *0x160(%rbx)
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff80004231:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff80004238:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff8000423b:	49 39 c4             	cmp    %rax,%r12
ffffffff8000423e:	72 d3                	jb     ffffffff80004213 <flanterm_write+0x1253>
            ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y);
ffffffff80004240:	48 29 d0             	sub    %rdx,%rax
ffffffff80004243:	48 89 df             	mov    %rbx,%rdi
ffffffff80004246:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000424b:	48 89 c6             	mov    %rax,%rsi
ffffffff8000424e:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            size_t count = ctx->esc_values[0] > ctx->cols ? ctx->cols : ctx->esc_values[0];
ffffffff80004254:	44 8b 63 78          	mov    0x78(%rbx),%r12d
ffffffff80004258:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000425f:	49 39 c4             	cmp    %rax,%r12
ffffffff80004262:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++)
ffffffff80004266:	45 31 ff             	xor    %r15d,%r15d
ffffffff80004269:	4d 85 e4             	test   %r12,%r12
ffffffff8000426c:	74 17                	je     ffffffff80004285 <flanterm_write+0x12c5>
ffffffff8000426e:	49 83 c7 01          	add    $0x1,%r15
                ctx->raw_putchar(ctx, ' ');
ffffffff80004272:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004277:	48 89 df             	mov    %rbx,%rdi
ffffffff8000427a:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 0; i < count; i++)
ffffffff80004280:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004283:	75 e9                	jne    ffffffff8000426e <flanterm_write+0x12ae>
                    ctx->set_cursor_pos(ctx, x, y);
ffffffff80004285:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000428a:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff8000428f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004292:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    break;
ffffffff80004298:	e9 c1 fc ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            x = 0;
ffffffff8000429d:	45 31 c0             	xor    %r8d,%r8d
ffffffff800042a0:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
            if (ctx->esc_values[0] > y)
ffffffff800042a5:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800042aa:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800042ad:	48 39 d1             	cmp    %rdx,%rcx
ffffffff800042b0:	73 05                	jae    ffffffff800042b7 <flanterm_write+0x12f7>
                ctx->esc_values[0] = y;
ffffffff800042b2:	89 4b 78             	mov    %ecx,0x78(%rbx)
ffffffff800042b5:	89 ca                	mov    %ecx,%edx
            size_t dest_y = y - ctx->esc_values[0];
ffffffff800042b7:	48 89 c8             	mov    %rcx,%rax
ffffffff800042ba:	48 29 d0             	sub    %rdx,%rax
            if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y)
ffffffff800042bd:	48 8b 53 68          	mov    0x68(%rbx),%rdx
ffffffff800042c1:	48 39 c2             	cmp    %rax,%rdx
ffffffff800042c4:	72 09                	jb     ffffffff800042cf <flanterm_write+0x130f>
ffffffff800042c6:	48 39 d1             	cmp    %rdx,%rcx
ffffffff800042c9:	0f 83 2c 04 00 00    	jae    ffffffff800046fb <flanterm_write+0x173b>
             || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) {
ffffffff800042cf:	48 8b 73 70          	mov    0x70(%rbx),%rsi
ffffffff800042d3:	48 39 c6             	cmp    %rax,%rsi
ffffffff800042d6:	72 09                	jb     ffffffff800042e1 <flanterm_write+0x1321>
ffffffff800042d8:	48 39 f1             	cmp    %rsi,%rcx
ffffffff800042db:	0f 83 1a 04 00 00    	jae    ffffffff800046fb <flanterm_write+0x173b>
            ctx->set_cursor_pos(ctx, x, dest_y);
ffffffff800042e1:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800042e6:	48 89 c2             	mov    %rax,%rdx
ffffffff800042e9:	48 89 df             	mov    %rbx,%rdi
ffffffff800042ec:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff800042f2:	e9 67 fc ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
        case 0x221f: return 28;
ffffffff800042f7:	be 1c 00 00 00       	mov    $0x1c,%esi
ffffffff800042fc:	e9 6f f3 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case '~': FLANTERM_DEC_SPCL_PRN(0xfa)
ffffffff80004301:	be fa 00 00 00       	mov    $0xfa,%esi
ffffffff80004306:	48 89 df             	mov    %rbx,%rdi
ffffffff80004309:	ff d0                	call   *%rax
ffffffff8000430b:	e9 87 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '}': FLANTERM_DEC_SPCL_PRN(0x9c)
ffffffff80004310:	be 9c 00 00 00       	mov    $0x9c,%esi
ffffffff80004315:	48 89 df             	mov    %rbx,%rdi
ffffffff80004318:	ff d0                	call   *%rax
ffffffff8000431a:	e9 78 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '{': FLANTERM_DEC_SPCL_PRN(0xe3)
ffffffff8000431f:	be e3 00 00 00       	mov    $0xe3,%esi
ffffffff80004324:	48 89 df             	mov    %rbx,%rdi
ffffffff80004327:	ff d0                	call   *%rax
ffffffff80004329:	e9 69 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'z': FLANTERM_DEC_SPCL_PRN(0xf2)
ffffffff8000432e:	be f2 00 00 00       	mov    $0xf2,%esi
ffffffff80004333:	48 89 df             	mov    %rbx,%rdi
ffffffff80004336:	ff d0                	call   *%rax
ffffffff80004338:	e9 5a ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'y': FLANTERM_DEC_SPCL_PRN(0xf3)
ffffffff8000433d:	be f3 00 00 00       	mov    $0xf3,%esi
ffffffff80004342:	48 89 df             	mov    %rbx,%rdi
ffffffff80004345:	ff d0                	call   *%rax
ffffffff80004347:	e9 4b ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'x': FLANTERM_DEC_SPCL_PRN(0xb3)
ffffffff8000434c:	be b3 00 00 00       	mov    $0xb3,%esi
ffffffff80004351:	48 89 df             	mov    %rbx,%rdi
ffffffff80004354:	ff d0                	call   *%rax
ffffffff80004356:	e9 3c ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'w': FLANTERM_DEC_SPCL_PRN(0xc2)
ffffffff8000435b:	be c2 00 00 00       	mov    $0xc2,%esi
ffffffff80004360:	48 89 df             	mov    %rbx,%rdi
ffffffff80004363:	ff d0                	call   *%rax
ffffffff80004365:	e9 2d ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'v': FLANTERM_DEC_SPCL_PRN(0xc1)
ffffffff8000436a:	be c1 00 00 00       	mov    $0xc1,%esi
ffffffff8000436f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004372:	ff d0                	call   *%rax
ffffffff80004374:	e9 1e ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'u': FLANTERM_DEC_SPCL_PRN(0xb4)
ffffffff80004379:	be b4 00 00 00       	mov    $0xb4,%esi
ffffffff8000437e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004381:	ff d0                	call   *%rax
ffffffff80004383:	e9 0f ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 't': FLANTERM_DEC_SPCL_PRN(0xc3)
ffffffff80004388:	be c3 00 00 00       	mov    $0xc3,%esi
ffffffff8000438d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004390:	ff d0                	call   *%rax
ffffffff80004392:	e9 00 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 's': FLANTERM_DEC_SPCL_PRN(0x5f)
ffffffff80004397:	be 5f 00 00 00       	mov    $0x5f,%esi
ffffffff8000439c:	48 89 df             	mov    %rbx,%rdi
ffffffff8000439f:	ff d0                	call   *%rax
ffffffff800043a1:	e9 f1 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'q': FLANTERM_DEC_SPCL_PRN(0xc4)
ffffffff800043a6:	be c4 00 00 00       	mov    $0xc4,%esi
ffffffff800043ab:	48 89 df             	mov    %rbx,%rdi
ffffffff800043ae:	ff d0                	call   *%rax
ffffffff800043b0:	e9 e2 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'n': FLANTERM_DEC_SPCL_PRN(0xc5)
ffffffff800043b5:	be c5 00 00 00       	mov    $0xc5,%esi
ffffffff800043ba:	48 89 df             	mov    %rbx,%rdi
ffffffff800043bd:	ff d0                	call   *%rax
ffffffff800043bf:	e9 d3 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'm': FLANTERM_DEC_SPCL_PRN(0xc0)
ffffffff800043c4:	be c0 00 00 00       	mov    $0xc0,%esi
ffffffff800043c9:	48 89 df             	mov    %rbx,%rdi
ffffffff800043cc:	ff d0                	call   *%rax
ffffffff800043ce:	e9 c4 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'l': FLANTERM_DEC_SPCL_PRN(0xda)
ffffffff800043d3:	be da 00 00 00       	mov    $0xda,%esi
ffffffff800043d8:	48 89 df             	mov    %rbx,%rdi
ffffffff800043db:	ff d0                	call   *%rax
ffffffff800043dd:	e9 b5 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'k': FLANTERM_DEC_SPCL_PRN(0xbf)
ffffffff800043e2:	be bf 00 00 00       	mov    $0xbf,%esi
ffffffff800043e7:	48 89 df             	mov    %rbx,%rdi
ffffffff800043ea:	ff d0                	call   *%rax
ffffffff800043ec:	e9 a6 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'j': FLANTERM_DEC_SPCL_PRN(0xd9)
ffffffff800043f1:	be d9 00 00 00       	mov    $0xd9,%esi
ffffffff800043f6:	48 89 df             	mov    %rbx,%rdi
ffffffff800043f9:	ff d0                	call   *%rax
ffffffff800043fb:	e9 97 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'h': FLANTERM_DEC_SPCL_PRN(0xb0)
ffffffff80004400:	be b0 00 00 00       	mov    $0xb0,%esi
ffffffff80004405:	48 89 df             	mov    %rbx,%rdi
ffffffff80004408:	ff d0                	call   *%rax
ffffffff8000440a:	e9 88 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'g': FLANTERM_DEC_SPCL_PRN(0xf1)
ffffffff8000440f:	be f1 00 00 00       	mov    $0xf1,%esi
ffffffff80004414:	48 89 df             	mov    %rbx,%rdi
ffffffff80004417:	ff d0                	call   *%rax
ffffffff80004419:	e9 79 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'f': FLANTERM_DEC_SPCL_PRN(0xf8)
ffffffff8000441e:	be f8 00 00 00       	mov    $0xf8,%esi
ffffffff80004423:	48 89 df             	mov    %rbx,%rdi
ffffffff80004426:	ff d0                	call   *%rax
ffffffff80004428:	e9 6a ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'a': FLANTERM_DEC_SPCL_PRN(0xb1)
ffffffff8000442d:	be b1 00 00 00       	mov    $0xb1,%esi
ffffffff80004432:	48 89 df             	mov    %rbx,%rdi
ffffffff80004435:	ff d0                	call   *%rax
ffffffff80004437:	e9 5b ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '`': FLANTERM_DEC_SPCL_PRN(0x04)
ffffffff8000443c:	be 04 00 00 00       	mov    $0x4,%esi
ffffffff80004441:	48 89 df             	mov    %rbx,%rdi
ffffffff80004444:	ff d0                	call   *%rax
ffffffff80004446:	e9 4c ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '_': FLANTERM_DEC_SPCL_PRN(0xff)
ffffffff8000444b:	be ff 00 00 00       	mov    $0xff,%esi
ffffffff80004450:	48 89 df             	mov    %rbx,%rdi
ffffffff80004453:	ff d0                	call   *%rax
ffffffff80004455:	e9 3d ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '0': FLANTERM_DEC_SPCL_PRN(0xdb)
ffffffff8000445a:	be db 00 00 00       	mov    $0xdb,%esi
ffffffff8000445f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004462:	ff d0                	call   *%rax
ffffffff80004464:	e9 2e ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '.': FLANTERM_DEC_SPCL_PRN(0x19)
ffffffff80004469:	be 19 00 00 00       	mov    $0x19,%esi
ffffffff8000446e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004471:	ff d0                	call   *%rax
ffffffff80004473:	e9 1f ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '-': FLANTERM_DEC_SPCL_PRN(0x18)
ffffffff80004478:	be 18 00 00 00       	mov    $0x18,%esi
ffffffff8000447d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004480:	ff d0                	call   *%rax
ffffffff80004482:	e9 10 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case ',': FLANTERM_DEC_SPCL_PRN(0x1b)
ffffffff80004487:	be 1b 00 00 00       	mov    $0x1b,%esi
ffffffff8000448c:	48 89 df             	mov    %rbx,%rdi
ffffffff8000448f:	ff d0                	call   *%rax
ffffffff80004491:	e9 01 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '+': FLANTERM_DEC_SPCL_PRN(0x1a)
ffffffff80004496:	be 1a 00 00 00       	mov    $0x1a,%esi
ffffffff8000449b:	48 89 df             	mov    %rbx,%rdi
ffffffff8000449e:	ff d0                	call   *%rax
ffffffff800044a0:	e9 f2 eb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044a5:	44 8b 63 78          	mov    0x78(%rbx),%r12d
ffffffff800044a9:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff800044b0:	49 39 c4             	cmp    %rax,%r12
ffffffff800044b3:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++) {
ffffffff800044b7:	4d 85 e4             	test   %r12,%r12
ffffffff800044ba:	0f 84 9e fa ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff800044c0:	45 31 ff             	xor    %r15d,%r15d
ffffffff800044c3:	49 83 c7 01          	add    $0x1,%r15
                ctx->scroll(ctx);
ffffffff800044c7:	48 89 df             	mov    %rbx,%rdi
ffffffff800044ca:	ff 93 68 01 00 00    	call   *0x168(%rbx)
            for (size_t i = 0; i < count; i++) {
ffffffff800044d0:	4d 39 fc             	cmp    %r15,%r12
ffffffff800044d3:	75 ee                	jne    ffffffff800044c3 <flanterm_write+0x1503>
ffffffff800044d5:	e9 84 fa ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->scroll_top_margin = y;
ffffffff800044da:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044df:	44 8b 63 78          	mov    0x78(%rbx),%r12d
            size_t old_scroll_top_margin = ctx->scroll_top_margin;
ffffffff800044e3:	48 8b 53 68          	mov    0x68(%rbx),%rdx
            ctx->scroll_top_margin = y;
ffffffff800044e7:	48 89 43 68          	mov    %rax,0x68(%rbx)
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044eb:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff800044f2:	49 39 c4             	cmp    %rax,%r12
ffffffff800044f5:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++) {
ffffffff800044f9:	45 31 ff             	xor    %r15d,%r15d
ffffffff800044fc:	4d 85 e4             	test   %r12,%r12
ffffffff800044ff:	74 1c                	je     ffffffff8000451d <flanterm_write+0x155d>
ffffffff80004501:	49 83 c7 01          	add    $0x1,%r15
ffffffff80004505:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
                ctx->revscroll(ctx);
ffffffff8000450a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000450d:	ff 93 70 01 00 00    	call   *0x170(%rbx)
            for (size_t i = 0; i < count; i++) {
ffffffff80004513:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004516:	48 8b 54 24 08       	mov    0x8(%rsp),%rdx
ffffffff8000451b:	75 e4                	jne    ffffffff80004501 <flanterm_write+0x1541>
            ctx->scroll_top_margin = old_scroll_top_margin;
ffffffff8000451d:	48 89 53 68          	mov    %rdx,0x68(%rbx)
            break;
ffffffff80004521:	e9 38 fa ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[0]) {
ffffffff80004526:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff80004529:	83 f8 01             	cmp    $0x1,%eax
ffffffff8000452c:	74 69                	je     ffffffff80004597 <flanterm_write+0x15d7>
ffffffff8000452e:	83 f8 02             	cmp    $0x2,%eax
ffffffff80004531:	74 2f                	je     ffffffff80004562 <flanterm_write+0x15a2>
ffffffff80004533:	85 c0                	test   %eax,%eax
ffffffff80004535:	0f 85 23 fa ff ff    	jne    ffffffff80003f5e <flanterm_write+0xf9e>
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff8000453b:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
ffffffff80004540:	eb 12                	jmp    ffffffff80004554 <flanterm_write+0x1594>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004542:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004547:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff8000454a:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff8000454e:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff80004554:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff8000455b:	72 e5                	jb     ffffffff80004542 <flanterm_write+0x1582>
ffffffff8000455d:	e9 23 fd ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004562:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80004567:	31 f6                	xor    %esi,%esi
ffffffff80004569:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff8000456c:	45 31 e4             	xor    %r12d,%r12d
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff8000456f:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff80004575:	eb 12                	jmp    ffffffff80004589 <flanterm_write+0x15c9>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004577:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff8000457c:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff8000457f:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004583:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff80004589:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff80004590:	72 e5                	jb     ffffffff80004577 <flanterm_write+0x15b7>
ffffffff80004592:	e9 ee fc ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004597:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000459c:	31 f6                	xor    %esi,%esi
ffffffff8000459e:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < x; i++)
ffffffff800045a1:	45 31 e4             	xor    %r12d,%r12d
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff800045a4:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t i = 0; i < x; i++)
ffffffff800045aa:	eb 12                	jmp    ffffffff800045be <flanterm_write+0x15fe>
                        ctx->raw_putchar(ctx, ' ');
ffffffff800045ac:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff800045b1:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < x; i++)
ffffffff800045b4:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff800045b8:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < x; i++)
ffffffff800045be:	4c 3b 64 24 10       	cmp    0x10(%rsp),%r12
ffffffff800045c3:	72 e7                	jb     ffffffff800045ac <flanterm_write+0x15ec>
ffffffff800045c5:	e9 94 f9 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[0]) {
ffffffff800045ca:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff800045cd:	83 f8 01             	cmp    $0x1,%eax
ffffffff800045d0:	0f 84 b3 00 00 00    	je     ffffffff80004689 <flanterm_write+0x16c9>
ffffffff800045d6:	0f 87 91 00 00 00    	ja     ffffffff8000466d <flanterm_write+0x16ad>
                    size_t cols_diff = ctx->cols - (x + 1);
ffffffff800045dc:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
                    size_t rows_remaining = ctx->rows - (y + 1);
ffffffff800045e3:	4c 8b a3 e0 00 00 00 	mov    0xe0(%rbx),%r12
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff800045ea:	45 31 ff             	xor    %r15d,%r15d
                    size_t rows_remaining = ctx->rows - (y + 1);
ffffffff800045ed:	4c 2b 64 24 18       	sub    0x18(%rsp),%r12
ffffffff800045f2:	49 83 ec 01          	sub    $0x1,%r12
                    size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1;
ffffffff800045f6:	4c 0f af e0          	imul   %rax,%r12
ffffffff800045fa:	48 2b 44 24 10       	sub    0x10(%rsp),%rax
ffffffff800045ff:	49 01 c4             	add    %rax,%r12
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff80004602:	eb 12                	jmp    ffffffff80004616 <flanterm_write+0x1656>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004604:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004609:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff8000460c:	49 83 c7 01          	add    $0x1,%r15
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004610:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff80004616:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004619:	75 e9                	jne    ffffffff80004604 <flanterm_write+0x1644>
ffffffff8000461b:	e9 65 fc ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
            if (ctx->esc_values[0] != 0) {
ffffffff80004620:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff80004623:	85 c0                	test   %eax,%eax
ffffffff80004625:	74 06                	je     ffffffff8000462d <flanterm_write+0x166d>
                ctx->esc_values[0]--;
ffffffff80004627:	83 e8 01             	sub    $0x1,%eax
ffffffff8000462a:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[1] != 0) {
ffffffff8000462d:	8b 43 7c             	mov    0x7c(%rbx),%eax
ffffffff80004630:	85 c0                	test   %eax,%eax
ffffffff80004632:	74 06                	je     ffffffff8000463a <flanterm_write+0x167a>
                ctx->esc_values[1]--;
ffffffff80004634:	83 e8 01             	sub    $0x1,%eax
ffffffff80004637:	89 43 7c             	mov    %eax,0x7c(%rbx)
            if (ctx->esc_values[1] >= ctx->cols)
ffffffff8000463a:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff80004641:	8b 73 7c             	mov    0x7c(%rbx),%esi
ffffffff80004644:	48 39 c6             	cmp    %rax,%rsi
ffffffff80004647:	72 06                	jb     ffffffff8000464f <flanterm_write+0x168f>
                ctx->esc_values[1] = ctx->cols - 1;
ffffffff80004649:	8d 70 ff             	lea    -0x1(%rax),%esi
ffffffff8000464c:	89 73 7c             	mov    %esi,0x7c(%rbx)
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff8000464f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80004656:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004659:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000465c:	0f 82 f3 f8 ff ff    	jb     ffffffff80003f55 <flanterm_write+0xf95>
                ctx->esc_values[0] = ctx->rows - 1;
ffffffff80004662:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff80004665:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]);
ffffffff80004668:	e9 e8 f8 ff ff       	jmp    ffffffff80003f55 <flanterm_write+0xf95>
            switch (ctx->esc_values[0]) {
ffffffff8000466d:	83 e8 02             	sub    $0x2,%eax
ffffffff80004670:	83 f8 01             	cmp    $0x1,%eax
ffffffff80004673:	0f 87 e5 f8 ff ff    	ja     ffffffff80003f5e <flanterm_write+0xf9e>
                    ctx->clear(ctx, false);
ffffffff80004679:	31 f6                	xor    %esi,%esi
ffffffff8000467b:	48 89 df             	mov    %rbx,%rdi
ffffffff8000467e:	ff 93 f8 00 00 00    	call   *0xf8(%rbx)
                    break;
ffffffff80004684:	e9 d5 f8 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    ctx->set_cursor_pos(ctx, 0, 0);
ffffffff80004689:	31 d2                	xor    %edx,%edx
ffffffff8000468b:	31 f6                	xor    %esi,%esi
ffffffff8000468d:	48 89 df             	mov    %rbx,%rdi
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff80004690:	45 31 ff             	xor    %r15d,%r15d
                    ctx->set_cursor_pos(ctx, 0, 0);
ffffffff80004693:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff80004699:	4c 3b bb e0 00 00 00 	cmp    0xe0(%rbx),%r15
ffffffff800046a0:	0f 83 b8 f8 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                        for (size_t xc = 0; xc < ctx->cols; xc++) {
ffffffff800046a6:	45 31 e4             	xor    %r12d,%r12d
ffffffff800046a9:	48 83 bb e8 00 00 00 	cmpq   $0x0,0xe8(%rbx)
ffffffff800046b0:	00 
ffffffff800046b1:	75 12                	jne    ffffffff800046c5 <flanterm_write+0x1705>
ffffffff800046b3:	eb 40                	jmp    ffffffff800046f5 <flanterm_write+0x1735>
ffffffff800046b5:	0f 1f 00             	nopl   (%rax)
ffffffff800046b8:	49 83 c4 01          	add    $0x1,%r12
ffffffff800046bc:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff800046c3:	73 30                	jae    ffffffff800046f5 <flanterm_write+0x1735>
                            ctx->raw_putchar(ctx, ' ');
ffffffff800046c5:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff800046ca:	48 89 df             	mov    %rbx,%rdi
ffffffff800046cd:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                            if (xc == x && yc == y) {
ffffffff800046d3:	4c 39 64 24 10       	cmp    %r12,0x10(%rsp)
ffffffff800046d8:	75 de                	jne    ffffffff800046b8 <flanterm_write+0x16f8>
ffffffff800046da:	4c 39 7c 24 18       	cmp    %r15,0x18(%rsp)
ffffffff800046df:	75 d7                	jne    ffffffff800046b8 <flanterm_write+0x16f8>
                                ctx->set_cursor_pos(ctx, x, y);
ffffffff800046e1:	4c 89 fa             	mov    %r15,%rdx
ffffffff800046e4:	4c 89 e6             	mov    %r12,%rsi
ffffffff800046e7:	48 89 df             	mov    %rbx,%rdi
ffffffff800046ea:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                        if (b == true)
ffffffff800046f0:	e9 69 f8 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff800046f5:	49 83 c7 01          	add    $0x1,%r15
ffffffff800046f9:	eb 9e                	jmp    ffffffff80004699 <flanterm_write+0x16d9>
            if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) {
ffffffff800046fb:	48 39 d0             	cmp    %rdx,%rax
ffffffff800046fe:	48 0f 42 c2          	cmovb  %rdx,%rax
ffffffff80004702:	e9 da fb ff ff       	jmp    ffffffff800042e1 <flanterm_write+0x1321>
        case 0x221e: return 236;
ffffffff80004707:	be ec 00 00 00       	mov    $0xec,%esi
ffffffff8000470c:	e9 5f ef ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    if (ctx->dec_private == true) {
ffffffff80004711:	40 84 f6             	test   %sil,%sil
ffffffff80004714:	0f 84 b8 f7 ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff8000471a:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    if (ctx->esc_values_i == 0) {
ffffffff8000471e:	e9 a4 fa ff ff       	jmp    ffffffff800041c7 <flanterm_write+0x1207>
                ctx->cursor_enabled = false;
ffffffff80004723:	c6 43 09 00          	movb   $0x0,0x9(%rbx)
ffffffff80004727:	e9 36 f8 ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
                dest_y = ctx->scroll_bottom_margin - 1;
ffffffff8000472c:	48 8d 50 ff          	lea    -0x1(%rax),%rdx
            ctx->set_cursor_pos(ctx, x, dest_y);
ffffffff80004730:	e9 1b f8 ff ff       	jmp    ffffffff80003f50 <flanterm_write+0xf90>
            for (size_t i = ctx->cols - 1; ; i--) {
ffffffff80004735:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000473c:	4c 8d 60 ff          	lea    -0x1(%rax),%r12
ffffffff80004740:	eb 04                	jmp    ffffffff80004746 <flanterm_write+0x1786>
ffffffff80004742:	49 83 ec 01          	sub    $0x1,%r12
                ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y);
ffffffff80004746:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000474b:	8b 73 78             	mov    0x78(%rbx),%esi
ffffffff8000474e:	4c 89 e1             	mov    %r12,%rcx
ffffffff80004751:	48 89 df             	mov    %rbx,%rdi
ffffffff80004754:	4c 01 e6             	add    %r12,%rsi
ffffffff80004757:	49 89 d0             	mov    %rdx,%r8
ffffffff8000475a:	ff 93 60 01 00 00    	call   *0x160(%rbx)
                ctx->set_cursor_pos(ctx, i, y);
ffffffff80004760:	4c 89 e6             	mov    %r12,%rsi
ffffffff80004763:	48 89 df             	mov    %rbx,%rdi
ffffffff80004766:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000476b:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                ctx->raw_putchar(ctx, ' ');
ffffffff80004771:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004776:	48 89 df             	mov    %rbx,%rdi
ffffffff80004779:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                if (i == x) {
ffffffff8000477f:	4c 3b 64 24 10       	cmp    0x10(%rsp),%r12
ffffffff80004784:	75 bc                	jne    ffffffff80004742 <flanterm_write+0x1782>
            ctx->set_cursor_pos(ctx, x, y);
ffffffff80004786:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000478b:	4c 89 e6             	mov    %r12,%rsi
ffffffff8000478e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004791:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004797:	e9 c2 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->esc_values_i == 0) {
ffffffff8000479c:	48 8b 53 40          	mov    0x40(%rbx),%rdx
ffffffff800047a0:	48 85 d2             	test   %rdx,%rdx
ffffffff800047a3:	0f 84 b5 f7 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->callback != NULL) {
ffffffff800047a9:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800047b0:	48 85 c0             	test   %rax,%rax
ffffffff800047b3:	0f 84 a5 f7 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
        ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0);
ffffffff800047b9:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff800047bd:	45 31 c0             	xor    %r8d,%r8d
ffffffff800047c0:	be 50 00 00 00       	mov    $0x50,%esi
ffffffff800047c5:	48 89 df             	mov    %rbx,%rdi
ffffffff800047c8:	ff d0                	call   *%rax
ffffffff800047ca:	e9 8f f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (x + ctx->esc_values[0] > ctx->cols - 1)
ffffffff800047cf:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
ffffffff800047d4:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff800047db:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800047de:	48 8d 78 ff          	lea    -0x1(%rax),%rdi
ffffffff800047e2:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff800047e6:	48 39 f7             	cmp    %rsi,%rdi
ffffffff800047e9:	73 08                	jae    ffffffff800047f3 <flanterm_write+0x1833>
                ctx->esc_values[0] = (ctx->cols - 1) - x;
ffffffff800047eb:	29 c8                	sub    %ecx,%eax
ffffffff800047ed:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff800047f0:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y);
ffffffff800047f3:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff800047f7:	48 89 df             	mov    %rbx,%rdi
ffffffff800047fa:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800047ff:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004805:	e9 54 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->esc_values[0] -= 1;
ffffffff8000480a:	8b 43 78             	mov    0x78(%rbx),%eax
            if (ctx->esc_values[0] >= ctx->cols)
ffffffff8000480d:	48 8b 93 e8 00 00 00 	mov    0xe8(%rbx),%rdx
            ctx->esc_values[0] -= 1;
ffffffff80004814:	83 e8 01             	sub    $0x1,%eax
ffffffff80004817:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[0] >= ctx->cols)
ffffffff8000481a:	48 39 d0             	cmp    %rdx,%rax
ffffffff8000481d:	72 06                	jb     ffffffff80004825 <flanterm_write+0x1865>
                ctx->esc_values[0] = ctx->cols - 1;
ffffffff8000481f:	83 ea 01             	sub    $0x1,%edx
ffffffff80004822:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, ctx->esc_values[0], y);
ffffffff80004825:	8b 73 78             	mov    0x78(%rbx),%esi
ffffffff80004828:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000482d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004830:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004836:	e9 23 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->esc_values[0] > x)
ffffffff8000483b:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff80004840:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004843:	48 39 d0             	cmp    %rdx,%rax
ffffffff80004846:	73 05                	jae    ffffffff8000484d <flanterm_write+0x188d>
                ctx->esc_values[0] = x;
ffffffff80004848:	89 43 78             	mov    %eax,0x78(%rbx)
ffffffff8000484b:	89 c2                	mov    %eax,%edx
            ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y);
ffffffff8000484d:	48 29 d0             	sub    %rdx,%rax
ffffffff80004850:	48 89 df             	mov    %rbx,%rdi
ffffffff80004853:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80004858:	48 89 c6             	mov    %rax,%rsi
ffffffff8000485b:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004861:	e9 f8 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->dec_private == true) {
ffffffff80004866:	40 84 f6             	test   %sil,%sil
ffffffff80004869:	0f 84 63 f6 ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff8000486f:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
ffffffff80004873:	e9 ea f6 ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
            switch (ctx->esc_values[0]) {
ffffffff80004878:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff8000487b:	83 f8 05             	cmp    $0x5,%eax
ffffffff8000487e:	74 53                	je     ffffffff800048d3 <flanterm_write+0x1913>
ffffffff80004880:	83 f8 06             	cmp    $0x6,%eax
ffffffff80004883:	0f 85 d5 f6 ff ff    	jne    ffffffff80003f5e <flanterm_write+0xf9e>
                    if (ctx->callback != NULL) {
ffffffff80004889:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004890:	48 85 c0             	test   %rax,%rax
ffffffff80004893:	0f 84 c5 f6 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                        ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0);
ffffffff80004899:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
ffffffff8000489e:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800048a3:	45 31 c0             	xor    %r8d,%r8d
ffffffff800048a6:	be 32 00 00 00       	mov    $0x32,%esi
ffffffff800048ab:	48 8d 57 01          	lea    0x1(%rdi),%rdx
ffffffff800048af:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800048b3:	48 89 df             	mov    %rbx,%rdi
ffffffff800048b6:	ff d0                	call   *%rax
ffffffff800048b8:	e9 a1 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y);
ffffffff800048bd:	48 8b 53 50          	mov    0x50(%rbx),%rdx
ffffffff800048c1:	48 8b 73 48          	mov    0x48(%rbx),%rsi
ffffffff800048c5:	48 89 df             	mov    %rbx,%rdi
ffffffff800048c8:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff800048ce:	e9 8b f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    if (ctx->callback != NULL) {
ffffffff800048d3:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800048da:	48 85 c0             	test   %rax,%rax
ffffffff800048dd:	0f 84 7b f6 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                        ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0);
ffffffff800048e3:	45 31 c0             	xor    %r8d,%r8d
ffffffff800048e6:	31 c9                	xor    %ecx,%ecx
ffffffff800048e8:	31 d2                	xor    %edx,%edx
ffffffff800048ea:	be 28 00 00 00       	mov    $0x28,%esi
ffffffff800048ef:	48 89 df             	mov    %rbx,%rdi
ffffffff800048f2:	ff d0                	call   *%rax
ffffffff800048f4:	e9 65 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y);
ffffffff800048f9:	48 8d 53 50          	lea    0x50(%rbx),%rdx
ffffffff800048fd:	48 8d 73 48          	lea    0x48(%rbx),%rsi
ffffffff80004901:	48 89 df             	mov    %rbx,%rdi
ffffffff80004904:	ff 93 08 01 00 00    	call   *0x108(%rbx)
            break;
ffffffff8000490a:	e9 4f f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->esc_values[0] == 0) {
ffffffff8000490f:	83 7b 78 00          	cmpl   $0x0,0x78(%rbx)
ffffffff80004913:	75 07                	jne    ffffffff8000491c <flanterm_write+0x195c>
                ctx->esc_values[0] = 1;
ffffffff80004915:	c7 43 78 01 00 00 00 	movl   $0x1,0x78(%rbx)
            if (ctx->esc_values[1] == 0) {
ffffffff8000491c:	83 7b 7c 00          	cmpl   $0x0,0x7c(%rbx)
ffffffff80004920:	75 07                	jne    ffffffff80004929 <flanterm_write+0x1969>
                ctx->esc_values[1] = 1;
ffffffff80004922:	c7 43 7c 01 00 00 00 	movl   $0x1,0x7c(%rbx)
            ctx->scroll_bottom_margin = ctx->rows;
ffffffff80004929:	48 8b 93 e0 00 00 00 	mov    0xe0(%rbx),%rdx
            if (ctx->esc_values_i > 0) {
ffffffff80004930:	48 8b 43 40          	mov    0x40(%rbx),%rax
            ctx->scroll_top_margin = 0;
ffffffff80004934:	31 f6                	xor    %esi,%esi
ffffffff80004936:	48 89 73 68          	mov    %rsi,0x68(%rbx)
            ctx->scroll_bottom_margin = ctx->rows;
ffffffff8000493a:	48 89 53 70          	mov    %rdx,0x70(%rbx)
            if (ctx->esc_values_i > 0) {
ffffffff8000493e:	48 85 c0             	test   %rax,%rax
ffffffff80004941:	74 3d                	je     ffffffff80004980 <flanterm_write+0x19c0>
                ctx->scroll_top_margin = ctx->esc_values[0] - 1;
ffffffff80004943:	8b 4b 78             	mov    0x78(%rbx),%ecx
ffffffff80004946:	83 e9 01             	sub    $0x1,%ecx
            if (ctx->esc_values_i > 1) {
ffffffff80004949:	48 83 e8 01          	sub    $0x1,%rax
                ctx->scroll_top_margin = ctx->esc_values[0] - 1;
ffffffff8000494d:	48 89 4b 68          	mov    %rcx,0x68(%rbx)
            if (ctx->esc_values_i > 1) {
ffffffff80004951:	74 2d                	je     ffffffff80004980 <flanterm_write+0x19c0>
                ctx->scroll_bottom_margin = ctx->esc_values[1];
ffffffff80004953:	8b 43 7c             	mov    0x7c(%rbx),%eax
ffffffff80004956:	48 89 43 70          	mov    %rax,0x70(%rbx)
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff8000495a:	48 39 d1             	cmp    %rdx,%rcx
ffffffff8000495d:	73 05                	jae    ffffffff80004964 <flanterm_write+0x19a4>
             || ctx->scroll_bottom_margin > ctx->rows
ffffffff8000495f:	48 39 c2             	cmp    %rax,%rdx
ffffffff80004962:	73 28                	jae    ffffffff8000498c <flanterm_write+0x19cc>
                ctx->scroll_top_margin = 0;
ffffffff80004964:	31 c9                	xor    %ecx,%ecx
                ctx->scroll_bottom_margin = ctx->rows;
ffffffff80004966:	48 89 53 70          	mov    %rdx,0x70(%rbx)
                ctx->scroll_top_margin = 0;
ffffffff8000496a:	48 89 4b 68          	mov    %rcx,0x68(%rbx)
            ctx->set_cursor_pos(ctx, 0, 0);
ffffffff8000496e:	31 d2                	xor    %edx,%edx
ffffffff80004970:	31 f6                	xor    %esi,%esi
ffffffff80004972:	48 89 df             	mov    %rbx,%rdi
ffffffff80004975:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff8000497b:	e9 de f5 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff80004980:	48 8b 4b 68          	mov    0x68(%rbx),%rcx
             || ctx->scroll_bottom_margin > ctx->rows
ffffffff80004984:	48 89 d0             	mov    %rdx,%rax
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff80004987:	48 39 d1             	cmp    %rdx,%rcx
ffffffff8000498a:	73 d8                	jae    ffffffff80004964 <flanterm_write+0x19a4>
             || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) {
ffffffff8000498c:	48 83 e8 01          	sub    $0x1,%rax
ffffffff80004990:	48 39 c1             	cmp    %rax,%rcx
ffffffff80004993:	73 cf                	jae    ffffffff80004964 <flanterm_write+0x19a4>
ffffffff80004995:	eb d7                	jmp    ffffffff8000496e <flanterm_write+0x19ae>
    if (!ctx->esc_values_i)
ffffffff80004997:	4c 8b 63 40          	mov    0x40(%rbx),%r12
ffffffff8000499b:	4d 85 e4             	test   %r12,%r12
ffffffff8000499e:	0f 84 c8 00 00 00    	je     ffffffff80004a6c <flanterm_write+0x1aac>
    for (; i < ctx->esc_values_i; i++) {
ffffffff800049a4:	4c 89 e6             	mov    %r12,%rsi
    size_t i = 0;
ffffffff800049a7:	45 31 e4             	xor    %r12d,%r12d
        if (ctx->esc_values[i] == 0) {
ffffffff800049aa:	4a 8d 0c a3          	lea    (%rbx,%r12,4),%rcx
ffffffff800049ae:	8b 51 78             	mov    0x78(%rcx),%edx
ffffffff800049b1:	83 fa 6b             	cmp    $0x6b,%edx
ffffffff800049b4:	77 71                	ja     ffffffff80004a27 <flanterm_write+0x1a67>
ffffffff800049b6:	89 d0                	mov    %edx,%eax
ffffffff800049b8:	3e ff 24 c5 e8 ad 00 	notrack jmp *-0x7fff5218(,%rax,8)
ffffffff800049bf:	80 
    if (ctx->esc_values_i == 0) {
ffffffff800049c0:	48 8b 53 40          	mov    0x40(%rbx),%rdx
ffffffff800049c4:	48 85 d2             	test   %rdx,%rdx
ffffffff800049c7:	0f 84 91 f5 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
    switch (c) {
ffffffff800049cd:	41 80 fc 68          	cmp    $0x68,%r12b
ffffffff800049d1:	0f 94 c0             	sete   %al
    switch (ctx->esc_values[0]) {
ffffffff800049d4:	83 7b 78 04          	cmpl   $0x4,0x78(%rbx)
ffffffff800049d8:	0f 84 86 00 00 00    	je     ffffffff80004a64 <flanterm_write+0x1aa4>
    if (ctx->callback != NULL) {
ffffffff800049de:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800049e5:	48 85 c0             	test   %rax,%rax
ffffffff800049e8:	0f 84 70 f5 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
        ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);
ffffffff800049ee:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff800049f2:	4d 0f be c4          	movsbq %r12b,%r8
ffffffff800049f6:	be 46 00 00 00       	mov    $0x46,%esi
ffffffff800049fb:	48 89 df             	mov    %rbx,%rdi
ffffffff800049fe:	ff d0                	call   *%rax
ffffffff80004a00:	e9 59 f5 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004a05:	48 8d 50 9c          	lea    -0x64(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004a09:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004a0d:	48 89 53 60          	mov    %rdx,0x60(%rbx)
            offset = 100;
ffffffff80004a11:	ba 64 00 00 00       	mov    $0x64,%edx
            if (ctx->reverse_video) {
ffffffff80004a16:	75 3b                	jne    ffffffff80004a53 <flanterm_write+0x1a93>
            ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);
ffffffff80004a18:	48 29 d0             	sub    %rdx,%rax
ffffffff80004a1b:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a1e:	48 89 c6             	mov    %rax,%rsi
ffffffff80004a21:	ff 93 28 01 00 00    	call   *0x128(%rbx)
            continue;
ffffffff80004a27:	4d 89 e7             	mov    %r12,%r15
    for (; i < ctx->esc_values_i; i++) {
ffffffff80004a2a:	48 8b 73 40          	mov    0x40(%rbx),%rsi
ffffffff80004a2e:	4d 8d 67 01          	lea    0x1(%r15),%r12
ffffffff80004a32:	49 39 f4             	cmp    %rsi,%r12
ffffffff80004a35:	0f 83 23 f5 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff80004a3b:	e9 6a ff ff ff       	jmp    ffffffff800049aa <flanterm_write+0x19ea>
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004a40:	48 8d 50 a6          	lea    -0x5a(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004a44:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004a48:	48 89 53 58          	mov    %rdx,0x58(%rbx)
            offset = 90;
ffffffff80004a4c:	ba 5a 00 00 00       	mov    $0x5a,%edx
            if (ctx->reverse_video) {
ffffffff80004a51:	75 c5                	jne    ffffffff80004a18 <flanterm_write+0x1a58>
            ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);
ffffffff80004a53:	48 29 d0             	sub    %rdx,%rax
ffffffff80004a56:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a59:	48 89 c6             	mov    %rax,%rsi
ffffffff80004a5c:	ff 93 20 01 00 00    	call   *0x120(%rbx)
            continue;
ffffffff80004a62:	eb c3                	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            ctx->insert_mode = set; return;
ffffffff80004a64:	88 43 15             	mov    %al,0x15(%rbx)
ffffffff80004a67:	e9 f2 f4 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->reverse_video) {
ffffffff80004a6c:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004a70:	74 0d                	je     ffffffff80004a7f <flanterm_write+0x1abf>
                ctx->reverse_video = false;
ffffffff80004a72:	c6 43 13 00          	movb   $0x0,0x13(%rbx)
                ctx->swap_palette(ctx);
ffffffff80004a76:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a79:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            ctx->set_text_bg_default(ctx);
ffffffff80004a7f:	48 89 df             	mov    %rbx,%rdi
            ctx->bold = false;
ffffffff80004a82:	66 c7 43 11 00 00    	movw   $0x0,0x11(%rbx)
            continue;
ffffffff80004a88:	4d 89 e7             	mov    %r12,%r15
            ctx->current_primary = (size_t)-1;
ffffffff80004a8b:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80004a92:	ff 
            ctx->current_bg = (size_t)-1;
ffffffff80004a93:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80004a9a:	ff 
            ctx->set_text_bg_default(ctx);
ffffffff80004a9b:	ff 93 48 01 00 00    	call   *0x148(%rbx)
            ctx->set_text_fg_default(ctx);
ffffffff80004aa1:	48 89 df             	mov    %rbx,%rdi
ffffffff80004aa4:	ff 93 40 01 00 00    	call   *0x140(%rbx)
            continue;
ffffffff80004aaa:	e9 7b ff ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            ctx->esc_values[0] -= 1;
ffffffff80004aaf:	8b 43 78             	mov    0x78(%rbx),%eax
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff80004ab2:	48 8b 93 e0 00 00 00 	mov    0xe0(%rbx),%rdx
            ctx->esc_values[0] -= 1;
ffffffff80004ab9:	83 e8 01             	sub    $0x1,%eax
ffffffff80004abc:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff80004abf:	48 39 d0             	cmp    %rdx,%rax
ffffffff80004ac2:	72 06                	jb     ffffffff80004aca <flanterm_write+0x1b0a>
                ctx->esc_values[0] = ctx->rows - 1;
ffffffff80004ac4:	83 ea 01             	sub    $0x1,%edx
ffffffff80004ac7:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);
ffffffff80004aca:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004acd:	e9 7e f4 ff ff       	jmp    ffffffff80003f50 <flanterm_write+0xf90>
            if (ctx->callback != NULL) {
ffffffff80004ad2:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004ad9:	48 85 c0             	test   %rax,%rax
ffffffff80004adc:	0f 84 7c f4 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);
ffffffff80004ae2:	45 31 c0             	xor    %r8d,%r8d
ffffffff80004ae5:	31 c9                	xor    %ecx,%ecx
ffffffff80004ae7:	31 d2                	xor    %edx,%edx
ffffffff80004ae9:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80004aee:	48 89 df             	mov    %rbx,%rdi
ffffffff80004af1:	ff d0                	call   *%rax
ffffffff80004af3:	e9 66 f4 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->reverse_video) {
ffffffff80004af8:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = (size_t)-1;
ffffffff80004afc:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80004b03:	ff 
            if (ctx->reverse_video) {
ffffffff80004b04:	74 09                	je     ffffffff80004b0f <flanterm_write+0x1b4f>
                ctx->swap_palette(ctx);
ffffffff80004b06:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b09:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            if (!ctx->bg_bold) {
ffffffff80004b0f:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
                ctx->set_text_bg_default(ctx);
ffffffff80004b13:	48 89 df             	mov    %rbx,%rdi
            if (!ctx->bg_bold) {
ffffffff80004b16:	75 77                	jne    ffffffff80004b8f <flanterm_write+0x1bcf>
                ctx->set_text_bg_default(ctx);
ffffffff80004b18:	ff 93 48 01 00 00    	call   *0x148(%rbx)
            if (ctx->reverse_video) {
ffffffff80004b1e:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004b22:	0f 84 ff fe ff ff    	je     ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->swap_palette(ctx);
ffffffff80004b28:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b2b:	ff 93 78 01 00 00    	call   *0x178(%rbx)
ffffffff80004b31:	e9 f1 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004b36:	48 8d 50 d8          	lea    -0x28(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004b3a:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004b3e:	48 89 53 60          	mov    %rdx,0x60(%rbx)
            if (ctx->reverse_video) {
ffffffff80004b42:	75 53                	jne    ffffffff80004b97 <flanterm_write+0x1bd7>
             || (ctx->bg_bold && !ctx->reverse_video)) {
ffffffff80004b44:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
ffffffff80004b48:	ba 28 00 00 00       	mov    $0x28,%edx
ffffffff80004b4d:	0f 85 c5 fe ff ff    	jne    ffffffff80004a18 <flanterm_write+0x1a58>
                ctx->set_text_bg(ctx, ctx->esc_values[i] - offset);
ffffffff80004b53:	48 29 d0             	sub    %rdx,%rax
ffffffff80004b56:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b59:	48 89 c6             	mov    %rax,%rsi
ffffffff80004b5c:	ff 93 18 01 00 00    	call   *0x118(%rbx)
ffffffff80004b62:	e9 c0 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            if (ctx->reverse_video) {
ffffffff80004b67:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_primary = (size_t)-1;
ffffffff80004b6b:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80004b72:	ff 
            if (ctx->reverse_video) {
ffffffff80004b73:	74 09                	je     ffffffff80004b7e <flanterm_write+0x1bbe>
                ctx->swap_palette(ctx);
ffffffff80004b75:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b78:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            if (!ctx->bold) {
ffffffff80004b7e:	80 7b 11 00          	cmpb   $0x0,0x11(%rbx)
                ctx->set_text_fg_default(ctx);
ffffffff80004b82:	48 89 df             	mov    %rbx,%rdi
            if (!ctx->bold) {
ffffffff80004b85:	75 33                	jne    ffffffff80004bba <flanterm_write+0x1bfa>
                ctx->set_text_fg_default(ctx);
ffffffff80004b87:	ff 93 40 01 00 00    	call   *0x140(%rbx)
ffffffff80004b8d:	eb 8f                	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
                ctx->set_text_bg_default_bright(ctx);
ffffffff80004b8f:	ff 93 58 01 00 00    	call   *0x158(%rbx)
ffffffff80004b95:	eb 87                	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
             || (ctx->bg_bold && ctx->reverse_video)) {
ffffffff80004b97:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
ffffffff80004b9b:	ba 28 00 00 00       	mov    $0x28,%edx
ffffffff80004ba0:	0f 85 ad fe ff ff    	jne    ffffffff80004a53 <flanterm_write+0x1a93>
                ctx->set_text_fg(ctx, ctx->esc_values[i] - offset);
ffffffff80004ba6:	48 29 d0             	sub    %rdx,%rax
ffffffff80004ba9:	48 89 df             	mov    %rbx,%rdi
ffffffff80004bac:	48 89 c6             	mov    %rax,%rsi
ffffffff80004baf:	ff 93 10 01 00 00    	call   *0x110(%rbx)
ffffffff80004bb5:	e9 6d fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->set_text_fg_default_bright(ctx);
ffffffff80004bba:	ff 93 50 01 00 00    	call   *0x150(%rbx)
            if (ctx->reverse_video) {
ffffffff80004bc0:	e9 59 ff ff ff       	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004bc5:	48 8b 73 58          	mov    0x58(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004bc9:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bold = false;
ffffffff80004bcd:	c6 43 11 00          	movb   $0x0,0x11(%rbx)
                    ctx->set_text_fg(ctx, ctx->current_primary);
ffffffff80004bd1:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004bd4:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004bd8:	74 26                	je     ffffffff80004c00 <flanterm_write+0x1c40>
                if (!ctx->reverse_video) {
ffffffff80004bda:	84 c0                	test   %al,%al
ffffffff80004bdc:	0f 85 7a ff ff ff    	jne    ffffffff80004b5c <flanterm_write+0x1b9c>
ffffffff80004be2:	eb cb                	jmp    ffffffff80004baf <flanterm_write+0x1bef>
            if (!ctx->reverse_video) {
ffffffff80004be4:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004be8:	0f 85 39 fe ff ff    	jne    ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->reverse_video = true;
ffffffff80004bee:	c6 43 13 01          	movb   $0x1,0x13(%rbx)
                ctx->swap_palette(ctx);
ffffffff80004bf2:	48 89 df             	mov    %rbx,%rdi
ffffffff80004bf5:	ff 93 78 01 00 00    	call   *0x178(%rbx)
ffffffff80004bfb:	e9 27 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c00:	84 c0                	test   %al,%al
ffffffff80004c02:	75 53                	jne    ffffffff80004c57 <flanterm_write+0x1c97>
                    ctx->set_text_fg_default(ctx);
ffffffff80004c04:	ff 93 40 01 00 00    	call   *0x140(%rbx)
ffffffff80004c0a:	e9 18 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004c0f:	48 8b 73 60          	mov    0x60(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004c13:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bg_bold = true;
ffffffff80004c17:	c6 43 12 01          	movb   $0x1,0x12(%rbx)
                    ctx->set_text_bg_bright(ctx, ctx->current_bg);
ffffffff80004c1b:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004c1e:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004c22:	74 3e                	je     ffffffff80004c62 <flanterm_write+0x1ca2>
                if (!ctx->reverse_video) {
ffffffff80004c24:	84 c0                	test   %al,%al
ffffffff80004c26:	0f 85 30 fe ff ff    	jne    ffffffff80004a5c <flanterm_write+0x1a9c>
ffffffff80004c2c:	e9 f0 fd ff ff       	jmp    ffffffff80004a21 <flanterm_write+0x1a61>
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004c31:	48 8b 73 58          	mov    0x58(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004c35:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bold = true;
ffffffff80004c39:	c6 43 11 01          	movb   $0x1,0x11(%rbx)
                    ctx->set_text_fg_bright(ctx, ctx->current_primary);
ffffffff80004c3d:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004c40:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004c44:	74 2b                	je     ffffffff80004c71 <flanterm_write+0x1cb1>
                if (!ctx->reverse_video) {
ffffffff80004c46:	84 c0                	test   %al,%al
ffffffff80004c48:	0f 85 d3 fd ff ff    	jne    ffffffff80004a21 <flanterm_write+0x1a61>
ffffffff80004c4e:	e9 09 fe ff ff       	jmp    ffffffff80004a5c <flanterm_write+0x1a9c>
                if (!ctx->reverse_video) {
ffffffff80004c53:	84 c0                	test   %al,%al
ffffffff80004c55:	75 ad                	jne    ffffffff80004c04 <flanterm_write+0x1c44>
                    ctx->set_text_bg_default(ctx);
ffffffff80004c57:	ff 93 48 01 00 00    	call   *0x148(%rbx)
ffffffff80004c5d:	e9 c5 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c62:	84 c0                	test   %al,%al
ffffffff80004c64:	75 0f                	jne    ffffffff80004c75 <flanterm_write+0x1cb5>
                    ctx->set_text_bg_default_bright(ctx);
ffffffff80004c66:	ff 93 58 01 00 00    	call   *0x158(%rbx)
ffffffff80004c6c:	e9 b6 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c71:	84 c0                	test   %al,%al
ffffffff80004c73:	75 f1                	jne    ffffffff80004c66 <flanterm_write+0x1ca6>
                    ctx->set_text_fg_default_bright(ctx);
ffffffff80004c75:	ff 93 50 01 00 00    	call   *0x150(%rbx)
ffffffff80004c7b:	e9 a7 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            i++;
ffffffff80004c80:	4d 8d 7c 24 01       	lea    0x1(%r12),%r15
            if (i >= ctx->esc_values_i) {
ffffffff80004c85:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004c88:	0f 83 d0 f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[i]) {
ffffffff80004c8e:	8b 41 7c             	mov    0x7c(%rcx),%eax
ffffffff80004c91:	83 f8 02             	cmp    $0x2,%eax
ffffffff80004c94:	0f 84 a3 00 00 00    	je     ffffffff80004d3d <flanterm_write+0x1d7d>
ffffffff80004c9a:	83 f8 05             	cmp    $0x5,%eax
ffffffff80004c9d:	0f 85 87 fd ff ff    	jne    ffffffff80004a2a <flanterm_write+0x1a6a>
                    if (i + 1 >= ctx->esc_values_i) {
ffffffff80004ca3:	4d 8d 7c 24 02       	lea    0x2(%r12),%r15
ffffffff80004ca8:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004cab:	0f 83 ad f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                    uint32_t col = ctx->esc_values[i + 1];
ffffffff80004cb1:	8b 81 80 00 00 00    	mov    0x80(%rcx),%eax
                    if (col < 8) {
ffffffff80004cb7:	83 f8 07             	cmp    $0x7,%eax
ffffffff80004cba:	77 46                	ja     ffffffff80004d02 <flanterm_write+0x1d42>
                        (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col);
ffffffff80004cbc:	48 8b 8b 18 01 00 00 	mov    0x118(%rbx),%rcx
ffffffff80004cc3:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004cc6:	89 c6                	mov    %eax,%esi
ffffffff80004cc8:	48 89 df             	mov    %rbx,%rdi
ffffffff80004ccb:	48 0f 44 8b 10 01 00 	cmove  0x110(%rbx),%rcx
ffffffff80004cd2:	00 
ffffffff80004cd3:	ff d1                	call   *%rcx
ffffffff80004cd5:	e9 50 fd ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004cda:	48 8d 50 e2          	lea    -0x1e(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004cde:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            if ((ctx->bold && ctx->reverse_video)
ffffffff80004ce2:	0f b6 4b 11          	movzbl 0x11(%rbx),%ecx
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004ce6:	48 89 53 58          	mov    %rdx,0x58(%rbx)
            if (ctx->reverse_video) {
ffffffff80004cea:	0f 85 91 00 00 00    	jne    ffffffff80004d81 <flanterm_write+0x1dc1>
            offset = 30;
ffffffff80004cf0:	ba 1e 00 00 00       	mov    $0x1e,%edx
            if ((ctx->bold && !ctx->reverse_video)
ffffffff80004cf5:	84 c9                	test   %cl,%cl
ffffffff80004cf7:	0f 84 a9 fe ff ff    	je     ffffffff80004ba6 <flanterm_write+0x1be6>
ffffffff80004cfd:	e9 51 fd ff ff       	jmp    ffffffff80004a53 <flanterm_write+0x1a93>
                    } else if (col < 16) {
ffffffff80004d02:	83 f8 0f             	cmp    $0xf,%eax
ffffffff80004d05:	0f 87 ae 00 00 00    	ja     ffffffff80004db9 <flanterm_write+0x1df9>
                        (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8);
ffffffff80004d0b:	48 8b 8b 28 01 00 00 	mov    0x128(%rbx),%rcx
ffffffff80004d12:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004d15:	8d 70 f8             	lea    -0x8(%rax),%esi
ffffffff80004d18:	48 89 df             	mov    %rbx,%rdi
ffffffff80004d1b:	48 0f 44 8b 20 01 00 	cmove  0x120(%rbx),%rcx
ffffffff80004d22:	00 
ffffffff80004d23:	ff d1                	call   *%rcx
ffffffff80004d25:	e9 00 fd ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            if (ctx->reverse_video) {
ffffffff80004d2a:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004d2e:	0f 84 f3 fc ff ff    	je     ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->reverse_video = false;
ffffffff80004d34:	c6 43 13 00          	movb   $0x0,0x13(%rbx)
ffffffff80004d38:	e9 eb fd ff ff       	jmp    ffffffff80004b28 <flanterm_write+0x1b68>
                    if (i + 3 >= ctx->esc_values_i) {
ffffffff80004d3d:	4d 8d 7c 24 04       	lea    0x4(%r12),%r15
ffffffff80004d42:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004d45:	0f 83 13 f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                    rgb_value |= ctx->esc_values[i + 1] << 16;
ffffffff80004d4b:	8b b1 80 00 00 00    	mov    0x80(%rcx),%esi
                    rgb_value |= ctx->esc_values[i + 2] << 8;
ffffffff80004d51:	8b 81 84 00 00 00    	mov    0x84(%rcx),%eax
                    rgb_value |= ctx->esc_values[i + 1] << 16;
ffffffff80004d57:	c1 e6 10             	shl    $0x10,%esi
                    rgb_value |= ctx->esc_values[i + 2] << 8;
ffffffff80004d5a:	c1 e0 08             	shl    $0x8,%eax
ffffffff80004d5d:	09 c6                	or     %eax,%esi
                    rgb_value |= ctx->esc_values[i + 3];
ffffffff80004d5f:	0b b1 88 00 00 00    	or     0x88(%rcx),%esi
                        (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);
ffffffff80004d65:	48 8b 83 38 01 00 00 	mov    0x138(%rbx),%rax
ffffffff80004d6c:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004d6f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004d72:	48 0f 44 83 30 01 00 	cmove  0x130(%rbx),%rax
ffffffff80004d79:	00 
ffffffff80004d7a:	ff d0                	call   *%rax
ffffffff80004d7c:	e9 a9 fc ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            offset = 30;
ffffffff80004d81:	ba 1e 00 00 00       	mov    $0x1e,%edx
            if ((ctx->bold && ctx->reverse_video)
ffffffff80004d86:	84 c9                	test   %cl,%cl
ffffffff80004d88:	0f 85 8a fc ff ff    	jne    ffffffff80004a18 <flanterm_write+0x1a58>
ffffffff80004d8e:	e9 c0 fd ff ff       	jmp    ffffffff80004b53 <flanterm_write+0x1b93>
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004d93:	48 8b 73 60          	mov    0x60(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004d97:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bg_bold = false;
ffffffff80004d9b:	c6 43 12 00          	movb   $0x0,0x12(%rbx)
                    ctx->set_text_bg(ctx, ctx->current_bg);
ffffffff80004d9f:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004da2:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004da6:	0f 84 a7 fe ff ff    	je     ffffffff80004c53 <flanterm_write+0x1c93>
                if (!ctx->reverse_video) {
ffffffff80004dac:	84 c0                	test   %al,%al
ffffffff80004dae:	0f 85 fb fd ff ff    	jne    ffffffff80004baf <flanterm_write+0x1bef>
ffffffff80004db4:	e9 a3 fd ff ff       	jmp    ffffffff80004b5c <flanterm_write+0x1b9c>
                    } else if (col < 256) {
ffffffff80004db9:	3d ff 00 00 00       	cmp    $0xff,%eax
ffffffff80004dbe:	0f 87 66 fc ff ff    	ja     ffffffff80004a2a <flanterm_write+0x1a6a>
                        uint32_t rgb_value = col256[col - 16];
ffffffff80004dc4:	83 e8 10             	sub    $0x10,%eax
ffffffff80004dc7:	8b 34 85 e0 b5 00 80 	mov    -0x7fff4a20(,%rax,4),%esi
ffffffff80004dce:	eb 95                	jmp    ffffffff80004d65 <flanterm_write+0x1da5>

ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>:
ffffffff80004dd0:	f3 0f 1e fa          	endbr64
ffffffff80004dd4:	55                   	push   %rbp
ffffffff80004dd5:	48 89 f5             	mov    %rsi,%rbp
ffffffff80004dd8:	53                   	push   %rbx
ffffffff80004dd9:	48 89 fb             	mov    %rdi,%rbx
        #if defined (__x86_64__)
ffffffff80004ddc:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80004de3:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004de7:	e8 b4 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004dec:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004def:	e8 ac 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004df4:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff80004dfb:	e8 a0 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004e00:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004e04:	48 89 d8             	mov    %rbx,%rax
ffffffff80004e07:	5b                   	pop    %rbx
ffffffff80004e08:	5d                   	pop    %rbp
ffffffff80004e09:	c3                   	ret
ffffffff80004e0a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>:
ffffffff80004e10:	f3 0f 1e fa          	endbr64
ffffffff80004e14:	55                   	push   %rbp
ffffffff80004e15:	48 89 fd             	mov    %rdi,%rbp
        #if defined (__x86_64__)
ffffffff80004e18:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80004e1f:	53                   	push   %rbx
ffffffff80004e20:	89 f3                	mov    %esi,%ebx
ffffffff80004e22:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004e26:	e8 75 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004e2b:	8b 35 c7 72 00 00    	mov    0x72c7(%rip),%esi        # ffffffff8000c0f8 <kout>
ffffffff80004e31:	0f b6 fb             	movzbl %bl,%edi
ffffffff80004e34:	e8 67 1a 00 00       	call   ffffffff800068a0 <_ZN3Lib11int2basestrEim>
ffffffff80004e39:	48 89 c7             	mov    %rax,%rdi
ffffffff80004e3c:	e8 5f 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        #if defined (__x86_64__)
ffffffff80004e41:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff80004e48:	e8 53 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004e4d:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004e51:	48 89 e8             	mov    %rbp,%rax
ffffffff80004e54:	5b                   	pop    %rbx
ffffffff80004e55:	5d                   	pop    %rbp
ffffffff80004e56:	c3                   	ret
ffffffff80004e57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80004e5e:	00 00 

ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>:
ffffffff80004e60:	f3 0f 1e fa          	endbr64
ffffffff80004e64:	55                   	push   %rbp
ffffffff80004e65:	48 89 f5             	mov    %rsi,%rbp
ffffffff80004e68:	53                   	push   %rbx
ffffffff80004e69:	48 89 fb             	mov    %rdi,%rbx
        #if defined (__x86_64__)
ffffffff80004e6c:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80004e73:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004e77:	e8 24 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004e7c:	8b 35 76 72 00 00    	mov    0x7276(%rip),%esi        # ffffffff8000c0f8 <kout>
ffffffff80004e82:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004e85:	e8 26 1b 00 00       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80004e8a:	48 89 c7             	mov    %rax,%rdi
ffffffff80004e8d:	e8 0e 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        #if defined (__x86_64__)
ffffffff80004e92:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff80004e99:	e8 02 21 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004e9e:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004ea2:	48 89 d8             	mov    %rbx,%rax
ffffffff80004ea5:	5b                   	pop    %rbx
ffffffff80004ea6:	5d                   	pop    %rbp
ffffffff80004ea7:	c3                   	ret
ffffffff80004ea8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80004eaf:	00 

ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>:
void Panic(const char *meditationString, System::PanicFrame* frame) {
ffffffff80004eb0:	f3 0f 1e fa          	endbr64
ffffffff80004eb4:	41 54                	push   %r12
ffffffff80004eb6:	55                   	push   %rbp
ffffffff80004eb7:	48 89 fd             	mov    %rdi,%rbp
    kerr << "\nGuru Meditation" << "\n" << "\n";
ffffffff80004eba:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
void Panic(const char *meditationString, System::PanicFrame* frame) {
ffffffff80004ec1:	53                   	push   %rbx
ffffffff80004ec2:	48 89 f3             	mov    %rsi,%rbx
    kerr << "\nGuru Meditation" << "\n" << "\n";
ffffffff80004ec5:	48 c7 c6 af b9 00 80 	mov    $0xffffffff8000b9af,%rsi
ffffffff80004ecc:	e8 ff fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ed1:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80004ed8:	48 89 c7             	mov    %rax,%rdi
ffffffff80004edb:	e8 f0 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ee0:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80004ee7:	48 89 c7             	mov    %rax,%rdi
ffffffff80004eea:	e8 e1 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
    kerr << "\t" << "MeditationString: " << meditationString << Kt::newline;
ffffffff80004eef:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80004ef6:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80004efd:	e8 ce fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f02:	48 c7 c6 c4 b9 00 80 	mov    $0xffffffff8000b9c4,%rsi
ffffffff80004f09:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f0c:	e8 bf fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f11:	48 89 ee             	mov    %rbp,%rsi
ffffffff80004f14:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f17:	e8 b4 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        base streamBaseType = base::dec;

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char *string)
        {
            Print(string);
ffffffff80004f1c:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80004f23:	e8 78 20 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        }

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char chr)
        {
            Putchar(chr);
ffffffff80004f28:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80004f2d:	e8 3e 20 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
            Print(string);
ffffffff80004f32:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff80004f39:	e8 62 20 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
    if (frame != nullptr) {
ffffffff80004f3e:	48 85 db             	test   %rbx,%rbx
ffffffff80004f41:	0f 84 b9 02 00 00    	je     ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350>
        kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n";
ffffffff80004f47:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80004f4e:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80004f55:	e8 76 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f5a:	48 c7 c6 d7 b9 00 80 	mov    $0xffffffff8000b9d7,%rsi
ffffffff80004f61:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f64:	e8 67 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f69:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff80004f70:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f73:	e8 58 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f78:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80004f7f:	48 89 c5             	mov    %rax,%rbp
ffffffff80004f82:	e8 19 20 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004f87:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, base newBase)
        {
            t.streamBaseType = newBase;
ffffffff80004f8e:	c7 05 60 71 00 00 10 	movl   $0x10,0x7160(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80004f95:	00 00 00 
            Print(string);
ffffffff80004f98:	e8 03 20 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80004f9d:	0f b6 73 28          	movzbl 0x28(%rbx),%esi
ffffffff80004fa1:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004fa4:	e8 67 fe ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80004fa9:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80004fb0:	48 89 c7             	mov    %rax,%rdi
ffffffff80004fb3:	e8 18 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame
ffffffff80004fb8:	0f b6 43 28          	movzbl 0x28(%rbx),%eax
ffffffff80004fbc:	3c 0e                	cmp    $0xe,%al
ffffffff80004fbe:	0f 84 40 02 00 00    	je     ffffffff80005204 <_Z5PanicPKcPN6System10PanicFrameE+0x354>
        else if (frame->InterruptVector == 0xD) {
ffffffff80004fc4:	3c 0d                	cmp    $0xd,%al
ffffffff80004fc6:	0f 84 7f 05 00 00    	je     ffffffff8000554b <_Z5PanicPKcPN6System10PanicFrameE+0x69b>
        kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n";
ffffffff80004fcc:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80004fd3:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80004fda:	e8 f1 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004fdf:	48 c7 c6 9d ba 00 80 	mov    $0xffffffff8000ba9d,%rsi
ffffffff80004fe6:	48 89 c7             	mov    %rax,%rdi
ffffffff80004fe9:	e8 e2 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004fee:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff80004ff5:	48 89 c7             	mov    %rax,%rdi
ffffffff80004ff8:	e8 d3 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ffd:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005004:	48 89 c5             	mov    %rax,%rbp
ffffffff80005007:	e8 94 1f 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000500c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005013:	c7 05 db 70 00 00 10 	movl   $0x10,0x70db(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000501a:	00 00 00 
            Print(string);
ffffffff8000501d:	e8 7e 1f 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005022:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005025:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005028:	e8 33 fe ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000502d:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005034:	48 89 c7             	mov    %rax,%rdi
ffffffff80005037:	e8 94 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "CodeSegment: " << "0x" << base::hex << frame->CS << "\n";
ffffffff8000503c:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005043:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff8000504a:	e8 81 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000504f:	48 c7 c6 b2 ba 00 80 	mov    $0xffffffff8000bab2,%rsi
ffffffff80005056:	48 89 c7             	mov    %rax,%rdi
ffffffff80005059:	e8 72 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000505e:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff80005065:	48 89 c7             	mov    %rax,%rdi
ffffffff80005068:	e8 63 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000506d:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005074:	48 89 c5             	mov    %rax,%rbp
ffffffff80005077:	e8 24 1f 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000507c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005083:	c7 05 6b 70 00 00 10 	movl   $0x10,0x706b(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000508a:	00 00 00 
            Print(string);
ffffffff8000508d:	e8 0e 1f 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005092:	48 8b 73 08          	mov    0x8(%rbx),%rsi
ffffffff80005096:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005099:	e8 c2 fd ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000509e:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff800050a5:	48 89 c7             	mov    %rax,%rdi
ffffffff800050a8:	e8 23 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "Flags: " << "0x" << base::hex << frame->Flags << "\n";
ffffffff800050ad:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff800050b4:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff800050bb:	e8 10 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050c0:	48 c7 c6 c0 ba 00 80 	mov    $0xffffffff8000bac0,%rsi
ffffffff800050c7:	48 89 c7             	mov    %rax,%rdi
ffffffff800050ca:	e8 01 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050cf:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff800050d6:	48 89 c7             	mov    %rax,%rdi
ffffffff800050d9:	e8 f2 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050de:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff800050e5:	48 89 c5             	mov    %rax,%rbp
ffffffff800050e8:	e8 b3 1e 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800050ed:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800050f4:	c7 05 fa 6f 00 00 10 	movl   $0x10,0x6ffa(%rip)        # ffffffff8000c0f8 <kout>
ffffffff800050fb:	00 00 00 
            Print(string);
ffffffff800050fe:	e8 9d 1e 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005103:	48 8b 73 10          	mov    0x10(%rbx),%rsi
ffffffff80005107:	48 89 ef             	mov    %rbp,%rdi
ffffffff8000510a:	e8 51 fd ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000510f:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005116:	48 89 c7             	mov    %rax,%rdi
ffffffff80005119:	e8 b2 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "StackPointer: " << "0x" << base::hex << frame->SP << "\n";   
ffffffff8000511e:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005125:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff8000512c:	e8 9f fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005131:	48 c7 c6 c8 ba 00 80 	mov    $0xffffffff8000bac8,%rsi
ffffffff80005138:	48 89 c7             	mov    %rax,%rdi
ffffffff8000513b:	e8 90 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005140:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff80005147:	48 89 c7             	mov    %rax,%rdi
ffffffff8000514a:	e8 81 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000514f:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005156:	48 89 c5             	mov    %rax,%rbp
ffffffff80005159:	e8 42 1e 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000515e:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005165:	c7 05 89 6f 00 00 10 	movl   $0x10,0x6f89(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000516c:	00 00 00 
            Print(string);
ffffffff8000516f:	e8 2c 1e 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005174:	48 8b 73 18          	mov    0x18(%rbx),%rsi
ffffffff80005178:	48 89 ef             	mov    %rbp,%rdi
ffffffff8000517b:	e8 e0 fc ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff80005180:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005187:	48 89 c7             	mov    %rax,%rdi
ffffffff8000518a:	e8 41 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "StackSegment: " << "0x" << base::hex << frame->SS << "\n";   
ffffffff8000518f:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005196:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff8000519d:	e8 2e fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051a2:	48 c7 c6 d7 ba 00 80 	mov    $0xffffffff8000bad7,%rsi
ffffffff800051a9:	48 89 c7             	mov    %rax,%rdi
ffffffff800051ac:	e8 1f fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051b1:	48 c7 c6 10 bd 00 80 	mov    $0xffffffff8000bd10,%rsi
ffffffff800051b8:	48 89 c7             	mov    %rax,%rdi
ffffffff800051bb:	e8 10 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051c0:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff800051c7:	48 89 c5             	mov    %rax,%rbp
ffffffff800051ca:	e8 d1 1d 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800051cf:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800051d6:	c7 05 18 6f 00 00 10 	movl   $0x10,0x6f18(%rip)        # ffffffff8000c0f8 <kout>
ffffffff800051dd:	00 00 00 
            Print(string);
ffffffff800051e0:	e8 bb 1d 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800051e5:	48 8b 73 20          	mov    0x20(%rbx),%rsi
ffffffff800051e9:	48 89 ef             	mov    %rbp,%rdi
ffffffff800051ec:	e8 6f fc ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff800051f1:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff800051f8:	48 89 c7             	mov    %rax,%rdi
ffffffff800051fb:	e8 d0 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        asm ("cli");
ffffffff80005200:	fa                   	cli
        asm ("hlt");
ffffffff80005201:	f4                   	hlt
    while (true) {
ffffffff80005202:	eb fc                	jmp    ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350>
            kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n";
ffffffff80005204:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff8000520b:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
            frame = (System::PanicFrame*)&pf_frame->IP;
ffffffff80005212:	48 8d 6b 08          	lea    0x8(%rbx),%rbp
            kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n";
ffffffff80005216:	e8 b5 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000521b:	48 c7 c6 e9 b9 00 80 	mov    $0xffffffff8000b9e9,%rsi
ffffffff80005222:	48 89 c7             	mov    %rax,%rdi
ffffffff80005225:	e8 a6 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000522a:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005231:	49 89 c4             	mov    %rax,%r12
ffffffff80005234:	e8 67 1d 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005239:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005240:	c7 05 ae 6e 00 00 0a 	movl   $0xa,0x6eae(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80005247:	00 00 00 
            Print(string);
ffffffff8000524a:	e8 51 1d 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000524f:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005252:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005255:	83 e6 01             	and    $0x1,%esi
ffffffff80005258:	e8 b3 fb ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff8000525d:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005264:	48 89 c7             	mov    %rax,%rdi
ffffffff80005267:	e8 64 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n";
ffffffff8000526c:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005273:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff8000527a:	e8 51 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000527f:	48 c7 c6 fc b9 00 80 	mov    $0xffffffff8000b9fc,%rsi
ffffffff80005286:	48 89 c7             	mov    %rax,%rdi
ffffffff80005289:	e8 42 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000528e:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005295:	49 89 c4             	mov    %rax,%r12
ffffffff80005298:	e8 03 1d 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000529d:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800052a4:	c7 05 4a 6e 00 00 0a 	movl   $0xa,0x6e4a(%rip)        # ffffffff8000c0f8 <kout>
ffffffff800052ab:	00 00 00 
            Print(string);
ffffffff800052ae:	e8 ed 1c 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800052b3:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800052b6:	4c 89 e7             	mov    %r12,%rdi
ffffffff800052b9:	40 d0 ee             	shr    $1,%sil
ffffffff800052bc:	83 e6 01             	and    $0x1,%esi
ffffffff800052bf:	e8 4c fb ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800052c4:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff800052cb:	48 89 c7             	mov    %rax,%rdi
ffffffff800052ce:	e8 fd fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultUser: " << base::dec << pf_frame->PageFaultError.User << "\n";
ffffffff800052d3:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff800052da:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff800052e1:	e8 ea fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800052e6:	48 c7 c6 0d ba 00 80 	mov    $0xffffffff8000ba0d,%rsi
ffffffff800052ed:	48 89 c7             	mov    %rax,%rdi
ffffffff800052f0:	e8 db fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800052f5:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff800052fc:	49 89 c4             	mov    %rax,%r12
ffffffff800052ff:	e8 9c 1c 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005304:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff8000530b:	c7 05 e3 6d 00 00 0a 	movl   $0xa,0x6de3(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80005312:	00 00 00 
            Print(string);
ffffffff80005315:	e8 86 1c 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000531a:	0f b6 33             	movzbl (%rbx),%esi
ffffffff8000531d:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005320:	40 c0 ee 02          	shr    $0x2,%sil
ffffffff80005324:	83 e6 01             	and    $0x1,%esi
ffffffff80005327:	e8 e4 fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff8000532c:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005333:	48 89 c7             	mov    %rax,%rdi
ffffffff80005336:	e8 95 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultReservedWrite: " << base::dec << pf_frame->PageFaultError.ReservedWrite << "\n";
ffffffff8000533b:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005342:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80005349:	e8 82 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000534e:	48 c7 c6 1d ba 00 80 	mov    $0xffffffff8000ba1d,%rsi
ffffffff80005355:	48 89 c7             	mov    %rax,%rdi
ffffffff80005358:	e8 73 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000535d:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005364:	49 89 c4             	mov    %rax,%r12
ffffffff80005367:	e8 34 1c 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000536c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005373:	c7 05 7b 6d 00 00 0a 	movl   $0xa,0x6d7b(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000537a:	00 00 00 
            Print(string);
ffffffff8000537d:	e8 1e 1c 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005382:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005385:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005388:	40 c0 ee 03          	shr    $0x3,%sil
ffffffff8000538c:	83 e6 01             	and    $0x1,%esi
ffffffff8000538f:	e8 7c fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005394:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff8000539b:	48 89 c7             	mov    %rax,%rdi
ffffffff8000539e:	e8 2d fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultInstructionFetch: " << base::dec << pf_frame->PageFaultError.InstructionFetch << "\n";
ffffffff800053a3:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff800053aa:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff800053b1:	e8 1a fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800053b6:	48 c7 c6 36 ba 00 80 	mov    $0xffffffff8000ba36,%rsi
ffffffff800053bd:	48 89 c7             	mov    %rax,%rdi
ffffffff800053c0:	e8 0b fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800053c5:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff800053cc:	49 89 c4             	mov    %rax,%r12
ffffffff800053cf:	e8 cc 1b 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800053d4:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800053db:	c7 05 13 6d 00 00 0a 	movl   $0xa,0x6d13(%rip)        # ffffffff8000c0f8 <kout>
ffffffff800053e2:	00 00 00 
            Print(string);
ffffffff800053e5:	e8 b6 1b 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800053ea:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800053ed:	4c 89 e7             	mov    %r12,%rdi
ffffffff800053f0:	40 c0 ee 04          	shr    $0x4,%sil
ffffffff800053f4:	83 e6 01             	and    $0x1,%esi
ffffffff800053f7:	e8 14 fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800053fc:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff80005403:	48 89 c7             	mov    %rax,%rdi
ffffffff80005406:	e8 c5 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultProtectionKey: " << base::dec << pf_frame->PageFaultError.ProtectionKey << "\n";
ffffffff8000540b:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005412:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80005419:	e8 b2 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000541e:	48 c7 c6 52 ba 00 80 	mov    $0xffffffff8000ba52,%rsi
ffffffff80005425:	48 89 c7             	mov    %rax,%rdi
ffffffff80005428:	e8 a3 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000542d:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005434:	49 89 c4             	mov    %rax,%r12
ffffffff80005437:	e8 64 1b 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000543c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005443:	c7 05 ab 6c 00 00 0a 	movl   $0xa,0x6cab(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000544a:	00 00 00 
            Print(string);
ffffffff8000544d:	e8 4e 1b 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005452:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005455:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005458:	40 c0 ee 05          	shr    $0x5,%sil
ffffffff8000545c:	83 e6 01             	and    $0x1,%esi
ffffffff8000545f:	e8 ac f9 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005464:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff8000546b:	48 89 c7             	mov    %rax,%rdi
ffffffff8000546e:	e8 5d f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff80005473:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff8000547a:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80005481:	e8 4a f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005486:	48 c7 c6 6b ba 00 80 	mov    $0xffffffff8000ba6b,%rsi
ffffffff8000548d:	48 89 c7             	mov    %rax,%rdi
ffffffff80005490:	e8 3b f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005495:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff8000549c:	49 89 c4             	mov    %rax,%r12
ffffffff8000549f:	e8 fc 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800054a4:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800054ab:	c7 05 43 6c 00 00 0a 	movl   $0xa,0x6c43(%rip)        # ffffffff8000c0f8 <kout>
ffffffff800054b2:	00 00 00 
            Print(string);
ffffffff800054b5:	e8 e6 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800054ba:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800054bd:	4c 89 e7             	mov    %r12,%rdi
ffffffff800054c0:	40 c0 ee 06          	shr    $0x6,%sil
ffffffff800054c4:	83 e6 01             	and    $0x1,%esi
ffffffff800054c7:	e8 44 f9 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800054cc:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff800054d3:	48 89 c7             	mov    %rax,%rdi
ffffffff800054d6:	e8 f5 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff800054db:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff800054e2:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff800054e9:	e8 e2 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800054ee:	48 c7 c6 82 ba 00 80 	mov    $0xffffffff8000ba82,%rsi
ffffffff800054f5:	48 89 c7             	mov    %rax,%rdi
ffffffff800054f8:	e8 d3 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800054fd:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005504:	49 89 c4             	mov    %rax,%r12
ffffffff80005507:	e8 94 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000550c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005513:	c7 05 db 6b 00 00 0a 	movl   $0xa,0x6bdb(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000551a:	00 00 00 
            Print(string);
ffffffff8000551d:	e8 7e 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005522:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005525:	4c 89 e7             	mov    %r12,%rdi
            frame = (System::PanicFrame*)&pf_frame->IP;
ffffffff80005528:	48 89 eb             	mov    %rbp,%rbx
            kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff8000552b:	40 c0 ee 06          	shr    $0x6,%sil
ffffffff8000552f:	83 e6 01             	and    $0x1,%esi
ffffffff80005532:	e8 d9 f8 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005537:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff8000553e:	48 89 c7             	mov    %rax,%rdi
ffffffff80005541:	e8 8a f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005546:	e9 81 fa ff ff       	jmp    ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c>
            kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n";
ffffffff8000554b:	48 c7 c6 c2 b9 00 80 	mov    $0xffffffff8000b9c2,%rsi
ffffffff80005552:	48 c7 c7 c0 17 0e 80 	mov    $0xffffffff800e17c0,%rdi
ffffffff80005559:	e8 72 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000555e:	48 c7 c6 91 ba 00 80 	mov    $0xffffffff8000ba91,%rsi
ffffffff80005565:	48 89 c7             	mov    %rax,%rdi
ffffffff80005568:	e8 63 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000556d:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff80005574:	48 89 c5             	mov    %rax,%rbp
ffffffff80005577:	e8 24 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000557c:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005583:	c7 05 6b 6b 00 00 0a 	movl   $0xa,0x6b6b(%rip)        # ffffffff8000c0f8 <kout>
ffffffff8000558a:	00 00 00 
            Print(string);
ffffffff8000558d:	e8 0e 1a 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff80005592:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005595:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005598:	e8 c3 f8 ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000559d:	48 c7 c6 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rsi
ffffffff800055a4:	48 89 c7             	mov    %rax,%rdi
ffffffff800055a7:	e8 24 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800055ac:	e9 1b fa ff ff       	jmp    ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c>
ffffffff800055b1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800055b8:	00 00 00 
ffffffff800055bb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff800055c0 <_ZdlPvm>:
{
    Memory::g_heap->Free(block);
}

void operator delete(void* block, long unsigned int)
{
ffffffff800055c0:	f3 0f 1e fa          	endbr64
ffffffff800055c4:	48 89 fe             	mov    %rdi,%rsi
    Memory::g_heap->Free(block);
ffffffff800055c7:	48 8b 3d 02 c2 0d 00 	mov    0xdc202(%rip),%rdi        # ffffffff800e17d0 <_ZN6Memory6g_heapE>
ffffffff800055ce:	e9 ed 16 00 00       	jmp    ffffffff80006cc0 <_ZN6Memory13HeapAllocator4FreeEPv>
ffffffff800055d3:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800055da:	00 00 00 
ffffffff800055dd:	0f 1f 00             	nopl   (%rax)

ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>:
#include "Stream.hpp"
#include <Memory/Heap.hpp>
#include <Terminal/Terminal.hpp>
#include <Libraries/String.hpp>

kcp::cstringstream::cstringstream()
ffffffff800055e0:	f3 0f 1e fa          	endbr64
ffffffff800055e4:	c7 47 10 0a 00 00 00 	movl   $0xa,0x10(%rdi)
{
    this->string = nullptr;
ffffffff800055eb:	48 c7 07 00 00 00 00 	movq   $0x0,(%rdi)
    this->size = 0;
ffffffff800055f2:	48 c7 47 08 00 00 00 	movq   $0x0,0x8(%rdi)
ffffffff800055f9:	00 
}
ffffffff800055fa:	c3                   	ret
ffffffff800055fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>:

kcp::cstringstream::~cstringstream()
ffffffff80005600:	f3 0f 1e fa          	endbr64
{
    delete this->string;
ffffffff80005604:	48 8b 3f             	mov    (%rdi),%rdi
ffffffff80005607:	48 85 ff             	test   %rdi,%rdi
ffffffff8000560a:	74 14                	je     ffffffff80005620 <_ZN3kcp13cstringstreamD1Ev+0x20>
ffffffff8000560c:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80005611:	e9 aa ff ff ff       	jmp    ffffffff800055c0 <_ZdlPvm>
ffffffff80005616:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000561d:	00 00 00 
}
ffffffff80005620:	c3                   	ret
ffffffff80005621:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80005628:	00 00 00 
ffffffff8000562b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>:
    }

    return *this;
}

kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) {
ffffffff80005630:	f3 0f 1e fa          	endbr64
ffffffff80005634:	41 54                	push   %r12
ffffffff80005636:	55                   	push   %rbp
ffffffff80005637:	53                   	push   %rbx
    while (*str != '\0')
ffffffff80005638:	44 0f b6 26          	movzbl (%rsi),%r12d
kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) {
ffffffff8000563c:	48 89 fb             	mov    %rdi,%rbx
    while (*str != '\0')
ffffffff8000563f:	45 84 e4             	test   %r12b,%r12b
ffffffff80005642:	74 49                	je     ffffffff8000568d <_ZN3kcp13cstringstreamlsEPKc+0x5d>
ffffffff80005644:	48 89 f5             	mov    %rsi,%rbp
ffffffff80005647:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000564e:	00 00 
    this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2);
ffffffff80005650:	48 8b 43 08          	mov    0x8(%rbx),%rax
ffffffff80005654:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005657:	48 8b 3d 72 c1 0d 00 	mov    0xdc172(%rip),%rdi        # ffffffff800e17d0 <_ZN6Memory6g_heapE>
ffffffff8000565e:	48 8d 50 02          	lea    0x2(%rax),%rdx
ffffffff80005662:	e8 e9 15 00 00       	call   ffffffff80006c50 <_ZN6Memory13HeapAllocator7ReallocEPvm>
ffffffff80005667:	48 89 03             	mov    %rax,(%rbx)
    if (!this->string)
ffffffff8000566a:	48 85 c0             	test   %rax,%rax
ffffffff8000566d:	74 29                	je     ffffffff80005698 <_ZN3kcp13cstringstreamlsEPKc+0x68>
    char* ref = (char *)&string[size];
ffffffff8000566f:	48 03 43 08          	add    0x8(%rbx),%rax
    *ref = c;
ffffffff80005673:	44 88 20             	mov    %r12b,(%rax)
    *ref = '\0';
ffffffff80005676:	c6 40 01 00          	movb   $0x0,0x1(%rax)
    this->size++;
ffffffff8000567a:	48 83 43 08 01       	addq   $0x1,0x8(%rbx)
    while (*str != '\0')
ffffffff8000567f:	44 0f b6 65 01       	movzbl 0x1(%rbp),%r12d
        str++;
ffffffff80005684:	48 83 c5 01          	add    $0x1,%rbp
    while (*str != '\0')
ffffffff80005688:	45 84 e4             	test   %r12b,%r12b
ffffffff8000568b:	75 c3                	jne    ffffffff80005650 <_ZN3kcp13cstringstreamlsEPKc+0x20>
    *this << (char*)str;

    return *this;
}
ffffffff8000568d:	48 89 d8             	mov    %rbx,%rax
ffffffff80005690:	5b                   	pop    %rbx
ffffffff80005691:	5d                   	pop    %rbp
ffffffff80005692:	41 5c                	pop    %r12
ffffffff80005694:	c3                   	ret
ffffffff80005695:	0f 1f 00             	nopl   (%rax)
ffffffff80005698:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff8000569f:	e8 fc 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800056a4:	48 c7 c7 18 bd 00 80 	mov    $0xffffffff8000bd18,%rdi
ffffffff800056ab:	e8 f0 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800056b0:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff800056b7:	e8 e4 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff800056bc:	48 c7 c7 a2 b9 00 80 	mov    $0xffffffff8000b9a2,%rdi
ffffffff800056c3:	e8 d8 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800056c8:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800056cd:	e8 9e 18 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
            Print(string);
ffffffff800056d2:	48 c7 c7 aa b9 00 80 	mov    $0xffffffff8000b9aa,%rdi
ffffffff800056d9:	e8 c2 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        return *this;
ffffffff800056de:	eb 9f                	jmp    ffffffff8000567f <_ZN3kcp13cstringstreamlsEPKc+0x4f>

ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>:
    using namespace Kt;

    GDTPointer gdtPointer{};
    BasicGDT kernelGDT{};
    
    void PrepareGDT() {
ffffffff800056e0:	f3 0f 1e fa          	endbr64
ffffffff800056e4:	48 83 ec 08          	sub    $0x8,%rsp
        base streamBaseType = base::dec;

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char *string)
        {
            Print(string);
ffffffff800056e8:	48 c7 c7 e6 ba 00 80 	mov    $0xffffffff8000bae6,%rdi
ffffffff800056ef:	e8 ac 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, std::uint64_t number)
        {
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff800056f4:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff800056f9:	48 c7 c7 60 13 0e 80 	mov    $0xffffffff800e1360,%rdi
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, base newBase)
        {
            t.streamBaseType = newBase;
ffffffff80005700:	c7 05 ee 69 00 00 10 	movl   $0x10,0x69ee(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80005707:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff8000570a:	e8 a1 12 00 00       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff8000570f:	48 89 c7             	mov    %rax,%rdi
ffffffff80005712:	e8 89 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80005717:	48 c7 c7 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rdi
ffffffff8000571e:	e8 7d 18 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n";
        kernelGDT = {
ffffffff80005723:	48 b8 ff ff 00 00 00 	movabs $0xa092000000ffff,%rax
ffffffff8000572a:	92 a0 00 
ffffffff8000572d:	48 ba ff ff 00 00 00 	movabs $0xa09a000000ffff,%rdx
ffffffff80005734:	9a a0 00 
ffffffff80005737:	48 c7 05 1e bc 0d 00 	movq   $0xffff,0xdbc1e(%rip)        # ffffffff800e1360 <_ZN3Hal9kernelGDTE>
ffffffff8000573e:	ff ff 00 00 
ffffffff80005742:	48 89 05 27 bc 0d 00 	mov    %rax,0xdbc27(%rip)        # ffffffff800e1370 <_ZN3Hal9kernelGDTE+0x10>
ffffffff80005749:	48 89 05 30 bc 0d 00 	mov    %rax,0xdbc30(%rip)        # ffffffff800e1380 <_ZN3Hal9kernelGDTE+0x20>
ffffffff80005750:	48 b8 00 00 00 00 00 	movabs $0xfa0000000000,%rax
ffffffff80005757:	fa 00 00 
ffffffff8000575a:	48 89 05 27 bc 0d 00 	mov    %rax,0xdbc27(%rip)        # ffffffff800e1388 <_ZN3Hal9kernelGDTE+0x28>
    
                0x0
            }
        };
    
        gdtPointer = GDTPointer{
ffffffff80005761:	b8 2f 00 00 00       	mov    $0x2f,%eax
        kernelGDT = {
ffffffff80005766:	48 89 15 fb bb 0d 00 	mov    %rdx,0xdbbfb(%rip)        # ffffffff800e1368 <_ZN3Hal9kernelGDTE+0x8>
ffffffff8000576d:	48 89 15 04 bc 0d 00 	mov    %rdx,0xdbc04(%rip)        # ffffffff800e1378 <_ZN3Hal9kernelGDTE+0x18>
        gdtPointer = GDTPointer{
ffffffff80005774:	66 89 05 15 bc 0d 00 	mov    %ax,0xdbc15(%rip)        # ffffffff800e1390 <_ZN3Hal10gdtPointerE>
ffffffff8000577b:	48 c7 05 0c bc 0d 00 	movq   $0xffffffff800e1360,0xdbc0c(%rip)        # ffffffff800e1392 <_ZN3Hal10gdtPointerE+0x2>
ffffffff80005782:	60 13 0e 80 
            .Size = sizeof(kernelGDT) - 1,
            .GDTAddress = (uint64_t)&kernelGDT
        };
    }
ffffffff80005786:	48 83 c4 08          	add    $0x8,%rsp
ffffffff8000578a:	c3                   	ret
ffffffff8000578b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>:
    
    // Helpers implemented in gdt.asm
    extern "C" void LoadGDT(GDTPointer *gdtPointer);
    extern "C" void ReloadSegments();
    
    void BridgeLoadGDT() {
ffffffff80005790:	f3 0f 1e fa          	endbr64
ffffffff80005794:	48 83 ec 08          	sub    $0x8,%rsp
ffffffff80005798:	48 c7 c7 48 bd 00 80 	mov    $0xffffffff8000bd48,%rdi
ffffffff8000579f:	e8 fc 17 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800057a4:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800057a9:	e8 c2 17 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
        // Puts the GDT pointer structure into the GDTR
        kout << "HardwareAbstraction: Setting GDTR" << Kt::newline;
        LoadGDT(&gdtPointer);
ffffffff800057ae:	48 c7 c7 90 13 0e 80 	mov    $0xffffffff800e1390,%rdi
ffffffff800057b5:	e8 36 18 00 00       	call   ffffffff80006ff0 <LoadGDT>
            Print(string);
ffffffff800057ba:	48 c7 c7 70 bd 00 80 	mov    $0xffffffff8000bd70,%rdi
ffffffff800057c1:	e8 da 17 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800057c6:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800057cb:	e8 a0 17 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
    
        kout << "HardwareAbstraction: Reloading segments" << Kt::newline;
        ReloadSegments();
    }
ffffffff800057d0:	48 83 c4 08          	add    $0x8,%rsp
        ReloadSegments();
ffffffff800057d4:	e9 1b 18 00 00       	jmp    ffffffff80006ff4 <ReloadSegments>
ffffffff800057d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff800057e0 <_ZN3Hal16ExceptionHandlerILm0EEEvPN6System10PanicFrameE>:
        "Security Exception",
        "Reserved"
    };

    template<size_t i>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800057e0:	f3 0f 1e fa          	endbr64
ffffffff800057e4:	41 53                	push   %r11
ffffffff800057e6:	41 52                	push   %r10
ffffffff800057e8:	41 51                	push   %r9
ffffffff800057ea:	41 50                	push   %r8
ffffffff800057ec:	57                   	push   %rdi
        // kcp::cstringstream stream;
        // stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel";

        frame->InterruptVector = i;

        Panic(ExceptionStrings[i], frame);
ffffffff800057ed:	48 8b 3d 0c 68 00 00 	mov    0x680c(%rip),%rdi        # ffffffff8000c000 <_ZN3Hal16ExceptionStringsE>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800057f4:	56                   	push   %rsi
ffffffff800057f5:	51                   	push   %rcx
ffffffff800057f6:	52                   	push   %rdx
ffffffff800057f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800057f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800057fd:	c6 44 24 70 00       	movb   $0x0,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005802:	fc                   	cld
ffffffff80005803:	e8 a8 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005808:	58                   	pop    %rax
ffffffff80005809:	5a                   	pop    %rdx
ffffffff8000580a:	59                   	pop    %rcx
ffffffff8000580b:	5e                   	pop    %rsi
ffffffff8000580c:	5f                   	pop    %rdi
ffffffff8000580d:	41 58                	pop    %r8
ffffffff8000580f:	41 59                	pop    %r9
ffffffff80005811:	41 5a                	pop    %r10
ffffffff80005813:	41 5b                	pop    %r11
ffffffff80005815:	48 cf                	iretq
ffffffff80005817:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000581e:	00 00 

ffffffff80005820 <_ZN3Hal16ExceptionHandlerILm1EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005820:	f3 0f 1e fa          	endbr64
ffffffff80005824:	41 53                	push   %r11
ffffffff80005826:	41 52                	push   %r10
ffffffff80005828:	41 51                	push   %r9
ffffffff8000582a:	41 50                	push   %r8
ffffffff8000582c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000582d:	48 8b 3d d4 67 00 00 	mov    0x67d4(%rip),%rdi        # ffffffff8000c008 <_ZN3Hal16ExceptionStringsE+0x8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005834:	56                   	push   %rsi
ffffffff80005835:	51                   	push   %rcx
ffffffff80005836:	52                   	push   %rdx
ffffffff80005837:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005838:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000583d:	c6 44 24 70 01       	movb   $0x1,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005842:	fc                   	cld
ffffffff80005843:	e8 68 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005848:	58                   	pop    %rax
ffffffff80005849:	5a                   	pop    %rdx
ffffffff8000584a:	59                   	pop    %rcx
ffffffff8000584b:	5e                   	pop    %rsi
ffffffff8000584c:	5f                   	pop    %rdi
ffffffff8000584d:	41 58                	pop    %r8
ffffffff8000584f:	41 59                	pop    %r9
ffffffff80005851:	41 5a                	pop    %r10
ffffffff80005853:	41 5b                	pop    %r11
ffffffff80005855:	48 cf                	iretq
ffffffff80005857:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000585e:	00 00 

ffffffff80005860 <_ZN3Hal16ExceptionHandlerILm2EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005860:	f3 0f 1e fa          	endbr64
ffffffff80005864:	41 53                	push   %r11
ffffffff80005866:	41 52                	push   %r10
ffffffff80005868:	41 51                	push   %r9
ffffffff8000586a:	41 50                	push   %r8
ffffffff8000586c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000586d:	48 8b 3d 9c 67 00 00 	mov    0x679c(%rip),%rdi        # ffffffff8000c010 <_ZN3Hal16ExceptionStringsE+0x10>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005874:	56                   	push   %rsi
ffffffff80005875:	51                   	push   %rcx
ffffffff80005876:	52                   	push   %rdx
ffffffff80005877:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005878:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000587d:	c6 44 24 70 02       	movb   $0x2,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005882:	fc                   	cld
ffffffff80005883:	e8 28 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005888:	58                   	pop    %rax
ffffffff80005889:	5a                   	pop    %rdx
ffffffff8000588a:	59                   	pop    %rcx
ffffffff8000588b:	5e                   	pop    %rsi
ffffffff8000588c:	5f                   	pop    %rdi
ffffffff8000588d:	41 58                	pop    %r8
ffffffff8000588f:	41 59                	pop    %r9
ffffffff80005891:	41 5a                	pop    %r10
ffffffff80005893:	41 5b                	pop    %r11
ffffffff80005895:	48 cf                	iretq
ffffffff80005897:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000589e:	00 00 

ffffffff800058a0 <_ZN3Hal16ExceptionHandlerILm3EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058a0:	f3 0f 1e fa          	endbr64
ffffffff800058a4:	41 53                	push   %r11
ffffffff800058a6:	41 52                	push   %r10
ffffffff800058a8:	41 51                	push   %r9
ffffffff800058aa:	41 50                	push   %r8
ffffffff800058ac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800058ad:	48 8b 3d 64 67 00 00 	mov    0x6764(%rip),%rdi        # ffffffff8000c018 <_ZN3Hal16ExceptionStringsE+0x18>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058b4:	56                   	push   %rsi
ffffffff800058b5:	51                   	push   %rcx
ffffffff800058b6:	52                   	push   %rdx
ffffffff800058b7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800058b8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800058bd:	c6 44 24 70 03       	movb   $0x3,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff800058c2:	fc                   	cld
ffffffff800058c3:	e8 e8 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff800058c8:	58                   	pop    %rax
ffffffff800058c9:	5a                   	pop    %rdx
ffffffff800058ca:	59                   	pop    %rcx
ffffffff800058cb:	5e                   	pop    %rsi
ffffffff800058cc:	5f                   	pop    %rdi
ffffffff800058cd:	41 58                	pop    %r8
ffffffff800058cf:	41 59                	pop    %r9
ffffffff800058d1:	41 5a                	pop    %r10
ffffffff800058d3:	41 5b                	pop    %r11
ffffffff800058d5:	48 cf                	iretq
ffffffff800058d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800058de:	00 00 

ffffffff800058e0 <_ZN3Hal16ExceptionHandlerILm4EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058e0:	f3 0f 1e fa          	endbr64
ffffffff800058e4:	41 53                	push   %r11
ffffffff800058e6:	41 52                	push   %r10
ffffffff800058e8:	41 51                	push   %r9
ffffffff800058ea:	41 50                	push   %r8
ffffffff800058ec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800058ed:	48 8b 3d 2c 67 00 00 	mov    0x672c(%rip),%rdi        # ffffffff8000c020 <_ZN3Hal16ExceptionStringsE+0x20>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058f4:	56                   	push   %rsi
ffffffff800058f5:	51                   	push   %rcx
ffffffff800058f6:	52                   	push   %rdx
ffffffff800058f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800058f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800058fd:	c6 44 24 70 04       	movb   $0x4,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005902:	fc                   	cld
ffffffff80005903:	e8 a8 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005908:	58                   	pop    %rax
ffffffff80005909:	5a                   	pop    %rdx
ffffffff8000590a:	59                   	pop    %rcx
ffffffff8000590b:	5e                   	pop    %rsi
ffffffff8000590c:	5f                   	pop    %rdi
ffffffff8000590d:	41 58                	pop    %r8
ffffffff8000590f:	41 59                	pop    %r9
ffffffff80005911:	41 5a                	pop    %r10
ffffffff80005913:	41 5b                	pop    %r11
ffffffff80005915:	48 cf                	iretq
ffffffff80005917:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000591e:	00 00 

ffffffff80005920 <_ZN3Hal16ExceptionHandlerILm5EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005920:	f3 0f 1e fa          	endbr64
ffffffff80005924:	41 53                	push   %r11
ffffffff80005926:	41 52                	push   %r10
ffffffff80005928:	41 51                	push   %r9
ffffffff8000592a:	41 50                	push   %r8
ffffffff8000592c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000592d:	48 8b 3d f4 66 00 00 	mov    0x66f4(%rip),%rdi        # ffffffff8000c028 <_ZN3Hal16ExceptionStringsE+0x28>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005934:	56                   	push   %rsi
ffffffff80005935:	51                   	push   %rcx
ffffffff80005936:	52                   	push   %rdx
ffffffff80005937:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005938:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000593d:	c6 44 24 70 05       	movb   $0x5,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005942:	fc                   	cld
ffffffff80005943:	e8 68 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005948:	58                   	pop    %rax
ffffffff80005949:	5a                   	pop    %rdx
ffffffff8000594a:	59                   	pop    %rcx
ffffffff8000594b:	5e                   	pop    %rsi
ffffffff8000594c:	5f                   	pop    %rdi
ffffffff8000594d:	41 58                	pop    %r8
ffffffff8000594f:	41 59                	pop    %r9
ffffffff80005951:	41 5a                	pop    %r10
ffffffff80005953:	41 5b                	pop    %r11
ffffffff80005955:	48 cf                	iretq
ffffffff80005957:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000595e:	00 00 

ffffffff80005960 <_ZN3Hal16ExceptionHandlerILm6EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005960:	f3 0f 1e fa          	endbr64
ffffffff80005964:	41 53                	push   %r11
ffffffff80005966:	41 52                	push   %r10
ffffffff80005968:	41 51                	push   %r9
ffffffff8000596a:	41 50                	push   %r8
ffffffff8000596c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000596d:	48 8b 3d bc 66 00 00 	mov    0x66bc(%rip),%rdi        # ffffffff8000c030 <_ZN3Hal16ExceptionStringsE+0x30>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005974:	56                   	push   %rsi
ffffffff80005975:	51                   	push   %rcx
ffffffff80005976:	52                   	push   %rdx
ffffffff80005977:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005978:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000597d:	c6 44 24 70 06       	movb   $0x6,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005982:	fc                   	cld
ffffffff80005983:	e8 28 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005988:	58                   	pop    %rax
ffffffff80005989:	5a                   	pop    %rdx
ffffffff8000598a:	59                   	pop    %rcx
ffffffff8000598b:	5e                   	pop    %rsi
ffffffff8000598c:	5f                   	pop    %rdi
ffffffff8000598d:	41 58                	pop    %r8
ffffffff8000598f:	41 59                	pop    %r9
ffffffff80005991:	41 5a                	pop    %r10
ffffffff80005993:	41 5b                	pop    %r11
ffffffff80005995:	48 cf                	iretq
ffffffff80005997:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000599e:	00 00 

ffffffff800059a0 <_ZN3Hal16ExceptionHandlerILm7EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059a0:	f3 0f 1e fa          	endbr64
ffffffff800059a4:	41 53                	push   %r11
ffffffff800059a6:	41 52                	push   %r10
ffffffff800059a8:	41 51                	push   %r9
ffffffff800059aa:	41 50                	push   %r8
ffffffff800059ac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800059ad:	48 8b 3d 84 66 00 00 	mov    0x6684(%rip),%rdi        # ffffffff8000c038 <_ZN3Hal16ExceptionStringsE+0x38>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059b4:	56                   	push   %rsi
ffffffff800059b5:	51                   	push   %rcx
ffffffff800059b6:	52                   	push   %rdx
ffffffff800059b7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800059b8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800059bd:	c6 44 24 70 07       	movb   $0x7,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff800059c2:	fc                   	cld
ffffffff800059c3:	e8 e8 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff800059c8:	58                   	pop    %rax
ffffffff800059c9:	5a                   	pop    %rdx
ffffffff800059ca:	59                   	pop    %rcx
ffffffff800059cb:	5e                   	pop    %rsi
ffffffff800059cc:	5f                   	pop    %rdi
ffffffff800059cd:	41 58                	pop    %r8
ffffffff800059cf:	41 59                	pop    %r9
ffffffff800059d1:	41 5a                	pop    %r10
ffffffff800059d3:	41 5b                	pop    %r11
ffffffff800059d5:	48 cf                	iretq
ffffffff800059d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800059de:	00 00 

ffffffff800059e0 <_ZN3Hal16ExceptionHandlerILm8EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059e0:	f3 0f 1e fa          	endbr64
ffffffff800059e4:	41 53                	push   %r11
ffffffff800059e6:	41 52                	push   %r10
ffffffff800059e8:	41 51                	push   %r9
ffffffff800059ea:	41 50                	push   %r8
ffffffff800059ec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800059ed:	48 8b 3d 4c 66 00 00 	mov    0x664c(%rip),%rdi        # ffffffff8000c040 <_ZN3Hal16ExceptionStringsE+0x40>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059f4:	56                   	push   %rsi
ffffffff800059f5:	51                   	push   %rcx
ffffffff800059f6:	52                   	push   %rdx
ffffffff800059f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800059f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800059fd:	c6 44 24 70 08       	movb   $0x8,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a02:	fc                   	cld
ffffffff80005a03:	e8 a8 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a08:	58                   	pop    %rax
ffffffff80005a09:	5a                   	pop    %rdx
ffffffff80005a0a:	59                   	pop    %rcx
ffffffff80005a0b:	5e                   	pop    %rsi
ffffffff80005a0c:	5f                   	pop    %rdi
ffffffff80005a0d:	41 58                	pop    %r8
ffffffff80005a0f:	41 59                	pop    %r9
ffffffff80005a11:	41 5a                	pop    %r10
ffffffff80005a13:	41 5b                	pop    %r11
ffffffff80005a15:	48 cf                	iretq
ffffffff80005a17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a1e:	00 00 

ffffffff80005a20 <_ZN3Hal16ExceptionHandlerILm9EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a20:	f3 0f 1e fa          	endbr64
ffffffff80005a24:	41 53                	push   %r11
ffffffff80005a26:	41 52                	push   %r10
ffffffff80005a28:	41 51                	push   %r9
ffffffff80005a2a:	41 50                	push   %r8
ffffffff80005a2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005a2d:	48 8b 3d 14 66 00 00 	mov    0x6614(%rip),%rdi        # ffffffff8000c048 <_ZN3Hal16ExceptionStringsE+0x48>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a34:	56                   	push   %rsi
ffffffff80005a35:	51                   	push   %rcx
ffffffff80005a36:	52                   	push   %rdx
ffffffff80005a37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005a38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005a3d:	c6 44 24 70 09       	movb   $0x9,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a42:	fc                   	cld
ffffffff80005a43:	e8 68 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a48:	58                   	pop    %rax
ffffffff80005a49:	5a                   	pop    %rdx
ffffffff80005a4a:	59                   	pop    %rcx
ffffffff80005a4b:	5e                   	pop    %rsi
ffffffff80005a4c:	5f                   	pop    %rdi
ffffffff80005a4d:	41 58                	pop    %r8
ffffffff80005a4f:	41 59                	pop    %r9
ffffffff80005a51:	41 5a                	pop    %r10
ffffffff80005a53:	41 5b                	pop    %r11
ffffffff80005a55:	48 cf                	iretq
ffffffff80005a57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a5e:	00 00 

ffffffff80005a60 <_ZN3Hal16ExceptionHandlerILm10EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a60:	f3 0f 1e fa          	endbr64
ffffffff80005a64:	41 53                	push   %r11
ffffffff80005a66:	41 52                	push   %r10
ffffffff80005a68:	41 51                	push   %r9
ffffffff80005a6a:	41 50                	push   %r8
ffffffff80005a6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005a6d:	48 8b 3d dc 65 00 00 	mov    0x65dc(%rip),%rdi        # ffffffff8000c050 <_ZN3Hal16ExceptionStringsE+0x50>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a74:	56                   	push   %rsi
ffffffff80005a75:	51                   	push   %rcx
ffffffff80005a76:	52                   	push   %rdx
ffffffff80005a77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005a78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005a7d:	c6 44 24 70 0a       	movb   $0xa,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a82:	fc                   	cld
ffffffff80005a83:	e8 28 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a88:	58                   	pop    %rax
ffffffff80005a89:	5a                   	pop    %rdx
ffffffff80005a8a:	59                   	pop    %rcx
ffffffff80005a8b:	5e                   	pop    %rsi
ffffffff80005a8c:	5f                   	pop    %rdi
ffffffff80005a8d:	41 58                	pop    %r8
ffffffff80005a8f:	41 59                	pop    %r9
ffffffff80005a91:	41 5a                	pop    %r10
ffffffff80005a93:	41 5b                	pop    %r11
ffffffff80005a95:	48 cf                	iretq
ffffffff80005a97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a9e:	00 00 

ffffffff80005aa0 <_ZN3Hal16ExceptionHandlerILm11EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005aa0:	f3 0f 1e fa          	endbr64
ffffffff80005aa4:	41 53                	push   %r11
ffffffff80005aa6:	41 52                	push   %r10
ffffffff80005aa8:	41 51                	push   %r9
ffffffff80005aaa:	41 50                	push   %r8
ffffffff80005aac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005aad:	48 8b 3d a4 65 00 00 	mov    0x65a4(%rip),%rdi        # ffffffff8000c058 <_ZN3Hal16ExceptionStringsE+0x58>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ab4:	56                   	push   %rsi
ffffffff80005ab5:	51                   	push   %rcx
ffffffff80005ab6:	52                   	push   %rdx
ffffffff80005ab7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005ab8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005abd:	c6 44 24 70 0b       	movb   $0xb,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005ac2:	fc                   	cld
ffffffff80005ac3:	e8 e8 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005ac8:	58                   	pop    %rax
ffffffff80005ac9:	5a                   	pop    %rdx
ffffffff80005aca:	59                   	pop    %rcx
ffffffff80005acb:	5e                   	pop    %rsi
ffffffff80005acc:	5f                   	pop    %rdi
ffffffff80005acd:	41 58                	pop    %r8
ffffffff80005acf:	41 59                	pop    %r9
ffffffff80005ad1:	41 5a                	pop    %r10
ffffffff80005ad3:	41 5b                	pop    %r11
ffffffff80005ad5:	48 cf                	iretq
ffffffff80005ad7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005ade:	00 00 

ffffffff80005ae0 <_ZN3Hal16ExceptionHandlerILm12EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ae0:	f3 0f 1e fa          	endbr64
ffffffff80005ae4:	41 53                	push   %r11
ffffffff80005ae6:	41 52                	push   %r10
ffffffff80005ae8:	41 51                	push   %r9
ffffffff80005aea:	41 50                	push   %r8
ffffffff80005aec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005aed:	48 8b 3d 6c 65 00 00 	mov    0x656c(%rip),%rdi        # ffffffff8000c060 <_ZN3Hal16ExceptionStringsE+0x60>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005af4:	56                   	push   %rsi
ffffffff80005af5:	51                   	push   %rcx
ffffffff80005af6:	52                   	push   %rdx
ffffffff80005af7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005af8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005afd:	c6 44 24 70 0c       	movb   $0xc,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b02:	fc                   	cld
ffffffff80005b03:	e8 a8 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b08:	58                   	pop    %rax
ffffffff80005b09:	5a                   	pop    %rdx
ffffffff80005b0a:	59                   	pop    %rcx
ffffffff80005b0b:	5e                   	pop    %rsi
ffffffff80005b0c:	5f                   	pop    %rdi
ffffffff80005b0d:	41 58                	pop    %r8
ffffffff80005b0f:	41 59                	pop    %r9
ffffffff80005b11:	41 5a                	pop    %r10
ffffffff80005b13:	41 5b                	pop    %r11
ffffffff80005b15:	48 cf                	iretq
ffffffff80005b17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b1e:	00 00 

ffffffff80005b20 <_ZN3Hal16ExceptionHandlerILm13EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b20:	f3 0f 1e fa          	endbr64
ffffffff80005b24:	41 53                	push   %r11
ffffffff80005b26:	41 52                	push   %r10
ffffffff80005b28:	41 51                	push   %r9
ffffffff80005b2a:	41 50                	push   %r8
ffffffff80005b2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005b2d:	48 8b 3d 34 65 00 00 	mov    0x6534(%rip),%rdi        # ffffffff8000c068 <_ZN3Hal16ExceptionStringsE+0x68>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b34:	56                   	push   %rsi
ffffffff80005b35:	51                   	push   %rcx
ffffffff80005b36:	52                   	push   %rdx
ffffffff80005b37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005b38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005b3d:	c6 44 24 70 0d       	movb   $0xd,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b42:	fc                   	cld
ffffffff80005b43:	e8 68 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b48:	58                   	pop    %rax
ffffffff80005b49:	5a                   	pop    %rdx
ffffffff80005b4a:	59                   	pop    %rcx
ffffffff80005b4b:	5e                   	pop    %rsi
ffffffff80005b4c:	5f                   	pop    %rdi
ffffffff80005b4d:	41 58                	pop    %r8
ffffffff80005b4f:	41 59                	pop    %r9
ffffffff80005b51:	41 5a                	pop    %r10
ffffffff80005b53:	41 5b                	pop    %r11
ffffffff80005b55:	48 cf                	iretq
ffffffff80005b57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b5e:	00 00 

ffffffff80005b60 <_ZN3Hal16ExceptionHandlerILm14EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b60:	f3 0f 1e fa          	endbr64
ffffffff80005b64:	41 53                	push   %r11
ffffffff80005b66:	41 52                	push   %r10
ffffffff80005b68:	41 51                	push   %r9
ffffffff80005b6a:	41 50                	push   %r8
ffffffff80005b6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005b6d:	48 8b 3d fc 64 00 00 	mov    0x64fc(%rip),%rdi        # ffffffff8000c070 <_ZN3Hal16ExceptionStringsE+0x70>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b74:	56                   	push   %rsi
ffffffff80005b75:	51                   	push   %rcx
ffffffff80005b76:	52                   	push   %rdx
ffffffff80005b77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005b78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005b7d:	c6 44 24 70 0e       	movb   $0xe,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b82:	fc                   	cld
ffffffff80005b83:	e8 28 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b88:	58                   	pop    %rax
ffffffff80005b89:	5a                   	pop    %rdx
ffffffff80005b8a:	59                   	pop    %rcx
ffffffff80005b8b:	5e                   	pop    %rsi
ffffffff80005b8c:	5f                   	pop    %rdi
ffffffff80005b8d:	41 58                	pop    %r8
ffffffff80005b8f:	41 59                	pop    %r9
ffffffff80005b91:	41 5a                	pop    %r10
ffffffff80005b93:	41 5b                	pop    %r11
ffffffff80005b95:	48 cf                	iretq
ffffffff80005b97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b9e:	00 00 

ffffffff80005ba0 <_ZN3Hal16ExceptionHandlerILm15EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ba0:	f3 0f 1e fa          	endbr64
ffffffff80005ba4:	41 53                	push   %r11
ffffffff80005ba6:	41 52                	push   %r10
ffffffff80005ba8:	41 51                	push   %r9
ffffffff80005baa:	41 50                	push   %r8
ffffffff80005bac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005bad:	48 8b 3d c4 64 00 00 	mov    0x64c4(%rip),%rdi        # ffffffff8000c078 <_ZN3Hal16ExceptionStringsE+0x78>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005bb4:	56                   	push   %rsi
ffffffff80005bb5:	51                   	push   %rcx
ffffffff80005bb6:	52                   	push   %rdx
ffffffff80005bb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005bb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005bbd:	c6 44 24 70 0f       	movb   $0xf,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005bc2:	fc                   	cld
ffffffff80005bc3:	e8 e8 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005bc8:	58                   	pop    %rax
ffffffff80005bc9:	5a                   	pop    %rdx
ffffffff80005bca:	59                   	pop    %rcx
ffffffff80005bcb:	5e                   	pop    %rsi
ffffffff80005bcc:	5f                   	pop    %rdi
ffffffff80005bcd:	41 58                	pop    %r8
ffffffff80005bcf:	41 59                	pop    %r9
ffffffff80005bd1:	41 5a                	pop    %r10
ffffffff80005bd3:	41 5b                	pop    %r11
ffffffff80005bd5:	48 cf                	iretq
ffffffff80005bd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005bde:	00 00 

ffffffff80005be0 <_ZN3Hal16ExceptionHandlerILm16EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005be0:	f3 0f 1e fa          	endbr64
ffffffff80005be4:	41 53                	push   %r11
ffffffff80005be6:	41 52                	push   %r10
ffffffff80005be8:	41 51                	push   %r9
ffffffff80005bea:	41 50                	push   %r8
ffffffff80005bec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005bed:	48 8b 3d 8c 64 00 00 	mov    0x648c(%rip),%rdi        # ffffffff8000c080 <_ZN3Hal16ExceptionStringsE+0x80>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005bf4:	56                   	push   %rsi
ffffffff80005bf5:	51                   	push   %rcx
ffffffff80005bf6:	52                   	push   %rdx
ffffffff80005bf7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005bf8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005bfd:	c6 44 24 70 10       	movb   $0x10,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c02:	fc                   	cld
ffffffff80005c03:	e8 a8 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c08:	58                   	pop    %rax
ffffffff80005c09:	5a                   	pop    %rdx
ffffffff80005c0a:	59                   	pop    %rcx
ffffffff80005c0b:	5e                   	pop    %rsi
ffffffff80005c0c:	5f                   	pop    %rdi
ffffffff80005c0d:	41 58                	pop    %r8
ffffffff80005c0f:	41 59                	pop    %r9
ffffffff80005c11:	41 5a                	pop    %r10
ffffffff80005c13:	41 5b                	pop    %r11
ffffffff80005c15:	48 cf                	iretq
ffffffff80005c17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c1e:	00 00 

ffffffff80005c20 <_ZN3Hal16ExceptionHandlerILm17EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c20:	f3 0f 1e fa          	endbr64
ffffffff80005c24:	41 53                	push   %r11
ffffffff80005c26:	41 52                	push   %r10
ffffffff80005c28:	41 51                	push   %r9
ffffffff80005c2a:	41 50                	push   %r8
ffffffff80005c2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005c2d:	48 8b 3d 54 64 00 00 	mov    0x6454(%rip),%rdi        # ffffffff8000c088 <_ZN3Hal16ExceptionStringsE+0x88>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c34:	56                   	push   %rsi
ffffffff80005c35:	51                   	push   %rcx
ffffffff80005c36:	52                   	push   %rdx
ffffffff80005c37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005c38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005c3d:	c6 44 24 70 11       	movb   $0x11,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c42:	fc                   	cld
ffffffff80005c43:	e8 68 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c48:	58                   	pop    %rax
ffffffff80005c49:	5a                   	pop    %rdx
ffffffff80005c4a:	59                   	pop    %rcx
ffffffff80005c4b:	5e                   	pop    %rsi
ffffffff80005c4c:	5f                   	pop    %rdi
ffffffff80005c4d:	41 58                	pop    %r8
ffffffff80005c4f:	41 59                	pop    %r9
ffffffff80005c51:	41 5a                	pop    %r10
ffffffff80005c53:	41 5b                	pop    %r11
ffffffff80005c55:	48 cf                	iretq
ffffffff80005c57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c5e:	00 00 

ffffffff80005c60 <_ZN3Hal16ExceptionHandlerILm18EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c60:	f3 0f 1e fa          	endbr64
ffffffff80005c64:	41 53                	push   %r11
ffffffff80005c66:	41 52                	push   %r10
ffffffff80005c68:	41 51                	push   %r9
ffffffff80005c6a:	41 50                	push   %r8
ffffffff80005c6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005c6d:	48 8b 3d 1c 64 00 00 	mov    0x641c(%rip),%rdi        # ffffffff8000c090 <_ZN3Hal16ExceptionStringsE+0x90>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c74:	56                   	push   %rsi
ffffffff80005c75:	51                   	push   %rcx
ffffffff80005c76:	52                   	push   %rdx
ffffffff80005c77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005c78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005c7d:	c6 44 24 70 12       	movb   $0x12,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c82:	fc                   	cld
ffffffff80005c83:	e8 28 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c88:	58                   	pop    %rax
ffffffff80005c89:	5a                   	pop    %rdx
ffffffff80005c8a:	59                   	pop    %rcx
ffffffff80005c8b:	5e                   	pop    %rsi
ffffffff80005c8c:	5f                   	pop    %rdi
ffffffff80005c8d:	41 58                	pop    %r8
ffffffff80005c8f:	41 59                	pop    %r9
ffffffff80005c91:	41 5a                	pop    %r10
ffffffff80005c93:	41 5b                	pop    %r11
ffffffff80005c95:	48 cf                	iretq
ffffffff80005c97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c9e:	00 00 

ffffffff80005ca0 <_ZN3Hal16ExceptionHandlerILm19EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ca0:	f3 0f 1e fa          	endbr64
ffffffff80005ca4:	41 53                	push   %r11
ffffffff80005ca6:	41 52                	push   %r10
ffffffff80005ca8:	41 51                	push   %r9
ffffffff80005caa:	41 50                	push   %r8
ffffffff80005cac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005cad:	48 8b 3d e4 63 00 00 	mov    0x63e4(%rip),%rdi        # ffffffff8000c098 <_ZN3Hal16ExceptionStringsE+0x98>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005cb4:	56                   	push   %rsi
ffffffff80005cb5:	51                   	push   %rcx
ffffffff80005cb6:	52                   	push   %rdx
ffffffff80005cb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005cb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005cbd:	c6 44 24 70 13       	movb   $0x13,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005cc2:	fc                   	cld
ffffffff80005cc3:	e8 e8 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005cc8:	58                   	pop    %rax
ffffffff80005cc9:	5a                   	pop    %rdx
ffffffff80005cca:	59                   	pop    %rcx
ffffffff80005ccb:	5e                   	pop    %rsi
ffffffff80005ccc:	5f                   	pop    %rdi
ffffffff80005ccd:	41 58                	pop    %r8
ffffffff80005ccf:	41 59                	pop    %r9
ffffffff80005cd1:	41 5a                	pop    %r10
ffffffff80005cd3:	41 5b                	pop    %r11
ffffffff80005cd5:	48 cf                	iretq
ffffffff80005cd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005cde:	00 00 

ffffffff80005ce0 <_ZN3Hal16ExceptionHandlerILm20EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ce0:	f3 0f 1e fa          	endbr64
ffffffff80005ce4:	41 53                	push   %r11
ffffffff80005ce6:	41 52                	push   %r10
ffffffff80005ce8:	41 51                	push   %r9
ffffffff80005cea:	41 50                	push   %r8
ffffffff80005cec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ced:	48 8b 3d ac 63 00 00 	mov    0x63ac(%rip),%rdi        # ffffffff8000c0a0 <_ZN3Hal16ExceptionStringsE+0xa0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005cf4:	56                   	push   %rsi
ffffffff80005cf5:	51                   	push   %rcx
ffffffff80005cf6:	52                   	push   %rdx
ffffffff80005cf7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005cf8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005cfd:	c6 44 24 70 14       	movb   $0x14,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d02:	fc                   	cld
ffffffff80005d03:	e8 a8 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d08:	58                   	pop    %rax
ffffffff80005d09:	5a                   	pop    %rdx
ffffffff80005d0a:	59                   	pop    %rcx
ffffffff80005d0b:	5e                   	pop    %rsi
ffffffff80005d0c:	5f                   	pop    %rdi
ffffffff80005d0d:	41 58                	pop    %r8
ffffffff80005d0f:	41 59                	pop    %r9
ffffffff80005d11:	41 5a                	pop    %r10
ffffffff80005d13:	41 5b                	pop    %r11
ffffffff80005d15:	48 cf                	iretq
ffffffff80005d17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d1e:	00 00 

ffffffff80005d20 <_ZN3Hal16ExceptionHandlerILm21EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d20:	f3 0f 1e fa          	endbr64
ffffffff80005d24:	41 53                	push   %r11
ffffffff80005d26:	41 52                	push   %r10
ffffffff80005d28:	41 51                	push   %r9
ffffffff80005d2a:	41 50                	push   %r8
ffffffff80005d2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005d2d:	48 8b 3d 74 63 00 00 	mov    0x6374(%rip),%rdi        # ffffffff8000c0a8 <_ZN3Hal16ExceptionStringsE+0xa8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d34:	56                   	push   %rsi
ffffffff80005d35:	51                   	push   %rcx
ffffffff80005d36:	52                   	push   %rdx
ffffffff80005d37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005d38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005d3d:	c6 44 24 70 15       	movb   $0x15,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d42:	fc                   	cld
ffffffff80005d43:	e8 68 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d48:	58                   	pop    %rax
ffffffff80005d49:	5a                   	pop    %rdx
ffffffff80005d4a:	59                   	pop    %rcx
ffffffff80005d4b:	5e                   	pop    %rsi
ffffffff80005d4c:	5f                   	pop    %rdi
ffffffff80005d4d:	41 58                	pop    %r8
ffffffff80005d4f:	41 59                	pop    %r9
ffffffff80005d51:	41 5a                	pop    %r10
ffffffff80005d53:	41 5b                	pop    %r11
ffffffff80005d55:	48 cf                	iretq
ffffffff80005d57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d5e:	00 00 

ffffffff80005d60 <_ZN3Hal16ExceptionHandlerILm22EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d60:	f3 0f 1e fa          	endbr64
ffffffff80005d64:	41 53                	push   %r11
ffffffff80005d66:	41 52                	push   %r10
ffffffff80005d68:	41 51                	push   %r9
ffffffff80005d6a:	41 50                	push   %r8
ffffffff80005d6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005d6d:	48 8b 3d 3c 63 00 00 	mov    0x633c(%rip),%rdi        # ffffffff8000c0b0 <_ZN3Hal16ExceptionStringsE+0xb0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d74:	56                   	push   %rsi
ffffffff80005d75:	51                   	push   %rcx
ffffffff80005d76:	52                   	push   %rdx
ffffffff80005d77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005d78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005d7d:	c6 44 24 70 16       	movb   $0x16,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d82:	fc                   	cld
ffffffff80005d83:	e8 28 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d88:	58                   	pop    %rax
ffffffff80005d89:	5a                   	pop    %rdx
ffffffff80005d8a:	59                   	pop    %rcx
ffffffff80005d8b:	5e                   	pop    %rsi
ffffffff80005d8c:	5f                   	pop    %rdi
ffffffff80005d8d:	41 58                	pop    %r8
ffffffff80005d8f:	41 59                	pop    %r9
ffffffff80005d91:	41 5a                	pop    %r10
ffffffff80005d93:	41 5b                	pop    %r11
ffffffff80005d95:	48 cf                	iretq
ffffffff80005d97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d9e:	00 00 

ffffffff80005da0 <_ZN3Hal16ExceptionHandlerILm23EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005da0:	f3 0f 1e fa          	endbr64
ffffffff80005da4:	41 53                	push   %r11
ffffffff80005da6:	41 52                	push   %r10
ffffffff80005da8:	41 51                	push   %r9
ffffffff80005daa:	41 50                	push   %r8
ffffffff80005dac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005dad:	48 8b 3d 04 63 00 00 	mov    0x6304(%rip),%rdi        # ffffffff8000c0b8 <_ZN3Hal16ExceptionStringsE+0xb8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005db4:	56                   	push   %rsi
ffffffff80005db5:	51                   	push   %rcx
ffffffff80005db6:	52                   	push   %rdx
ffffffff80005db7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005db8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005dbd:	c6 44 24 70 17       	movb   $0x17,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005dc2:	fc                   	cld
ffffffff80005dc3:	e8 e8 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005dc8:	58                   	pop    %rax
ffffffff80005dc9:	5a                   	pop    %rdx
ffffffff80005dca:	59                   	pop    %rcx
ffffffff80005dcb:	5e                   	pop    %rsi
ffffffff80005dcc:	5f                   	pop    %rdi
ffffffff80005dcd:	41 58                	pop    %r8
ffffffff80005dcf:	41 59                	pop    %r9
ffffffff80005dd1:	41 5a                	pop    %r10
ffffffff80005dd3:	41 5b                	pop    %r11
ffffffff80005dd5:	48 cf                	iretq
ffffffff80005dd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005dde:	00 00 

ffffffff80005de0 <_ZN3Hal16ExceptionHandlerILm24EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005de0:	f3 0f 1e fa          	endbr64
ffffffff80005de4:	41 53                	push   %r11
ffffffff80005de6:	41 52                	push   %r10
ffffffff80005de8:	41 51                	push   %r9
ffffffff80005dea:	41 50                	push   %r8
ffffffff80005dec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ded:	48 8b 3d cc 62 00 00 	mov    0x62cc(%rip),%rdi        # ffffffff8000c0c0 <_ZN3Hal16ExceptionStringsE+0xc0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005df4:	56                   	push   %rsi
ffffffff80005df5:	51                   	push   %rcx
ffffffff80005df6:	52                   	push   %rdx
ffffffff80005df7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005df8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005dfd:	c6 44 24 70 18       	movb   $0x18,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e02:	fc                   	cld
ffffffff80005e03:	e8 a8 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e08:	58                   	pop    %rax
ffffffff80005e09:	5a                   	pop    %rdx
ffffffff80005e0a:	59                   	pop    %rcx
ffffffff80005e0b:	5e                   	pop    %rsi
ffffffff80005e0c:	5f                   	pop    %rdi
ffffffff80005e0d:	41 58                	pop    %r8
ffffffff80005e0f:	41 59                	pop    %r9
ffffffff80005e11:	41 5a                	pop    %r10
ffffffff80005e13:	41 5b                	pop    %r11
ffffffff80005e15:	48 cf                	iretq
ffffffff80005e17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e1e:	00 00 

ffffffff80005e20 <_ZN3Hal16ExceptionHandlerILm25EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e20:	f3 0f 1e fa          	endbr64
ffffffff80005e24:	41 53                	push   %r11
ffffffff80005e26:	41 52                	push   %r10
ffffffff80005e28:	41 51                	push   %r9
ffffffff80005e2a:	41 50                	push   %r8
ffffffff80005e2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005e2d:	48 8b 3d 94 62 00 00 	mov    0x6294(%rip),%rdi        # ffffffff8000c0c8 <_ZN3Hal16ExceptionStringsE+0xc8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e34:	56                   	push   %rsi
ffffffff80005e35:	51                   	push   %rcx
ffffffff80005e36:	52                   	push   %rdx
ffffffff80005e37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005e38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005e3d:	c6 44 24 70 19       	movb   $0x19,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e42:	fc                   	cld
ffffffff80005e43:	e8 68 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e48:	58                   	pop    %rax
ffffffff80005e49:	5a                   	pop    %rdx
ffffffff80005e4a:	59                   	pop    %rcx
ffffffff80005e4b:	5e                   	pop    %rsi
ffffffff80005e4c:	5f                   	pop    %rdi
ffffffff80005e4d:	41 58                	pop    %r8
ffffffff80005e4f:	41 59                	pop    %r9
ffffffff80005e51:	41 5a                	pop    %r10
ffffffff80005e53:	41 5b                	pop    %r11
ffffffff80005e55:	48 cf                	iretq
ffffffff80005e57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e5e:	00 00 

ffffffff80005e60 <_ZN3Hal16ExceptionHandlerILm26EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e60:	f3 0f 1e fa          	endbr64
ffffffff80005e64:	41 53                	push   %r11
ffffffff80005e66:	41 52                	push   %r10
ffffffff80005e68:	41 51                	push   %r9
ffffffff80005e6a:	41 50                	push   %r8
ffffffff80005e6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005e6d:	48 8b 3d 5c 62 00 00 	mov    0x625c(%rip),%rdi        # ffffffff8000c0d0 <_ZN3Hal16ExceptionStringsE+0xd0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e74:	56                   	push   %rsi
ffffffff80005e75:	51                   	push   %rcx
ffffffff80005e76:	52                   	push   %rdx
ffffffff80005e77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005e78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005e7d:	c6 44 24 70 1a       	movb   $0x1a,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e82:	fc                   	cld
ffffffff80005e83:	e8 28 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e88:	58                   	pop    %rax
ffffffff80005e89:	5a                   	pop    %rdx
ffffffff80005e8a:	59                   	pop    %rcx
ffffffff80005e8b:	5e                   	pop    %rsi
ffffffff80005e8c:	5f                   	pop    %rdi
ffffffff80005e8d:	41 58                	pop    %r8
ffffffff80005e8f:	41 59                	pop    %r9
ffffffff80005e91:	41 5a                	pop    %r10
ffffffff80005e93:	41 5b                	pop    %r11
ffffffff80005e95:	48 cf                	iretq
ffffffff80005e97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e9e:	00 00 

ffffffff80005ea0 <_ZN3Hal16ExceptionHandlerILm27EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ea0:	f3 0f 1e fa          	endbr64
ffffffff80005ea4:	41 53                	push   %r11
ffffffff80005ea6:	41 52                	push   %r10
ffffffff80005ea8:	41 51                	push   %r9
ffffffff80005eaa:	41 50                	push   %r8
ffffffff80005eac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ead:	48 8b 3d 24 62 00 00 	mov    0x6224(%rip),%rdi        # ffffffff8000c0d8 <_ZN3Hal16ExceptionStringsE+0xd8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005eb4:	56                   	push   %rsi
ffffffff80005eb5:	51                   	push   %rcx
ffffffff80005eb6:	52                   	push   %rdx
ffffffff80005eb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005eb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005ebd:	c6 44 24 70 1b       	movb   $0x1b,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005ec2:	fc                   	cld
ffffffff80005ec3:	e8 e8 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005ec8:	58                   	pop    %rax
ffffffff80005ec9:	5a                   	pop    %rdx
ffffffff80005eca:	59                   	pop    %rcx
ffffffff80005ecb:	5e                   	pop    %rsi
ffffffff80005ecc:	5f                   	pop    %rdi
ffffffff80005ecd:	41 58                	pop    %r8
ffffffff80005ecf:	41 59                	pop    %r9
ffffffff80005ed1:	41 5a                	pop    %r10
ffffffff80005ed3:	41 5b                	pop    %r11
ffffffff80005ed5:	48 cf                	iretq
ffffffff80005ed7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005ede:	00 00 

ffffffff80005ee0 <_ZN3Hal16ExceptionHandlerILm28EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ee0:	f3 0f 1e fa          	endbr64
ffffffff80005ee4:	41 53                	push   %r11
ffffffff80005ee6:	41 52                	push   %r10
ffffffff80005ee8:	41 51                	push   %r9
ffffffff80005eea:	41 50                	push   %r8
ffffffff80005eec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005eed:	48 8b 3d ec 61 00 00 	mov    0x61ec(%rip),%rdi        # ffffffff8000c0e0 <_ZN3Hal16ExceptionStringsE+0xe0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ef4:	56                   	push   %rsi
ffffffff80005ef5:	51                   	push   %rcx
ffffffff80005ef6:	52                   	push   %rdx
ffffffff80005ef7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005ef8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005efd:	c6 44 24 70 1c       	movb   $0x1c,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f02:	fc                   	cld
ffffffff80005f03:	e8 a8 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f08:	58                   	pop    %rax
ffffffff80005f09:	5a                   	pop    %rdx
ffffffff80005f0a:	59                   	pop    %rcx
ffffffff80005f0b:	5e                   	pop    %rsi
ffffffff80005f0c:	5f                   	pop    %rdi
ffffffff80005f0d:	41 58                	pop    %r8
ffffffff80005f0f:	41 59                	pop    %r9
ffffffff80005f11:	41 5a                	pop    %r10
ffffffff80005f13:	41 5b                	pop    %r11
ffffffff80005f15:	48 cf                	iretq
ffffffff80005f17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f1e:	00 00 

ffffffff80005f20 <_ZN3Hal16ExceptionHandlerILm29EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f20:	f3 0f 1e fa          	endbr64
ffffffff80005f24:	41 53                	push   %r11
ffffffff80005f26:	41 52                	push   %r10
ffffffff80005f28:	41 51                	push   %r9
ffffffff80005f2a:	41 50                	push   %r8
ffffffff80005f2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005f2d:	48 8b 3d b4 61 00 00 	mov    0x61b4(%rip),%rdi        # ffffffff8000c0e8 <_ZN3Hal16ExceptionStringsE+0xe8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f34:	56                   	push   %rsi
ffffffff80005f35:	51                   	push   %rcx
ffffffff80005f36:	52                   	push   %rdx
ffffffff80005f37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005f38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005f3d:	c6 44 24 70 1d       	movb   $0x1d,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f42:	fc                   	cld
ffffffff80005f43:	e8 68 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f48:	58                   	pop    %rax
ffffffff80005f49:	5a                   	pop    %rdx
ffffffff80005f4a:	59                   	pop    %rcx
ffffffff80005f4b:	5e                   	pop    %rsi
ffffffff80005f4c:	5f                   	pop    %rdi
ffffffff80005f4d:	41 58                	pop    %r8
ffffffff80005f4f:	41 59                	pop    %r9
ffffffff80005f51:	41 5a                	pop    %r10
ffffffff80005f53:	41 5b                	pop    %r11
ffffffff80005f55:	48 cf                	iretq
ffffffff80005f57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f5e:	00 00 

ffffffff80005f60 <_ZN3Hal16ExceptionHandlerILm30EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f60:	f3 0f 1e fa          	endbr64
ffffffff80005f64:	41 53                	push   %r11
ffffffff80005f66:	41 52                	push   %r10
ffffffff80005f68:	41 51                	push   %r9
ffffffff80005f6a:	41 50                	push   %r8
ffffffff80005f6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005f6d:	48 8b 3d 7c 61 00 00 	mov    0x617c(%rip),%rdi        # ffffffff8000c0f0 <_ZN3Hal16ExceptionStringsE+0xf0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f74:	56                   	push   %rsi
ffffffff80005f75:	51                   	push   %rcx
ffffffff80005f76:	52                   	push   %rdx
ffffffff80005f77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005f78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005f7d:	c6 44 24 70 1e       	movb   $0x1e,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f82:	fc                   	cld
ffffffff80005f83:	e8 28 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f88:	58                   	pop    %rax
ffffffff80005f89:	5a                   	pop    %rdx
ffffffff80005f8a:	59                   	pop    %rcx
ffffffff80005f8b:	5e                   	pop    %rsi
ffffffff80005f8c:	5f                   	pop    %rdi
ffffffff80005f8d:	41 58                	pop    %r8
ffffffff80005f8f:	41 59                	pop    %r9
ffffffff80005f91:	41 5a                	pop    %r10
ffffffff80005f93:	41 5b                	pop    %r11
ffffffff80005f95:	48 cf                	iretq
ffffffff80005f97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f9e:	00 00 

ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>:
        };
    }

    template<int I, int N>
    struct SetHandler {
        static void run() {
ffffffff80005fa0:	f3 0f 1e fa          	endbr64
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80005fa4:	48 8b 05 f7 b3 0d 00 	mov    0xdb3f7(%rip),%rax        # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2>
        uint64_t offset = (uint64_t)handler;
ffffffff80005fab:	48 c7 c2 a0 5d 00 80 	mov    $0xffffffff80005da0,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fb2:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005fb5:	66 89 90 70 01 00 00 	mov    %dx,0x170(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80005fbc:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fc0:	48 c1 ee 10          	shr    $0x10,%rsi
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80005fc4:	48 8d 88 e0 01 00 00 	lea    0x1e0(%rax),%rcx
        *ptr = InterruptDescriptor {
ffffffff80005fcb:	89 90 78 01 00 00    	mov    %edx,0x178(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80005fd1:	48 c7 c2 e0 5d 00 80 	mov    $0xffffffff80005de0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80005fd8:	66 89 b0 76 01 00 00 	mov    %si,0x176(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fdf:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005fe2:	66 89 90 80 01 00 00 	mov    %dx,0x180(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80005fe9:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fed:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005ff1:	89 90 88 01 00 00    	mov    %edx,0x188(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80005ff7:	48 c7 c2 20 5e 00 80 	mov    $0xffffffff80005e20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80005ffe:	66 89 b0 86 01 00 00 	mov    %si,0x186(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006005:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006008:	66 89 90 90 01 00 00 	mov    %dx,0x190(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000600f:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006013:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006017:	89 90 98 01 00 00    	mov    %edx,0x198(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000601d:	48 c7 c2 60 5e 00 80 	mov    $0xffffffff80005e60,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006024:	66 89 b0 96 01 00 00 	mov    %si,0x196(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000602b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000602e:	66 89 90 a0 01 00 00 	mov    %dx,0x1a0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006035:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006039:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000603d:	89 90 a8 01 00 00    	mov    %edx,0x1a8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006043:	48 c7 c2 a0 5e 00 80 	mov    $0xffffffff80005ea0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000604a:	66 89 b0 a6 01 00 00 	mov    %si,0x1a6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006051:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006054:	66 89 90 b0 01 00 00 	mov    %dx,0x1b0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000605b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000605f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006063:	89 90 b8 01 00 00    	mov    %edx,0x1b8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006069:	48 c7 c2 e0 5e 00 80 	mov    $0xffffffff80005ee0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006070:	66 89 b0 b6 01 00 00 	mov    %si,0x1b6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006077:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000607a:	66 89 90 c0 01 00 00 	mov    %dx,0x1c0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006081:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006085:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006089:	89 90 c8 01 00 00    	mov    %edx,0x1c8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000608f:	48 c7 c2 20 5f 00 80 	mov    $0xffffffff80005f20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006096:	66 89 b0 c6 01 00 00 	mov    %si,0x1c6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000609d:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800060a0:	66 89 90 d0 01 00 00 	mov    %dx,0x1d0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800060a7:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800060ab:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800060af:	c7 80 72 01 00 00 08 	movl   $0x8f000008,0x172(%rax)
ffffffff800060b6:	00 00 8f 
ffffffff800060b9:	c7 80 7c 01 00 00 00 	movl   $0x0,0x17c(%rax)
ffffffff800060c0:	00 00 00 
ffffffff800060c3:	c7 80 82 01 00 00 08 	movl   $0x8f000008,0x182(%rax)
ffffffff800060ca:	00 00 8f 
ffffffff800060cd:	c7 80 8c 01 00 00 00 	movl   $0x0,0x18c(%rax)
ffffffff800060d4:	00 00 00 
ffffffff800060d7:	c7 80 92 01 00 00 08 	movl   $0x8f000008,0x192(%rax)
ffffffff800060de:	00 00 8f 
ffffffff800060e1:	c7 80 9c 01 00 00 00 	movl   $0x0,0x19c(%rax)
ffffffff800060e8:	00 00 00 
ffffffff800060eb:	c7 80 a2 01 00 00 08 	movl   $0x8f000008,0x1a2(%rax)
ffffffff800060f2:	00 00 8f 
ffffffff800060f5:	c7 80 ac 01 00 00 00 	movl   $0x0,0x1ac(%rax)
ffffffff800060fc:	00 00 00 
ffffffff800060ff:	c7 80 b2 01 00 00 08 	movl   $0x8f000008,0x1b2(%rax)
ffffffff80006106:	00 00 8f 
ffffffff80006109:	c7 80 bc 01 00 00 00 	movl   $0x0,0x1bc(%rax)
ffffffff80006110:	00 00 00 
ffffffff80006113:	c7 80 c2 01 00 00 08 	movl   $0x8f000008,0x1c2(%rax)
ffffffff8000611a:	00 00 8f 
ffffffff8000611d:	c7 80 cc 01 00 00 00 	movl   $0x0,0x1cc(%rax)
ffffffff80006124:	00 00 00 
ffffffff80006127:	c7 80 d2 01 00 00 08 	movl   $0x8f000008,0x1d2(%rax)
ffffffff8000612e:	00 00 8f 
ffffffff80006131:	89 90 d8 01 00 00    	mov    %edx,0x1d8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006137:	48 c7 c2 60 5f 00 80 	mov    $0xffffffff80005f60,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000613e:	66 89 90 e0 01 00 00 	mov    %dx,0x1e0(%rax)
ffffffff80006145:	66 89 b0 d6 01 00 00 	mov    %si,0x1d6(%rax)
ffffffff8000614c:	c7 80 dc 01 00 00 00 	movl   $0x0,0x1dc(%rax)
ffffffff80006153:	00 00 00 
ffffffff80006156:	c7 80 e2 01 00 00 08 	movl   $0x8f000008,0x1e2(%rax)
ffffffff8000615d:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006160:	48 89 d0             	mov    %rdx,%rax
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006163:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006167:	48 c1 e8 10          	shr    $0x10,%rax
        *ptr = InterruptDescriptor {
ffffffff8000616b:	89 51 08             	mov    %edx,0x8(%rcx)
ffffffff8000616e:	66 89 41 06          	mov    %ax,0x6(%rcx)
ffffffff80006172:	c7 41 0c 00 00 00 00 	movl   $0x0,0xc(%rcx)
            IDTEncodeInterrupt(I, (void*)&ExceptionHandler<I>, TrapGate);
            SetHandler<I+1,N>::run();
        }
ffffffff80006179:	c3                   	ret
ffffffff8000617a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>:
        static void run() {
ffffffff80006180:	f3 0f 1e fa          	endbr64
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80006184:	48 8b 05 17 b2 0d 00 	mov    0xdb217(%rip),%rax        # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2>
        uint64_t offset = (uint64_t)handler;
ffffffff8000618b:	48 c7 c2 a0 5a 00 80 	mov    $0xffffffff80005aa0,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006192:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006195:	66 89 90 b0 00 00 00 	mov    %dx,0xb0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000619c:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061a0:	48 c1 ee 10          	shr    $0x10,%rsi
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff800061a4:	48 8d 88 60 01 00 00 	lea    0x160(%rax),%rcx
        *ptr = InterruptDescriptor {
ffffffff800061ab:	89 90 b8 00 00 00    	mov    %edx,0xb8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061b1:	48 c7 c2 e0 5a 00 80 	mov    $0xffffffff80005ae0,%rdx
        *ptr = InterruptDescriptor {
ffffffff800061b8:	66 89 b0 b6 00 00 00 	mov    %si,0xb6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061bf:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061c2:	66 89 90 c0 00 00 00 	mov    %dx,0xc0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800061c9:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061cd:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061d1:	89 90 c8 00 00 00    	mov    %edx,0xc8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061d7:	48 c7 c2 20 5b 00 80 	mov    $0xffffffff80005b20,%rdx
        *ptr = InterruptDescriptor {
ffffffff800061de:	66 89 b0 c6 00 00 00 	mov    %si,0xc6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061e5:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061e8:	66 89 90 d0 00 00 00 	mov    %dx,0xd0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800061ef:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061f3:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061f7:	89 90 d8 00 00 00    	mov    %edx,0xd8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061fd:	48 c7 c2 60 5b 00 80 	mov    $0xffffffff80005b60,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006204:	66 89 b0 d6 00 00 00 	mov    %si,0xd6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000620b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000620e:	66 89 90 e0 00 00 00 	mov    %dx,0xe0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006215:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006219:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000621d:	89 90 e8 00 00 00    	mov    %edx,0xe8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006223:	48 c7 c2 a0 5b 00 80 	mov    $0xffffffff80005ba0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000622a:	66 89 b0 e6 00 00 00 	mov    %si,0xe6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006231:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006234:	66 89 90 f0 00 00 00 	mov    %dx,0xf0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000623b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000623f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006243:	89 90 f8 00 00 00    	mov    %edx,0xf8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006249:	48 c7 c2 e0 5b 00 80 	mov    $0xffffffff80005be0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006250:	66 89 b0 f6 00 00 00 	mov    %si,0xf6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006257:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000625a:	66 89 90 00 01 00 00 	mov    %dx,0x100(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006261:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006265:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006269:	89 90 08 01 00 00    	mov    %edx,0x108(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000626f:	48 c7 c2 20 5c 00 80 	mov    $0xffffffff80005c20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006276:	66 89 b0 06 01 00 00 	mov    %si,0x106(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000627d:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006280:	66 89 90 10 01 00 00 	mov    %dx,0x110(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006287:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000628b:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000628f:	c7 80 b2 00 00 00 08 	movl   $0x8f000008,0xb2(%rax)
ffffffff80006296:	00 00 8f 
ffffffff80006299:	c7 80 bc 00 00 00 00 	movl   $0x0,0xbc(%rax)
ffffffff800062a0:	00 00 00 
ffffffff800062a3:	c7 80 c2 00 00 00 08 	movl   $0x8f000008,0xc2(%rax)
ffffffff800062aa:	00 00 8f 
ffffffff800062ad:	c7 80 cc 00 00 00 00 	movl   $0x0,0xcc(%rax)
ffffffff800062b4:	00 00 00 
ffffffff800062b7:	c7 80 d2 00 00 00 08 	movl   $0x8f000008,0xd2(%rax)
ffffffff800062be:	00 00 8f 
ffffffff800062c1:	c7 80 dc 00 00 00 00 	movl   $0x0,0xdc(%rax)
ffffffff800062c8:	00 00 00 
ffffffff800062cb:	c7 80 e2 00 00 00 08 	movl   $0x8f000008,0xe2(%rax)
ffffffff800062d2:	00 00 8f 
ffffffff800062d5:	c7 80 ec 00 00 00 00 	movl   $0x0,0xec(%rax)
ffffffff800062dc:	00 00 00 
ffffffff800062df:	c7 80 f2 00 00 00 08 	movl   $0x8f000008,0xf2(%rax)
ffffffff800062e6:	00 00 8f 
ffffffff800062e9:	c7 80 fc 00 00 00 00 	movl   $0x0,0xfc(%rax)
ffffffff800062f0:	00 00 00 
ffffffff800062f3:	c7 80 02 01 00 00 08 	movl   $0x8f000008,0x102(%rax)
ffffffff800062fa:	00 00 8f 
ffffffff800062fd:	c7 80 0c 01 00 00 00 	movl   $0x0,0x10c(%rax)
ffffffff80006304:	00 00 00 
ffffffff80006307:	c7 80 12 01 00 00 08 	movl   $0x8f000008,0x112(%rax)
ffffffff8000630e:	00 00 8f 
ffffffff80006311:	89 90 18 01 00 00    	mov    %edx,0x118(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006317:	48 c7 c2 60 5c 00 80 	mov    $0xffffffff80005c60,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000631e:	66 89 b0 16 01 00 00 	mov    %si,0x116(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006325:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006328:	66 89 90 20 01 00 00 	mov    %dx,0x120(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000632f:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006333:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006337:	89 90 28 01 00 00    	mov    %edx,0x128(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000633d:	48 c7 c2 a0 5c 00 80 	mov    $0xffffffff80005ca0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006344:	66 89 b0 26 01 00 00 	mov    %si,0x126(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000634b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000634e:	66 89 90 30 01 00 00 	mov    %dx,0x130(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006355:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006359:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000635d:	89 90 38 01 00 00    	mov    %edx,0x138(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006363:	48 c7 c2 e0 5c 00 80 	mov    $0xffffffff80005ce0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000636a:	66 89 b0 36 01 00 00 	mov    %si,0x136(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006371:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006374:	66 89 90 40 01 00 00 	mov    %dx,0x140(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000637b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000637f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006383:	89 90 48 01 00 00    	mov    %edx,0x148(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006389:	48 c7 c2 20 5d 00 80 	mov    $0xffffffff80005d20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006390:	66 89 b0 46 01 00 00 	mov    %si,0x146(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006397:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000639a:	66 89 90 50 01 00 00 	mov    %dx,0x150(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800063a1:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800063a5:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800063a9:	89 90 58 01 00 00    	mov    %edx,0x158(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800063af:	48 c7 c2 60 5d 00 80 	mov    $0xffffffff80005d60,%rdx
        *ptr = InterruptDescriptor {
ffffffff800063b6:	66 89 90 60 01 00 00 	mov    %dx,0x160(%rax)
ffffffff800063bd:	c7 80 1c 01 00 00 00 	movl   $0x0,0x11c(%rax)
ffffffff800063c4:	00 00 00 
ffffffff800063c7:	c7 80 22 01 00 00 08 	movl   $0x8f000008,0x122(%rax)
ffffffff800063ce:	00 00 8f 
ffffffff800063d1:	c7 80 2c 01 00 00 00 	movl   $0x0,0x12c(%rax)
ffffffff800063d8:	00 00 00 
ffffffff800063db:	c7 80 32 01 00 00 08 	movl   $0x8f000008,0x132(%rax)
ffffffff800063e2:	00 00 8f 
ffffffff800063e5:	c7 80 3c 01 00 00 00 	movl   $0x0,0x13c(%rax)
ffffffff800063ec:	00 00 00 
ffffffff800063ef:	c7 80 42 01 00 00 08 	movl   $0x8f000008,0x142(%rax)
ffffffff800063f6:	00 00 8f 
ffffffff800063f9:	c7 80 4c 01 00 00 00 	movl   $0x0,0x14c(%rax)
ffffffff80006400:	00 00 00 
ffffffff80006403:	c7 80 52 01 00 00 08 	movl   $0x8f000008,0x152(%rax)
ffffffff8000640a:	00 00 8f 
ffffffff8000640d:	66 89 b0 56 01 00 00 	mov    %si,0x156(%rax)
ffffffff80006414:	c7 80 5c 01 00 00 00 	movl   $0x0,0x15c(%rax)
ffffffff8000641b:	00 00 00 
ffffffff8000641e:	c7 80 62 01 00 00 08 	movl   $0x8f000008,0x162(%rax)
ffffffff80006425:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006428:	48 89 d0             	mov    %rdx,%rax
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000642b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000642f:	48 c1 e8 10          	shr    $0x10,%rax
        *ptr = InterruptDescriptor {
ffffffff80006433:	89 51 08             	mov    %edx,0x8(%rcx)
ffffffff80006436:	66 89 41 06          	mov    %ax,0x6(%rcx)
ffffffff8000643a:	c7 41 0c 00 00 00 00 	movl   $0x0,0xc(%rcx)
            SetHandler<I+1,N>::run();
ffffffff80006441:	e9 5a fb ff ff       	jmp    ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>
ffffffff80006446:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000644d:	00 00 00 

ffffffff80006450 <_ZN3Hal13IDTInitializeEv>:
    };

    template<int N>
    struct SetHandler<N,N> {static void run() {}};

    void IDTInitialize() {
ffffffff80006450:	f3 0f 1e fa          	endbr64
ffffffff80006454:	48 83 ec 08          	sub    $0x8,%rsp
        IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096);
ffffffff80006458:	48 8b 3d 71 b3 0d 00 	mov    0xdb371(%rip),%rdi        # ffffffff800e17d0 <_ZN6Memory6g_heapE>
ffffffff8000645f:	be 00 10 00 00       	mov    $0x1000,%esi
ffffffff80006464:	e8 57 07 00 00       	call   ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>
        IDTR.Limit = 0x0FF;
ffffffff80006469:	b8 ff 00 00 00       	mov    $0xff,%eax
        IDTR.Base = (uint64_t)&IDT;
ffffffff8000646e:	48 c7 05 29 af 0d 00 	movq   $0xffffffff800e13b0,0xdaf29(%rip)        # ffffffff800e13a2 <_ZN3Hal4IDTRE+0x2>
ffffffff80006475:	b0 13 0e 80 
        IDTR.Limit = 0x0FF;
ffffffff80006479:	66 89 05 20 af 0d 00 	mov    %ax,0xdaf20(%rip)        # ffffffff800e13a0 <_ZN3Hal4IDTRE>
        uint64_t offset = (uint64_t)handler;
ffffffff80006480:	48 c7 c0 e0 57 00 80 	mov    $0xffffffff800057e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006487:	66 89 05 22 af 0d 00 	mov    %ax,0xdaf22(%rip)        # ffffffff800e13b0 <_ZN3Hal3IDTE>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000648e:	48 89 c2             	mov    %rax,%rdx
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006491:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006495:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006499:	89 05 19 af 0d 00    	mov    %eax,0xdaf19(%rip)        # ffffffff800e13b8 <_ZN3Hal3IDTE+0x8>
        uint64_t offset = (uint64_t)handler;
ffffffff8000649f:	48 c7 c0 20 58 00 80 	mov    $0xffffffff80005820,%rax
        *ptr = InterruptDescriptor {
ffffffff800064a6:	66 89 15 09 af 0d 00 	mov    %dx,0xdaf09(%rip)        # ffffffff800e13b6 <_ZN3Hal3IDTE+0x6>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064ad:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064b0:	66 89 05 09 af 0d 00 	mov    %ax,0xdaf09(%rip)        # ffffffff800e13c0 <_ZN3Lib6outputE>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800064b7:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064bb:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064bf:	89 05 03 af 0d 00    	mov    %eax,0xdaf03(%rip)        # ffffffff800e13c8 <_ZN3Lib6outputE+0x8>
        uint64_t offset = (uint64_t)handler;
ffffffff800064c5:	48 c7 c0 60 58 00 80 	mov    $0xffffffff80005860,%rax
        *ptr = InterruptDescriptor {
ffffffff800064cc:	66 89 15 f3 ae 0d 00 	mov    %dx,0xdaef3(%rip)        # ffffffff800e13c6 <_ZN3Lib6outputE+0x6>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064d3:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064d6:	66 89 05 f3 ae 0d 00 	mov    %ax,0xdaef3(%rip)        # ffffffff800e13d0 <_ZN3Lib6outputE+0x10>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800064dd:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064e1:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064e5:	89 05 ed ae 0d 00    	mov    %eax,0xdaeed(%rip)        # ffffffff800e13d8 <_ZN3Lib6outputE+0x18>
        uint64_t offset = (uint64_t)handler;
ffffffff800064eb:	48 c7 c0 a0 58 00 80 	mov    $0xffffffff800058a0,%rax
        *ptr = InterruptDescriptor {
ffffffff800064f2:	66 89 15 dd ae 0d 00 	mov    %dx,0xdaedd(%rip)        # ffffffff800e13d6 <_ZN3Lib6outputE+0x16>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064f9:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064fc:	66 89 05 dd ae 0d 00 	mov    %ax,0xdaedd(%rip)        # ffffffff800e13e0 <_ZN3Lib6outputE+0x20>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006503:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006507:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000650b:	89 05 d7 ae 0d 00    	mov    %eax,0xdaed7(%rip)        # ffffffff800e13e8 <_ZN3Lib6outputE+0x28>
        uint64_t offset = (uint64_t)handler;
ffffffff80006511:	48 c7 c0 e0 58 00 80 	mov    $0xffffffff800058e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006518:	66 89 15 c7 ae 0d 00 	mov    %dx,0xdaec7(%rip)        # ffffffff800e13e6 <_ZN3Lib6outputE+0x26>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000651f:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006522:	66 89 05 c7 ae 0d 00 	mov    %ax,0xdaec7(%rip)        # ffffffff800e13f0 <_ZN3Lib6outputE+0x30>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006529:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000652d:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006531:	89 05 c1 ae 0d 00    	mov    %eax,0xdaec1(%rip)        # ffffffff800e13f8 <_ZN3Lib6outputE+0x38>
        uint64_t offset = (uint64_t)handler;
ffffffff80006537:	48 c7 c0 20 59 00 80 	mov    $0xffffffff80005920,%rax
        *ptr = InterruptDescriptor {
ffffffff8000653e:	66 89 15 b1 ae 0d 00 	mov    %dx,0xdaeb1(%rip)        # ffffffff800e13f6 <_ZN3Lib6outputE+0x36>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006545:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006548:	66 89 05 b1 ae 0d 00 	mov    %ax,0xdaeb1(%rip)        # ffffffff800e1400 <_ZN3Lib6outputE+0x40>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000654f:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006553:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006557:	89 05 ab ae 0d 00    	mov    %eax,0xdaeab(%rip)        # ffffffff800e1408 <_ZN3Lib6outputE+0x48>
        uint64_t offset = (uint64_t)handler;
ffffffff8000655d:	48 c7 c0 60 59 00 80 	mov    $0xffffffff80005960,%rax
        *ptr = InterruptDescriptor {
ffffffff80006564:	66 89 15 9b ae 0d 00 	mov    %dx,0xdae9b(%rip)        # ffffffff800e1406 <_ZN3Lib6outputE+0x46>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000656b:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000656e:	c7 05 3a ae 0d 00 08 	movl   $0x8f000008,0xdae3a(%rip)        # ffffffff800e13b2 <_ZN3Hal3IDTE+0x2>
ffffffff80006575:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006578:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000657c:	c7 05 36 ae 0d 00 00 	movl   $0x0,0xdae36(%rip)        # ffffffff800e13bc <_ZN3Hal3IDTE+0xc>
ffffffff80006583:	00 00 00 
ffffffff80006586:	c7 05 32 ae 0d 00 08 	movl   $0x8f000008,0xdae32(%rip)        # ffffffff800e13c2 <_ZN3Lib6outputE+0x2>
ffffffff8000658d:	00 00 8f 
ffffffff80006590:	c7 05 32 ae 0d 00 00 	movl   $0x0,0xdae32(%rip)        # ffffffff800e13cc <_ZN3Lib6outputE+0xc>
ffffffff80006597:	00 00 00 
ffffffff8000659a:	c7 05 2e ae 0d 00 08 	movl   $0x8f000008,0xdae2e(%rip)        # ffffffff800e13d2 <_ZN3Lib6outputE+0x12>
ffffffff800065a1:	00 00 8f 
ffffffff800065a4:	c7 05 2e ae 0d 00 00 	movl   $0x0,0xdae2e(%rip)        # ffffffff800e13dc <_ZN3Lib6outputE+0x1c>
ffffffff800065ab:	00 00 00 
ffffffff800065ae:	c7 05 2a ae 0d 00 08 	movl   $0x8f000008,0xdae2a(%rip)        # ffffffff800e13e2 <_ZN3Lib6outputE+0x22>
ffffffff800065b5:	00 00 8f 
ffffffff800065b8:	c7 05 2a ae 0d 00 00 	movl   $0x0,0xdae2a(%rip)        # ffffffff800e13ec <_ZN3Lib6outputE+0x2c>
ffffffff800065bf:	00 00 00 
ffffffff800065c2:	c7 05 26 ae 0d 00 08 	movl   $0x8f000008,0xdae26(%rip)        # ffffffff800e13f2 <_ZN3Lib6outputE+0x32>
ffffffff800065c9:	00 00 8f 
ffffffff800065cc:	c7 05 26 ae 0d 00 00 	movl   $0x0,0xdae26(%rip)        # ffffffff800e13fc <_ZN3Lib6outputE+0x3c>
ffffffff800065d3:	00 00 00 
ffffffff800065d6:	c7 05 22 ae 0d 00 08 	movl   $0x8f000008,0xdae22(%rip)        # ffffffff800e1402 <_ZN3Lib6outputE+0x42>
ffffffff800065dd:	00 00 8f 
ffffffff800065e0:	c7 05 22 ae 0d 00 00 	movl   $0x0,0xdae22(%rip)        # ffffffff800e140c <_ZN3Lib6outputE+0x4c>
ffffffff800065e7:	00 00 00 
ffffffff800065ea:	66 89 05 1f ae 0d 00 	mov    %ax,0xdae1f(%rip)        # ffffffff800e1410 <_ZN3Lib6outputE+0x50>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800065f1:	48 c1 e8 20          	shr    $0x20,%rax
        *ptr = InterruptDescriptor {
ffffffff800065f5:	89 05 1d ae 0d 00    	mov    %eax,0xdae1d(%rip)        # ffffffff800e1418 <_ZN3Lib6outputE+0x58>
        uint64_t offset = (uint64_t)handler;
ffffffff800065fb:	48 c7 c0 a0 59 00 80 	mov    $0xffffffff800059a0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006602:	66 89 15 0d ae 0d 00 	mov    %dx,0xdae0d(%rip)        # ffffffff800e1416 <_ZN3Lib6outputE+0x56>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006609:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000660c:	66 89 05 0d ae 0d 00 	mov    %ax,0xdae0d(%rip)        # ffffffff800e1420 <_ZN3Lib6outputE+0x60>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006613:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006617:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000661b:	89 05 07 ae 0d 00    	mov    %eax,0xdae07(%rip)        # ffffffff800e1428 <_ZN3Lib6outputE+0x68>
        uint64_t offset = (uint64_t)handler;
ffffffff80006621:	48 c7 c0 e0 59 00 80 	mov    $0xffffffff800059e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006628:	66 89 15 f7 ad 0d 00 	mov    %dx,0xdadf7(%rip)        # ffffffff800e1426 <_ZN3Lib6outputE+0x66>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000662f:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006632:	66 89 05 f7 ad 0d 00 	mov    %ax,0xdadf7(%rip)        # ffffffff800e1430 <_ZN3Lib6outputE+0x70>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006639:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000663d:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006641:	89 05 f1 ad 0d 00    	mov    %eax,0xdadf1(%rip)        # ffffffff800e1438 <_ZN3Lib6outputE+0x78>
        uint64_t offset = (uint64_t)handler;
ffffffff80006647:	48 c7 c0 20 5a 00 80 	mov    $0xffffffff80005a20,%rax
        *ptr = InterruptDescriptor {
ffffffff8000664e:	66 89 15 e1 ad 0d 00 	mov    %dx,0xdade1(%rip)        # ffffffff800e1436 <_ZN3Lib6outputE+0x76>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006655:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006658:	66 89 05 e1 ad 0d 00 	mov    %ax,0xdade1(%rip)        # ffffffff800e1440 <_ZN3Lib6outputE+0x80>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000665f:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006663:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006667:	89 05 db ad 0d 00    	mov    %eax,0xdaddb(%rip)        # ffffffff800e1448 <_ZN3Lib6outputE+0x88>
        uint64_t offset = (uint64_t)handler;
ffffffff8000666d:	48 c7 c0 60 5a 00 80 	mov    $0xffffffff80005a60,%rax
        *ptr = InterruptDescriptor {
ffffffff80006674:	66 89 15 cb ad 0d 00 	mov    %dx,0xdadcb(%rip)        # ffffffff800e1446 <_ZN3Lib6outputE+0x86>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000667b:	48 89 c2             	mov    %rax,%rdx
ffffffff8000667e:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006682:	66 89 05 c7 ad 0d 00 	mov    %ax,0xdadc7(%rip)        # ffffffff800e1450 <_ZN3Lib6outputE+0x90>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006689:	48 c1 e8 20          	shr    $0x20,%rax
        *ptr = InterruptDescriptor {
ffffffff8000668d:	66 89 15 c2 ad 0d 00 	mov    %dx,0xdadc2(%rip)        # ffffffff800e1456 <_ZN3Lib6outputE+0x96>
ffffffff80006694:	89 05 be ad 0d 00    	mov    %eax,0xdadbe(%rip)        # ffffffff800e1458 <_ZN3Lib6outputE+0x98>
ffffffff8000669a:	c7 05 6e ad 0d 00 08 	movl   $0x8f000008,0xdad6e(%rip)        # ffffffff800e1412 <_ZN3Lib6outputE+0x52>
ffffffff800066a1:	00 00 8f 
ffffffff800066a4:	c7 05 6e ad 0d 00 00 	movl   $0x0,0xdad6e(%rip)        # ffffffff800e141c <_ZN3Lib6outputE+0x5c>
ffffffff800066ab:	00 00 00 
ffffffff800066ae:	c7 05 6a ad 0d 00 08 	movl   $0x8f000008,0xdad6a(%rip)        # ffffffff800e1422 <_ZN3Lib6outputE+0x62>
ffffffff800066b5:	00 00 8f 
ffffffff800066b8:	c7 05 6a ad 0d 00 00 	movl   $0x0,0xdad6a(%rip)        # ffffffff800e142c <_ZN3Lib6outputE+0x6c>
ffffffff800066bf:	00 00 00 
ffffffff800066c2:	c7 05 66 ad 0d 00 08 	movl   $0x8f000008,0xdad66(%rip)        # ffffffff800e1432 <_ZN3Lib6outputE+0x72>
ffffffff800066c9:	00 00 8f 
ffffffff800066cc:	c7 05 66 ad 0d 00 00 	movl   $0x0,0xdad66(%rip)        # ffffffff800e143c <_ZN3Lib6outputE+0x7c>
ffffffff800066d3:	00 00 00 
ffffffff800066d6:	c7 05 62 ad 0d 00 08 	movl   $0x8f000008,0xdad62(%rip)        # ffffffff800e1442 <_ZN3Lib6outputE+0x82>
ffffffff800066dd:	00 00 8f 
ffffffff800066e0:	c7 05 62 ad 0d 00 00 	movl   $0x0,0xdad62(%rip)        # ffffffff800e144c <_ZN3Lib6outputE+0x8c>
ffffffff800066e7:	00 00 00 
ffffffff800066ea:	c7 05 5e ad 0d 00 08 	movl   $0x8f000008,0xdad5e(%rip)        # ffffffff800e1452 <_ZN3Lib6outputE+0x92>
ffffffff800066f1:	00 00 8f 
ffffffff800066f4:	c7 05 5e ad 0d 00 00 	movl   $0x0,0xdad5e(%rip)        # ffffffff800e145c <_ZN3Lib6outputE+0x9c>
ffffffff800066fb:	00 00 00 
            SetHandler<I+1,N>::run();
ffffffff800066fe:	e8 7d fa ff ff       	call   ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>
ffffffff80006703:	48 c7 c7 98 bd 00 80 	mov    $0xffffffff8000bd98,%rdi
ffffffff8000670a:	e8 91 08 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000670f:	48 c7 c7 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rdi
ffffffff80006716:	e8 85 08 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
        asm("lidt %0" : : "m"(idtr));
ffffffff8000671b:	0f 01 1d 7e ac 0d 00 	lidt   0xdac7e(%rip)        # ffffffff800e13a0 <_ZN3Hal4IDTRE>
ffffffff80006722:	48 c7 c7 d8 bd 00 80 	mov    $0xffffffff8000bdd8,%rdi
ffffffff80006729:	e8 72 08 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000672e:	48 c7 c7 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rdi
        kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n";

        LoadIDT(IDTR);

        kout << "HardwareAbstraction: Loaded new IDT" << "\n";
    }
ffffffff80006735:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006739:	e9 62 08 00 00       	jmp    ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
ffffffff8000673e:	66 90                	xchg   %ax,%ax

ffffffff80006740 <memcpy>:
// They CAN be moved to a different .cpp file.
#include <cstdint>

extern "C" {

    void *memcpy(void *dest, const void *src, std::size_t n) {
ffffffff80006740:	f3 0f 1e fa          	endbr64
ffffffff80006744:	48 89 f8             	mov    %rdi,%rax
        std::uint8_t *pdest = static_cast<std::uint8_t *>(dest);
        const std::uint8_t *psrc = static_cast<const std::uint8_t *>(src);
    
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006747:	48 85 d2             	test   %rdx,%rdx
ffffffff8000674a:	74 16                	je     ffffffff80006762 <memcpy+0x22>
ffffffff8000674c:	31 c9                	xor    %ecx,%ecx
ffffffff8000674e:	66 90                	xchg   %ax,%ax
            pdest[i] = psrc[i];
ffffffff80006750:	44 0f b6 04 0e       	movzbl (%rsi,%rcx,1),%r8d
ffffffff80006755:	44 88 04 08          	mov    %r8b,(%rax,%rcx,1)
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006759:	48 83 c1 01          	add    $0x1,%rcx
ffffffff8000675d:	48 39 ca             	cmp    %rcx,%rdx
ffffffff80006760:	75 ee                	jne    ffffffff80006750 <memcpy+0x10>
        }
    
        return dest;
    }
ffffffff80006762:	c3                   	ret
ffffffff80006763:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000676a:	00 00 00 
ffffffff8000676d:	0f 1f 00             	nopl   (%rax)

ffffffff80006770 <memset>:
    
    void *memset(void *s, int c, std::size_t n) {
ffffffff80006770:	f3 0f 1e fa          	endbr64
ffffffff80006774:	48 89 f8             	mov    %rdi,%rax
ffffffff80006777:	48 89 f9             	mov    %rdi,%rcx
ffffffff8000677a:	48 8d 3c 3a          	lea    (%rdx,%rdi,1),%rdi
        std::uint8_t *p = static_cast<std::uint8_t *>(s);
    
        for (std::size_t i = 0; i < n; i++) {
            p[i] = static_cast<uint8_t>(c);
ffffffff8000677e:	41 89 f0             	mov    %esi,%r8d
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006781:	48 85 d2             	test   %rdx,%rdx
ffffffff80006784:	74 2a                	je     ffffffff800067b0 <memset+0x40>
ffffffff80006786:	48 89 fa             	mov    %rdi,%rdx
ffffffff80006789:	48 29 c2             	sub    %rax,%rdx
ffffffff8000678c:	83 e2 01             	and    $0x1,%edx
ffffffff8000678f:	74 0f                	je     ffffffff800067a0 <memset+0x30>
ffffffff80006791:	48 8d 48 01          	lea    0x1(%rax),%rcx
            p[i] = static_cast<uint8_t>(c);
ffffffff80006795:	40 88 30             	mov    %sil,(%rax)
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006798:	48 39 f9             	cmp    %rdi,%rcx
ffffffff8000679b:	74 14                	je     ffffffff800067b1 <memset+0x41>
ffffffff8000679d:	0f 1f 00             	nopl   (%rax)
            p[i] = static_cast<uint8_t>(c);
ffffffff800067a0:	44 88 01             	mov    %r8b,(%rcx)
        for (std::size_t i = 0; i < n; i++) {
ffffffff800067a3:	48 83 c1 02          	add    $0x2,%rcx
            p[i] = static_cast<uint8_t>(c);
ffffffff800067a7:	44 88 41 ff          	mov    %r8b,-0x1(%rcx)
        for (std::size_t i = 0; i < n; i++) {
ffffffff800067ab:	48 39 f9             	cmp    %rdi,%rcx
ffffffff800067ae:	75 f0                	jne    ffffffff800067a0 <memset+0x30>
        }
    
        return s;
    }
ffffffff800067b0:	c3                   	ret
ffffffff800067b1:	c3                   	ret
ffffffff800067b2:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800067b9:	00 00 00 
ffffffff800067bc:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>:
            str[si++] = tmp[rdi--];
        str[si] = '\0';
        return str;
    }

    char *u64_2_basestr(uint64_t num, size_t radix)
ffffffff800067c0:	48 81 ec 20 01 00 00 	sub    $0x120,%rsp

        if (!num) {
            return (char *)"0";
        }

        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800067c7:	48 b8 30 31 32 33 34 	movabs $0x3736353433323130,%rax
ffffffff800067ce:	35 36 37 
ffffffff800067d1:	48 89 44 24 0d       	mov    %rax,0xd(%rsp)
ffffffff800067d6:	48 b8 38 39 41 42 43 	movabs $0x4645444342413938,%rax
ffffffff800067dd:	44 45 46 
ffffffff800067e0:	48 89 44 24 15       	mov    %rax,0x15(%rsp)

        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800067e5:	48 8d 46 fe          	lea    -0x2(%rsi),%rax
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800067e9:	c7 44 24 1c 46 47 48 	movl   $0x484746,0x1c(%rsp)
ffffffff800067f0:	00 
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800067f1:	48 83 f8 10          	cmp    $0x10,%rax
ffffffff800067f5:	0f 87 8d 00 00 00    	ja     ffffffff80006888 <_ZN3Lib13u64_2_basestrEmm.part.0+0xc8>

        int si = 0;

        char tmp[256];
        int rdi = -1;
        while (num)
ffffffff800067fb:	45 31 c0             	xor    %r8d,%r8d
ffffffff800067fe:	48 c7 c1 c0 13 0e 80 	mov    $0xffffffff800e13c0,%rcx
ffffffff80006805:	48 85 ff             	test   %rdi,%rdi
ffffffff80006808:	74 65                	je     ffffffff8000686f <_ZN3Lib13u64_2_basestrEmm.part.0+0xaf>
ffffffff8000680a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        {
            tmp[++rdi] = base[num % radix];
ffffffff80006810:	48 89 f8             	mov    %rdi,%rax
ffffffff80006813:	31 d2                	xor    %edx,%edx
ffffffff80006815:	4c 89 c1             	mov    %r8,%rcx
ffffffff80006818:	48 f7 f6             	div    %rsi
ffffffff8000681b:	0f b6 54 14 0d       	movzbl 0xd(%rsp,%rdx,1),%edx
ffffffff80006820:	42 88 54 04 20       	mov    %dl,0x20(%rsp,%r8,1)
            num /= radix;
ffffffff80006825:	48 89 fa             	mov    %rdi,%rdx
        while (num)
ffffffff80006828:	4d 8d 40 01          	lea    0x1(%r8),%r8
            num /= radix;
ffffffff8000682c:	48 89 c7             	mov    %rax,%rdi
        while (num)
ffffffff8000682f:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006832:	73 dc                	jae    ffffffff80006810 <_ZN3Lib13u64_2_basestrEmm.part.0+0x50>
ffffffff80006834:	48 63 c1             	movslq %ecx,%rax
ffffffff80006837:	48 8d 7c 24 20       	lea    0x20(%rsp),%rdi
            tmp[++rdi] = base[num % radix];
ffffffff8000683c:	31 d2                	xor    %edx,%edx
ffffffff8000683e:	48 01 f8             	add    %rdi,%rax
ffffffff80006841:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        }
        while (rdi >= 0)
            str[si++] = tmp[rdi--];
ffffffff80006848:	0f b6 30             	movzbl (%rax),%esi
        while (rdi >= 0)
ffffffff8000684b:	48 83 e8 01          	sub    $0x1,%rax
            str[si++] = tmp[rdi--];
ffffffff8000684f:	40 88 b2 c0 13 0e 80 	mov    %sil,-0x7ff1ec40(%rdx)
        while (rdi >= 0)
ffffffff80006856:	48 89 d6             	mov    %rdx,%rsi
ffffffff80006859:	48 83 c2 01          	add    $0x1,%rdx
ffffffff8000685d:	48 39 ce             	cmp    %rcx,%rsi
ffffffff80006860:	75 e6                	jne    ffffffff80006848 <_ZN3Lib13u64_2_basestrEmm.part.0+0x88>
        str[si] = '\0';
ffffffff80006862:	83 c1 01             	add    $0x1,%ecx
ffffffff80006865:	48 63 c9             	movslq %ecx,%rcx
ffffffff80006868:	48 81 c1 c0 13 0e 80 	add    $0xffffffff800e13c0,%rcx
ffffffff8000686f:	c6 01 00             	movb   $0x0,(%rcx)
        return str;
    }
ffffffff80006872:	48 c7 c0 c0 13 0e 80 	mov    $0xffffffff800e13c0,%rax
ffffffff80006879:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff80006880:	c3                   	ret
ffffffff80006881:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            str[0] = '\0';
ffffffff80006888:	c6 05 31 ab 0d 00 00 	movb   $0x0,0xdab31(%rip)        # ffffffff800e13c0 <_ZN3Lib6outputE>
    }
ffffffff8000688f:	48 c7 c0 c0 13 0e 80 	mov    $0xffffffff800e13c0,%rax
ffffffff80006896:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff8000689d:	c3                   	ret
ffffffff8000689e:	66 90                	xchg   %ax,%ax

ffffffff800068a0 <_ZN3Lib11int2basestrEim>:
    {
ffffffff800068a0:	f3 0f 1e fa          	endbr64
        if (!num) {
ffffffff800068a4:	85 ff                	test   %edi,%edi
ffffffff800068a6:	0f 84 d4 00 00 00    	je     ffffffff80006980 <_ZN3Lib11int2basestrEim+0xe0>
    {
ffffffff800068ac:	48 81 ec 20 01 00 00 	sub    $0x120,%rsp
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800068b3:	48 b8 30 31 32 33 34 	movabs $0x3736353433323130,%rax
ffffffff800068ba:	35 36 37 
ffffffff800068bd:	48 89 44 24 0d       	mov    %rax,0xd(%rsp)
ffffffff800068c2:	48 b8 38 39 41 42 43 	movabs $0x4645444342413938,%rax
ffffffff800068c9:	44 45 46 
ffffffff800068cc:	48 89 44 24 15       	mov    %rax,0x15(%rsp)
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800068d1:	48 8d 46 fe          	lea    -0x2(%rsi),%rax
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800068d5:	c7 44 24 1c 46 47 48 	movl   $0x484746,0x1c(%rsp)
ffffffff800068dc:	00 
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800068dd:	48 83 f8 10          	cmp    $0x10,%rax
ffffffff800068e1:	77 7d                	ja     ffffffff80006960 <_ZN3Lib11int2basestrEim+0xc0>
        if (num < 0)
ffffffff800068e3:	45 31 c9             	xor    %r9d,%r9d
ffffffff800068e6:	85 ff                	test   %edi,%edi
ffffffff800068e8:	0f 88 a2 00 00 00    	js     ffffffff80006990 <_ZN3Lib11int2basestrEim+0xf0>
            str[si++] = '-';
ffffffff800068ee:	31 c9                	xor    %ecx,%ecx
            tmp[++rdi] = base[num % radix];
ffffffff800068f0:	48 63 c7             	movslq %edi,%rax
ffffffff800068f3:	31 d2                	xor    %edx,%edx
ffffffff800068f5:	49 89 c8             	mov    %rcx,%r8
ffffffff800068f8:	48 f7 f6             	div    %rsi
ffffffff800068fb:	0f b6 54 14 0d       	movzbl 0xd(%rsp,%rdx,1),%edx
            num /= radix;
ffffffff80006900:	89 c7                	mov    %eax,%edi
            tmp[++rdi] = base[num % radix];
ffffffff80006902:	88 54 0c 20          	mov    %dl,0x20(%rsp,%rcx,1)
        while (num)
ffffffff80006906:	48 8d 49 01          	lea    0x1(%rcx),%rcx
ffffffff8000690a:	85 c0                	test   %eax,%eax
ffffffff8000690c:	75 e2                	jne    ffffffff800068f0 <_ZN3Lib11int2basestrEim+0x50>
ffffffff8000690e:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
ffffffff80006913:	49 63 c9             	movslq %r9d,%rcx
ffffffff80006916:	49 63 c0             	movslq %r8d,%rax
ffffffff80006919:	48 01 f0             	add    %rsi,%rax
ffffffff8000691c:	48 8d 91 c0 13 0e 80 	lea    -0x7ff1ec40(%rcx),%rdx
ffffffff80006923:	4a 8d b4 01 c1 13 0e 	lea    -0x7ff1ec3f(%rcx,%r8,1),%rsi
ffffffff8000692a:	80 
ffffffff8000692b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            str[si++] = tmp[rdi--];
ffffffff80006930:	0f b6 08             	movzbl (%rax),%ecx
        while (rdi >= 0)
ffffffff80006933:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80006937:	48 83 e8 01          	sub    $0x1,%rax
            str[si++] = tmp[rdi--];
ffffffff8000693b:	88 4a ff             	mov    %cl,-0x1(%rdx)
        while (rdi >= 0)
ffffffff8000693e:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006941:	75 ed                	jne    ffffffff80006930 <_ZN3Lib11int2basestrEim+0x90>
        str[si] = '\0';
ffffffff80006943:	43 8d 44 01 01       	lea    0x1(%r9,%r8,1),%eax
ffffffff80006948:	48 98                	cltq
ffffffff8000694a:	c6 80 c0 13 0e 80 00 	movb   $0x0,-0x7ff1ec40(%rax)
            return str;
ffffffff80006951:	48 c7 c0 c0 13 0e 80 	mov    $0xffffffff800e13c0,%rax
    }
ffffffff80006958:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff8000695f:	c3                   	ret
            str[0] = '\0';
ffffffff80006960:	c6 05 59 aa 0d 00 00 	movb   $0x0,0xdaa59(%rip)        # ffffffff800e13c0 <_ZN3Lib6outputE>
            return str;
ffffffff80006967:	48 c7 c0 c0 13 0e 80 	mov    $0xffffffff800e13c0,%rax
    }
ffffffff8000696e:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff80006975:	c3                   	ret
ffffffff80006976:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000697d:	00 00 00 
ffffffff80006980:	48 c7 c0 c3 bc 00 80 	mov    $0xffffffff8000bcc3,%rax
ffffffff80006987:	c3                   	ret
ffffffff80006988:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff8000698f:	00 
            str[si++] = '-';
ffffffff80006990:	c6 05 29 aa 0d 00 2d 	movb   $0x2d,0xdaa29(%rip)        # ffffffff800e13c0 <_ZN3Lib6outputE>
            num = -num;
ffffffff80006997:	f7 df                	neg    %edi
            str[si++] = '-';
ffffffff80006999:	41 b9 01 00 00 00    	mov    $0x1,%r9d
ffffffff8000699f:	e9 4a ff ff ff       	jmp    ffffffff800068ee <_ZN3Lib11int2basestrEim+0x4e>
ffffffff800069a4:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800069ab:	00 00 00 
ffffffff800069ae:	66 90                	xchg   %ax,%ax

ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>:
    {
ffffffff800069b0:	f3 0f 1e fa          	endbr64
        if (!num) {
ffffffff800069b4:	48 85 ff             	test   %rdi,%rdi
ffffffff800069b7:	74 07                	je     ffffffff800069c0 <_ZN3Lib13u64_2_basestrEmm+0x10>
ffffffff800069b9:	e9 02 fe ff ff       	jmp    ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>
ffffffff800069be:	66 90                	xchg   %ax,%ax
    }
ffffffff800069c0:	48 c7 c0 c3 bc 00 80 	mov    $0xffffffff8000bcc3,%rax
ffffffff800069c7:	c3                   	ret
ffffffff800069c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800069cf:	00 

ffffffff800069d0 <kmain>:

// Extern declarations for global constructors array.
extern void (*__init_array[])();
extern void (*__init_array_end[])();

extern "C" void kmain() {
ffffffff800069d0:	f3 0f 1e fa          	endbr64
ffffffff800069d4:	53                   	push   %rbx
ffffffff800069d5:	48 83 ec 20          	sub    $0x20,%rsp
    if (LIMINE_BASE_REVISION_SUPPORTED == false) {
ffffffff800069d9:	48 8b 05 40 97 ff ff 	mov    -0x68c0(%rip),%rax        # ffffffff80000120 <_ZN12_GLOBAL__N_120limine_base_revisionE+0x10>
ffffffff800069e0:	48 85 c0             	test   %rax,%rax
ffffffff800069e3:	0f 85 47 01 00 00    	jne    ffffffff80006b30 <kmain+0x160>
        hcf();
    }

    // Call global constructors.
    for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) {
ffffffff800069e9:	48 c7 c0 17 bf 00 80 	mov    $0xffffffff8000bf17,%rax
ffffffff800069f0:	48 3d 17 bf 00 80    	cmp    $0xffffffff8000bf17,%rax
ffffffff800069f6:	74 17                	je     ffffffff80006a0f <kmain+0x3f>
ffffffff800069f8:	48 89 c3             	mov    %rax,%rbx
ffffffff800069fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        __init_array[i]();
ffffffff80006a00:	ff 13                	call   *(%rbx)
    for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) {
ffffffff80006a02:	48 83 c3 08          	add    $0x8,%rbx
ffffffff80006a06:	48 81 fb 17 bf 00 80 	cmp    $0xffffffff8000bf17,%rbx
ffffffff80006a0d:	75 f1                	jne    ffffffff80006a00 <kmain+0x30>
    }

    if (framebuffer_request.response == nullptr
ffffffff80006a0f:	48 8b 05 f2 96 ff ff 	mov    -0x690e(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
     || framebuffer_request.response->framebuffer_count < 1) {
ffffffff80006a16:	48 85 c0             	test   %rax,%rax
ffffffff80006a19:	0f 84 01 01 00 00    	je     ffffffff80006b20 <kmain+0x150>
ffffffff80006a1f:	48 8b 05 e2 96 ff ff 	mov    -0x691e(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
ffffffff80006a26:	48 83 78 08 00       	cmpq   $0x0,0x8(%rax)
ffffffff80006a2b:	0f 84 ef 00 00 00    	je     ffffffff80006b20 <kmain+0x150>
        hcf();
    }
    
    limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]};
ffffffff80006a31:	48 8b 05 d0 96 ff ff 	mov    -0x6930(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
ffffffff80006a38:	48 8b 40 10          	mov    0x10(%rax),%rax
ffffffff80006a3c:	48 8b 00             	mov    (%rax),%rax

    Kt::Initialize(
ffffffff80006a3f:	44 0f b6 50 28       	movzbl 0x28(%rax),%r10d
ffffffff80006a44:	44 0f b6 48 24       	movzbl 0x24(%rax),%r9d
ffffffff80006a49:	44 0f b6 40 23       	movzbl 0x23(%rax),%r8d
ffffffff80006a4e:	48 8b 48 18          	mov    0x18(%rax),%rcx
ffffffff80006a52:	48 8b 50 10          	mov    0x10(%rax),%rdx
ffffffff80006a56:	48 8b 70 08          	mov    0x8(%rax),%rsi
ffffffff80006a5a:	48 8b 38             	mov    (%rax),%rdi
ffffffff80006a5d:	41 52                	push   %r10
ffffffff80006a5f:	44 0f b6 50 27       	movzbl 0x27(%rax),%r10d
ffffffff80006a64:	41 52                	push   %r10
ffffffff80006a66:	44 0f b6 50 26       	movzbl 0x26(%rax),%r10d
ffffffff80006a6b:	41 52                	push   %r10
ffffffff80006a6d:	0f b6 40 25          	movzbl 0x25(%rax),%eax
ffffffff80006a71:	50                   	push   %rax
ffffffff80006a72:	e8 79 04 00 00       	call   ffffffff80006ef0 <_ZN2Kt10InitializeEPjmmmhhhhhh>
        framebuffer->blue_mask_size,
        framebuffer->blue_mask_shift
    );

#if defined (__x86_64__)
    Hal::PrepareGDT();
ffffffff80006a77:	48 83 c4 20          	add    $0x20,%rsp
ffffffff80006a7b:	e8 60 ec ff ff       	call   ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>
    Hal::BridgeLoadGDT();
ffffffff80006a80:	e8 0b ed ff ff       	call   ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>
#endif

    uint64_t hhdm_offset = hhdm_request.response->offset;
ffffffff80006a85:	48 8b 05 fc 95 ff ff 	mov    -0x6a04(%rip),%rax        # ffffffff80000088 <_ZN12_GLOBAL__N_112hhdm_requestE+0x28>
    Memory::HHDMBase = hhdm_offset;
ffffffff80006a8c:	48 8b 40 08          	mov    0x8(%rax),%rax
ffffffff80006a90:	48 89 05 31 ad 0d 00 	mov    %rax,0xdad31(%rip)        # ffffffff800e17c8 <_ZN6Memory8HHDMBaseE>

    if (memmap_request.response != nullptr) {
ffffffff80006a97:	48 8b 05 aa 95 ff ff 	mov    -0x6a56(%rip),%rax        # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28>
ffffffff80006a9e:	48 85 c0             	test   %rax,%rax
ffffffff80006aa1:	0f 84 99 00 00 00    	je     ffffffff80006b40 <kmain+0x170>
ffffffff80006aa7:	48 c7 c7 20 be 00 80 	mov    $0xffffffff8000be20,%rdi
        kout << "MemoryManagement: Creating global HeapAllocator" << newline;

        auto result = Memory::Scan(memmap_request.response);
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006aae:	48 89 e3             	mov    %rsp,%rbx
ffffffff80006ab1:	e8 ea 04 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006ab6:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006abb:	e8 b0 04 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
        auto result = Memory::Scan(memmap_request.response);
ffffffff80006ac0:	48 8b 3d 81 95 ff ff 	mov    -0x6a7f(%rip),%rdi        # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28>
ffffffff80006ac7:	e8 e4 02 00 00       	call   ffffffff80006db0 <_ZN6Memory4ScanEP22limine_memmap_response>
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006acc:	48 89 df             	mov    %rbx,%rdi
        auto result = Memory::Scan(memmap_request.response);
ffffffff80006acf:	48 89 c6             	mov    %rax,%rsi
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006ad2:	e8 89 00 00 00       	call   ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>

        Memory::g_heap = &allocator;
ffffffff80006ad7:	48 89 1d f2 ac 0d 00 	mov    %rbx,0xdacf2(%rip)        # ffffffff800e17d0 <_ZN6Memory6g_heapE>
    } else {
        Panic("Guru Meditation Error: System memory map missing!", nullptr);
    }

#if defined (__x86_64__)
    Hal::IDTInitialize();
ffffffff80006ade:	e8 6d f9 ff ff       	call   ffffffff80006450 <_ZN3Hal13IDTInitializeEv>
#endif

    kcp::cstringstream stream;
ffffffff80006ae3:	48 89 df             	mov    %rbx,%rdi
ffffffff80006ae6:	e8 f5 ea ff ff       	call   ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>
    stream<<"Hello, World";
ffffffff80006aeb:	48 c7 c6 c5 bc 00 80 	mov    $0xffffffff8000bcc5,%rsi
ffffffff80006af2:	48 89 df             	mov    %rbx,%rdi
ffffffff80006af5:	e8 36 eb ff ff       	call   ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>

    Memory::g_heap->Walk();
ffffffff80006afa:	48 8b 3d cf ac 0d 00 	mov    0xdaccf(%rip),%rdi        # ffffffff800e17d0 <_ZN6Memory6g_heapE>
ffffffff80006b01:	e8 da 01 00 00       	call   ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv>

    hcf();
ffffffff80006b06:	e8 d5 03 00 00       	call   ffffffff80006ee0 <_Z3hcfv>
}
ffffffff80006b0b:	48 89 df             	mov    %rbx,%rdi
ffffffff80006b0e:	e8 ed ea ff ff       	call   ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>
ffffffff80006b13:	48 83 c4 20          	add    $0x20,%rsp
ffffffff80006b17:	5b                   	pop    %rbx
ffffffff80006b18:	c3                   	ret
ffffffff80006b19:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        hcf();
ffffffff80006b20:	e8 bb 03 00 00       	call   ffffffff80006ee0 <_Z3hcfv>
ffffffff80006b25:	e9 07 ff ff ff       	jmp    ffffffff80006a31 <kmain+0x61>
ffffffff80006b2a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        hcf();
ffffffff80006b30:	e8 ab 03 00 00       	call   ffffffff80006ee0 <_Z3hcfv>
ffffffff80006b35:	e9 af fe ff ff       	jmp    ffffffff800069e9 <kmain+0x19>
ffffffff80006b3a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        Panic("Guru Meditation Error: System memory map missing!", nullptr);
ffffffff80006b40:	31 f6                	xor    %esi,%esi
ffffffff80006b42:	48 c7 c7 50 be 00 80 	mov    $0xffffffff8000be50,%rdi
ffffffff80006b49:	48 89 e3             	mov    %rsp,%rbx
ffffffff80006b4c:	e8 5f e3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
ffffffff80006b51:	eb 8b                	jmp    ffffffff80006ade <kmain+0x10e>
ffffffff80006b53:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006b5a:	00 00 00 
ffffffff80006b5d:	0f 1f 00             	nopl   (%rax)

ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>:

namespace Memory
{
    constexpr size_t metadata_size = 8; // 8 bytes
    
    HeapAllocator::HeapAllocator(LargestSection section)
ffffffff80006b60:	f3 0f 1e fa          	endbr64
ffffffff80006b64:	41 54                	push   %r12
ffffffff80006b66:	49 89 d4             	mov    %rdx,%r12
ffffffff80006b69:	55                   	push   %rbp
ffffffff80006b6a:	48 89 f5             	mov    %rsi,%rbp
ffffffff80006b6d:	53                   	push   %rbx
ffffffff80006b6e:	48 89 fb             	mov    %rdi,%rbx
ffffffff80006b71:	48 c7 47 10 00 00 00 	movq   $0x0,0x10(%rdi)
ffffffff80006b78:	00 
ffffffff80006b79:	48 c7 47 18 00 00 00 	movq   $0x0,0x18(%rdi)
ffffffff80006b80:	00 
            Print(string);
ffffffff80006b81:	48 c7 c7 88 be 00 80 	mov    $0xffffffff8000be88,%rdi
ffffffff80006b88:	e8 13 04 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006b8d:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006b92:	e8 d9 03 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>

namespace Memory {
    extern std::uint64_t HHDMBase;

    inline uint64_t HHDM(uint64_t address) {
        return HHDMBase + address;
ffffffff80006b97:	48 8b 35 2a ac 0d 00 	mov    0xdac2a(%rip),%rsi        # ffffffff800e17c8 <_ZN6Memory8HHDMBaseE>
    {
        kout << "HeapAllocator: constructor called" << Kt::newline;
        
        // section contains the physical address, we need the virtual address, so we call the helper
        g_section = LargestSection {
ffffffff80006b9e:	4c 89 63 08          	mov    %r12,0x8(%rbx)
            .address = HHDM(section.address),
            .size = section.size
        };

        head = Node {
ffffffff80006ba2:	48 c7 43 10 00 00 00 	movq   $0x0,0x10(%rbx)
ffffffff80006ba9:	00 
ffffffff80006baa:	48 01 ee             	add    %rbp,%rsi
        g_section = LargestSection {
ffffffff80006bad:	48 89 33             	mov    %rsi,(%rbx)
        head = Node {
ffffffff80006bb0:	48 89 73 18          	mov    %rsi,0x18(%rbx)
            .size = 0,
            .next = (Node*)g_section.address
        };

        head.next->size = g_section.size;
ffffffff80006bb4:	4c 89 26             	mov    %r12,(%rsi)
        head.size = 0;//!!!!!!
    }
ffffffff80006bb7:	5b                   	pop    %rbx
ffffffff80006bb8:	5d                   	pop    %rbp
ffffffff80006bb9:	41 5c                	pop    %r12
ffffffff80006bbb:	c3                   	ret
ffffffff80006bbc:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>:

    void* HeapAllocator::Request(size_t size) {
ffffffff80006bc0:	f3 0f 1e fa          	endbr64
ffffffff80006bc4:	55                   	push   %rbp
        Node* current = &head;
        Node* prev = nullptr;
ffffffff80006bc5:	31 c9                	xor    %ecx,%ecx
    void* HeapAllocator::Request(size_t size) {
ffffffff80006bc7:	48 89 fd             	mov    %rdi,%rbp
ffffffff80006bca:	53                   	push   %rbx
        Node* current = &head;
ffffffff80006bcb:	48 8d 5f 10          	lea    0x10(%rdi),%rbx
    void* HeapAllocator::Request(size_t size) {
ffffffff80006bcf:	48 83 ec 08          	sub    $0x8,%rsp
ffffffff80006bd3:	eb 0e                	jmp    ffffffff80006be3 <_ZN6Memory13HeapAllocator7RequestEm+0x23>
ffffffff80006bd5:	0f 1f 00             	nopl   (%rax)

        while (current != nullptr) {
ffffffff80006bd8:	48 89 d9             	mov    %rbx,%rcx
ffffffff80006bdb:	48 85 c0             	test   %rax,%rax
ffffffff80006bde:	74 62                	je     ffffffff80006c42 <_ZN6Memory13HeapAllocator7RequestEm+0x82>
ffffffff80006be0:	48 89 c3             	mov    %rax,%rbx
            if (current->size >= size) {
ffffffff80006be3:	48 8b 13             	mov    (%rbx),%rdx
                Node copy = *current;
ffffffff80006be6:	48 8b 43 08          	mov    0x8(%rbx),%rax
            if (current->size >= size) {
ffffffff80006bea:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006bed:	72 e9                	jb     ffffffff80006bd8 <_ZN6Memory13HeapAllocator7RequestEm+0x18>
                size_t total_size_needed = size + sizeof(Metadata);

                Metadata* meta = (Metadata*)current;

                meta->size = size;
ffffffff80006bef:	48 89 33             	mov    %rsi,(%rbx)
                
                prev->next = (Node*)((uint64_t)current + total_size_needed);
ffffffff80006bf2:	48 8d 74 33 08       	lea    0x8(%rbx,%rsi,1),%rsi
            Print(string);
ffffffff80006bf7:	48 c7 c7 d2 bc 00 80 	mov    $0xffffffff8000bcd2,%rdi
ffffffff80006bfe:	48 89 71 08          	mov    %rsi,0x8(%rcx)
                prev->next->next = copy.next;
ffffffff80006c02:	48 89 46 08          	mov    %rax,0x8(%rsi)
                prev->next->size = copy.size;
ffffffff80006c06:	48 8b 41 08          	mov    0x8(%rcx),%rax
ffffffff80006c0a:	48 89 10             	mov    %rdx,(%rax)
ffffffff80006c0d:	e8 8e 03 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006c12:	48 8b 7d 10          	mov    0x10(%rbp),%rdi
ffffffff80006c16:	be 0a 00 00 00       	mov    $0xa,%esi
            t.streamBaseType = newBase;
ffffffff80006c1b:	c7 05 d3 54 00 00 0a 	movl   $0xa,0x54d3(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80006c22:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006c25:	e8 86 fd ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006c2a:	48 89 c7             	mov    %rax,%rdi
ffffffff80006c2d:	e8 6e 03 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006c32:	48 c7 c7 c0 b9 00 80 	mov    $0xffffffff8000b9c0,%rdi
ffffffff80006c39:	e8 62 03 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>

                kout << "head.size: " << base::dec << head.size << "\n";

                return (void*)((uint64_t)meta + sizeof(Metadata));
ffffffff80006c3e:	48 8d 43 08          	lea    0x8(%rbx),%rax
            prev = current;
            current = current->next;
        }

        return nullptr;
    }
ffffffff80006c42:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006c46:	5b                   	pop    %rbx
ffffffff80006c47:	5d                   	pop    %rbp
ffffffff80006c48:	c3                   	ret
ffffffff80006c49:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80006c50 <_ZN6Memory13HeapAllocator7ReallocEPvm>:

    void* HeapAllocator::Realloc(void* ptr, size_t size) {
ffffffff80006c50:	f3 0f 1e fa          	endbr64
ffffffff80006c54:	41 55                	push   %r13
ffffffff80006c56:	49 89 d5             	mov    %rdx,%r13
ffffffff80006c59:	41 54                	push   %r12
ffffffff80006c5b:	55                   	push   %rbp
ffffffff80006c5c:	48 89 f5             	mov    %rsi,%rbp
        auto new_ptr = Request(size);
ffffffff80006c5f:	48 89 d6             	mov    %rdx,%rsi
    void* HeapAllocator::Realloc(void* ptr, size_t size) {
ffffffff80006c62:	53                   	push   %rbx
ffffffff80006c63:	48 89 fb             	mov    %rdi,%rbx
ffffffff80006c66:	48 83 ec 08          	sub    $0x8,%rsp
        auto new_ptr = Request(size);
ffffffff80006c6a:	e8 51 ff ff ff       	call   ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>
ffffffff80006c6f:	49 89 c4             	mov    %rax,%r12

        if (new_ptr == nullptr) {
ffffffff80006c72:	48 85 c0             	test   %rax,%rax
ffffffff80006c75:	74 2e                	je     ffffffff80006ca5 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x55>
            return nullptr;
        }

        if (ptr == nullptr) {
ffffffff80006c77:	48 85 ed             	test   %rbp,%rbp
ffffffff80006c7a:	74 29                	je     ffffffff80006ca5 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x55>
            return new_ptr;
        }

        memcpy(new_ptr, ptr, size);
ffffffff80006c7c:	4c 89 ea             	mov    %r13,%rdx
ffffffff80006c7f:	48 89 ee             	mov    %rbp,%rsi
ffffffff80006c82:	48 89 c7             	mov    %rax,%rdi
ffffffff80006c85:	e8 b6 fa ff ff       	call   ffffffff80006740 <memcpy>

    void HeapAllocator::Free(void* ptr) {
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
        size_t size = meta->size;

        auto prev_next = head.next;
ffffffff80006c8a:	48 8b 4b 18          	mov    0x18(%rbx),%rcx
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
ffffffff80006c8e:	48 8d 45 f8          	lea    -0x8(%rbp),%rax
        size_t size = meta->size;
ffffffff80006c92:	48 8b 55 f8          	mov    -0x8(%rbp),%rdx

        head.next = (Node*)meta;
ffffffff80006c96:	48 89 43 18          	mov    %rax,0x18(%rbx)
        head.next->next = prev_next;
ffffffff80006c9a:	48 89 4d 00          	mov    %rcx,0x0(%rbp)
        head.next->size = size;
ffffffff80006c9e:	48 8b 43 18          	mov    0x18(%rbx),%rax
ffffffff80006ca2:	48 89 10             	mov    %rdx,(%rax)
    }
ffffffff80006ca5:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006ca9:	4c 89 e0             	mov    %r12,%rax
ffffffff80006cac:	5b                   	pop    %rbx
ffffffff80006cad:	5d                   	pop    %rbp
ffffffff80006cae:	41 5c                	pop    %r12
ffffffff80006cb0:	41 5d                	pop    %r13
ffffffff80006cb2:	c3                   	ret
ffffffff80006cb3:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006cba:	00 00 00 
ffffffff80006cbd:	0f 1f 00             	nopl   (%rax)

ffffffff80006cc0 <_ZN6Memory13HeapAllocator4FreeEPv>:
    void HeapAllocator::Free(void* ptr) {
ffffffff80006cc0:	f3 0f 1e fa          	endbr64
        auto prev_next = head.next;
ffffffff80006cc4:	48 8b 4f 18          	mov    0x18(%rdi),%rcx
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
ffffffff80006cc8:	48 8d 46 f8          	lea    -0x8(%rsi),%rax
        size_t size = meta->size;
ffffffff80006ccc:	48 8b 56 f8          	mov    -0x8(%rsi),%rdx
        head.next = (Node*)meta;
ffffffff80006cd0:	48 89 47 18          	mov    %rax,0x18(%rdi)
        head.next->next = prev_next;
ffffffff80006cd4:	48 89 0e             	mov    %rcx,(%rsi)
        head.next->size = size;
ffffffff80006cd7:	48 8b 47 18          	mov    0x18(%rdi),%rax
ffffffff80006cdb:	48 89 10             	mov    %rdx,(%rax)
    }
ffffffff80006cde:	c3                   	ret
ffffffff80006cdf:	90                   	nop

ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv>:
    
    // Traverses the Allocator's linked list for debugging
    void HeapAllocator::Walk() {
ffffffff80006ce0:	f3 0f 1e fa          	endbr64
ffffffff80006ce4:	55                   	push   %rbp
ffffffff80006ce5:	53                   	push   %rbx
ffffffff80006ce6:	48 83 ec 08          	sub    $0x8,%rsp
        Node* current = {head.next};
ffffffff80006cea:	48 8b 5f 18          	mov    0x18(%rdi),%rbx
        size_t i{0};

        while (current != nullptr) {
ffffffff80006cee:	48 85 db             	test   %rbx,%rbx
ffffffff80006cf1:	0f 84 a8 00 00 00    	je     ffffffff80006d9f <_ZN6Memory13HeapAllocator4WalkEv+0xbf>
        size_t i{0};
ffffffff80006cf7:	31 ed                	xor    %ebp,%ebp
ffffffff80006cf9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80006d00:	48 c7 c7 de bc 00 80 	mov    $0xffffffff8000bcde,%rdi
ffffffff80006d07:	e8 94 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d0c:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff80006d11:	48 89 ef             	mov    %rbp,%rdi
            t.streamBaseType = newBase;
ffffffff80006d14:	c7 05 da 53 00 00 0a 	movl   $0xa,0x53da(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80006d1b:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d1e:	e8 8d fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
            kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline;
            current = current->next;
            i++;
ffffffff80006d23:	48 83 c5 01          	add    $0x1,%rbp
ffffffff80006d27:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d2a:	e8 71 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d2f:	48 c7 c7 e5 bc 00 80 	mov    $0xffffffff8000bce5,%rdi
ffffffff80006d36:	e8 65 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d3b:	8b 35 b7 53 00 00    	mov    0x53b7(%rip),%esi        # ffffffff8000c0f8 <kout>
ffffffff80006d41:	48 8b 3b             	mov    (%rbx),%rdi
ffffffff80006d44:	e8 67 fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006d49:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d4c:	e8 4f 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d51:	48 c7 c7 e8 bc 00 80 	mov    $0xffffffff8000bce8,%rdi
ffffffff80006d58:	e8 43 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d5d:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff80006d62:	48 89 df             	mov    %rbx,%rdi
            t.streamBaseType = newBase;
ffffffff80006d65:	c7 05 89 53 00 00 10 	movl   $0x10,0x5389(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80006d6c:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d6f:	e8 3c fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006d74:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d77:	e8 24 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d7c:	48 c7 c7 fc bc 00 80 	mov    $0xffffffff8000bcfc,%rdi
ffffffff80006d83:	e8 18 02 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006d88:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006d8d:	e8 de 01 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
            current = current->next;
ffffffff80006d92:	48 8b 5b 08          	mov    0x8(%rbx),%rbx
        while (current != nullptr) {
ffffffff80006d96:	48 85 db             	test   %rbx,%rbx
ffffffff80006d99:	0f 85 61 ff ff ff    	jne    ffffffff80006d00 <_ZN6Memory13HeapAllocator4WalkEv+0x20>
        }
    }
ffffffff80006d9f:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006da3:	5b                   	pop    %rbx
ffffffff80006da4:	5d                   	pop    %rbp
ffffffff80006da5:	c3                   	ret
ffffffff80006da6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006dad:	00 00 00 

ffffffff80006db0 <_ZN6Memory4ScanEP22limine_memmap_response>:
#include "Heap.hpp"

using namespace Kt;

namespace Memory {
    LargestSection Scan(limine_memmap_response* mmap) {
ffffffff80006db0:	f3 0f 1e fa          	endbr64
ffffffff80006db4:	41 56                	push   %r14
ffffffff80006db6:	41 55                	push   %r13
ffffffff80006db8:	41 54                	push   %r12
ffffffff80006dba:	55                   	push   %rbp
ffffffff80006dbb:	53                   	push   %rbx
        LargestSection currentLargestSection{};

        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006dbc:	4c 8b 6f 08          	mov    0x8(%rdi),%r13
ffffffff80006dc0:	4d 85 ed             	test   %r13,%r13
ffffffff80006dc3:	0f 84 ef 00 00 00    	je     ffffffff80006eb8 <_ZN6Memory4ScanEP22limine_memmap_response+0x108>
ffffffff80006dc9:	49 89 fc             	mov    %rdi,%r12
        LargestSection currentLargestSection{};
ffffffff80006dcc:	45 31 ed             	xor    %r13d,%r13d
ffffffff80006dcf:	45 31 f6             	xor    %r14d,%r14d
        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006dd2:	31 db                	xor    %ebx,%ebx
ffffffff80006dd4:	eb 19                	jmp    ffffffff80006def <_ZN6Memory4ScanEP22limine_memmap_response+0x3f>
ffffffff80006dd6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006ddd:	00 00 00 
ffffffff80006de0:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80006de4:	49 3b 5c 24 08       	cmp    0x8(%r12),%rbx
ffffffff80006de9:	0f 83 b1 00 00 00    	jae    ffffffff80006ea0 <_ZN6Memory4ScanEP22limine_memmap_response+0xf0>
            auto entry = mmap->entries[i];
ffffffff80006def:	49 8b 44 24 10       	mov    0x10(%r12),%rax
ffffffff80006df4:	48 8b 2c d8          	mov    (%rax,%rbx,8),%rbp

            if (entry->base == 0) {
ffffffff80006df8:	48 83 7d 00 00       	cmpq   $0x0,0x0(%rbp)
ffffffff80006dfd:	74 e1                	je     ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
                continue;
            }
            
            if (entry->type == LIMINE_MEMMAP_USABLE) {
ffffffff80006dff:	48 83 7d 10 00       	cmpq   $0x0,0x10(%rbp)
ffffffff80006e04:	75 da                	jne    ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
            Print(string);
ffffffff80006e06:	48 c7 c7 b0 be 00 80 	mov    $0xffffffff8000beb0,%rdi
ffffffff80006e0d:	e8 8e 01 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e12:	48 8b 7d 08          	mov    0x8(%rbp),%rdi
ffffffff80006e16:	be 0a 00 00 00       	mov    $0xa,%esi
            t.streamBaseType = newBase;
ffffffff80006e1b:	c7 05 d3 52 00 00 0a 	movl   $0xa,0x52d3(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80006e22:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e25:	e8 86 fb ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006e2a:	48 89 c7             	mov    %rax,%rdi
ffffffff80006e2d:	e8 6e 01 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006e32:	48 c7 c7 fe bc 00 80 	mov    $0xffffffff8000bcfe,%rdi
ffffffff80006e39:	e8 62 01 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e3e:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
ffffffff80006e42:	be 10 00 00 00       	mov    $0x10,%esi
            t.streamBaseType = newBase;
ffffffff80006e47:	c7 05 a7 52 00 00 10 	movl   $0x10,0x52a7(%rip)        # ffffffff8000c0f8 <kout>
ffffffff80006e4e:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e51:	e8 5a fb ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006e56:	48 89 c7             	mov    %rax,%rdi
ffffffff80006e59:	e8 42 01 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006e5e:	48 c7 c7 13 bd 00 80 	mov    $0xffffffff8000bd13,%rdi
ffffffff80006e65:	e8 36 01 00 00       	call   ffffffff80006fa0 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006e6a:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006e6f:	e8 fc 00 00 00       	call   ffffffff80006f70 <_ZN2Kt7PutcharEc>
                kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline;                
                
                if (entry->length > currentLargestSection.size) {
ffffffff80006e74:	48 8b 45 08          	mov    0x8(%rbp),%rax
ffffffff80006e78:	49 39 c5             	cmp    %rax,%r13
ffffffff80006e7b:	0f 83 5f ff ff ff    	jae    ffffffff80006de0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
                    currentLargestSection = {
                        .address = (uint64_t)entry->base,
ffffffff80006e81:	4c 8b 75 00          	mov    0x0(%rbp),%r14
                    currentLargestSection = {
ffffffff80006e85:	49 89 c5             	mov    %rax,%r13
        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006e88:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80006e8c:	49 3b 5c 24 08       	cmp    0x8(%r12),%rbx
ffffffff80006e91:	0f 82 58 ff ff ff    	jb     ffffffff80006def <_ZN6Memory4ScanEP22limine_memmap_response+0x3f>
ffffffff80006e97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80006e9e:	00 00 
                    };
                }
            }
        }

        [[unlikely]] if (currentLargestSection.address == 0) {
ffffffff80006ea0:	4d 85 f6             	test   %r14,%r14
ffffffff80006ea3:	74 13                	je     ffffffff80006eb8 <_ZN6Memory4ScanEP22limine_memmap_response+0x108>
            Panic("Couldn't find a usable memory section.", nullptr);
        }

        return currentLargestSection;
    }
ffffffff80006ea5:	5b                   	pop    %rbx
ffffffff80006ea6:	4c 89 f0             	mov    %r14,%rax
ffffffff80006ea9:	5d                   	pop    %rbp
ffffffff80006eaa:	4c 89 ea             	mov    %r13,%rdx
ffffffff80006ead:	41 5c                	pop    %r12
ffffffff80006eaf:	41 5d                	pop    %r13
ffffffff80006eb1:	41 5e                	pop    %r14
ffffffff80006eb3:	c3                   	ret
ffffffff80006eb4:	0f 1f 40 00          	nopl   0x0(%rax)
            Panic("Couldn't find a usable memory section.", nullptr);
ffffffff80006eb8:	45 31 f6             	xor    %r14d,%r14d
ffffffff80006ebb:	31 f6                	xor    %esi,%esi
ffffffff80006ebd:	48 c7 c7 f0 be 00 80 	mov    $0xffffffff8000bef0,%rdi
ffffffff80006ec4:	e8 e7 df ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80006ec9:	5b                   	pop    %rbx
ffffffff80006eca:	4c 89 f0             	mov    %r14,%rax
ffffffff80006ecd:	5d                   	pop    %rbp
ffffffff80006ece:	4c 89 ea             	mov    %r13,%rdx
ffffffff80006ed1:	41 5c                	pop    %r12
ffffffff80006ed3:	41 5d                	pop    %r13
ffffffff80006ed5:	41 5e                	pop    %r14
ffffffff80006ed7:	c3                   	ret
ffffffff80006ed8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80006edf:	00 

ffffffff80006ee0 <_Z3hcfv>:
    * Copyright (c) Daniel Hammer, Limine Contributors (via Limine C++ example)
*/

// Halt and catch fire function.
void hcf()
{
ffffffff80006ee0:	f3 0f 1e fa          	endbr64
ffffffff80006ee4:	0f 1f 40 00          	nopl   0x0(%rax)
    for (;;)
    {
#if defined(__x86_64__)
        asm("hlt");
ffffffff80006ee8:	f4                   	hlt
    for (;;)
ffffffff80006ee9:	eb fd                	jmp    ffffffff80006ee8 <_Z3hcfv+0x8>
ffffffff80006eeb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80006ef0 <_ZN2Kt10InitializeEPjmmmhhhhhh>:
    void Initialize(std::uint32_t *framebuffer, std::size_t width, std::size_t height, std::size_t pitch,
        std::uint8_t red_mask_size, std::uint8_t red_mask_shift,
        std::uint8_t green_mask_size, std::uint8_t green_mask_shift,
        std::uint8_t blue_mask_size, std::uint8_t blue_mask_shift
        )
    {
ffffffff80006ef0:	f3 0f 1e fa          	endbr64
ffffffff80006ef4:	48 83 ec 08          	sub    $0x8,%rsp
ffffffff80006ef8:	48 89 f8             	mov    %rdi,%rax
        ctx = flanterm_fb_init(
ffffffff80006efb:	45 0f b6 c9          	movzbl %r9b,%r9d
ffffffff80006eff:	45 0f b6 c0          	movzbl %r8b,%r8d
ffffffff80006f03:	6a 00                	push   $0x0
ffffffff80006f05:	6a 00                	push   $0x0
ffffffff80006f07:	6a 00                	push   $0x0
ffffffff80006f09:	6a 01                	push   $0x1
ffffffff80006f0b:	6a 00                	push   $0x0
ffffffff80006f0d:	6a 00                	push   $0x0
ffffffff80006f0f:	6a 00                	push   $0x0
ffffffff80006f11:	6a 00                	push   $0x0
ffffffff80006f13:	6a 00                	push   $0x0
ffffffff80006f15:	6a 00                	push   $0x0
ffffffff80006f17:	6a 00                	push   $0x0
ffffffff80006f19:	6a 00                	push   $0x0
ffffffff80006f1b:	6a 00                	push   $0x0
ffffffff80006f1d:	6a 00                	push   $0x0
ffffffff80006f1f:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f26:	00 
ffffffff80006f27:	57                   	push   %rdi
ffffffff80006f28:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f2f:	00 
ffffffff80006f30:	57                   	push   %rdi
ffffffff80006f31:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f38:	00 
ffffffff80006f39:	57                   	push   %rdi
ffffffff80006f3a:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f41:	00 
ffffffff80006f42:	57                   	push   %rdi
ffffffff80006f43:	31 ff                	xor    %edi,%edi
ffffffff80006f45:	41 51                	push   %r9
ffffffff80006f47:	49 89 c9             	mov    %rcx,%r9
ffffffff80006f4a:	48 89 f1             	mov    %rsi,%rcx
ffffffff80006f4d:	31 f6                	xor    %esi,%esi
ffffffff80006f4f:	41 50                	push   %r8
ffffffff80006f51:	49 89 d0             	mov    %rdx,%r8
ffffffff80006f54:	48 89 c2             	mov    %rax,%rdx
ffffffff80006f57:	e8 04 b2 ff ff       	call   ffffffff80002160 <flanterm_fb_init>
ffffffff80006f5c:	48 89 05 75 a8 0d 00 	mov    %rax,0xda875(%rip)        # ffffffff800e17d8 <_ZN2Kt3ctxE>
            NULL, NULL,
            NULL, 0, 0, 1,
            0, 0,
            0
        );
    }
ffffffff80006f63:	48 81 c4 a8 00 00 00 	add    $0xa8,%rsp
ffffffff80006f6a:	c3                   	ret
ffffffff80006f6b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80006f70 <_ZN2Kt7PutcharEc>:

    void Putchar(char c) {
ffffffff80006f70:	f3 0f 1e fa          	endbr64
ffffffff80006f74:	48 83 ec 18          	sub    $0x18,%rsp
        flanterm_write(ctx, &c, 1);
ffffffff80006f78:	ba 01 00 00 00       	mov    $0x1,%edx
    void Putchar(char c) {
ffffffff80006f7d:	40 88 7c 24 0c       	mov    %dil,0xc(%rsp)
        flanterm_write(ctx, &c, 1);
ffffffff80006f82:	48 8b 3d 4f a8 0d 00 	mov    0xda84f(%rip),%rdi        # ffffffff800e17d8 <_ZN2Kt3ctxE>
ffffffff80006f89:	48 8d 74 24 0c       	lea    0xc(%rsp),%rsi
ffffffff80006f8e:	e8 2d c0 ff ff       	call   ffffffff80002fc0 <flanterm_write>
    }
ffffffff80006f93:	48 83 c4 18          	add    $0x18,%rsp
ffffffff80006f97:	c3                   	ret
ffffffff80006f98:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80006f9f:	00 

ffffffff80006fa0 <_ZN2Kt5PrintEPKc>:

    void Print(const char *text) {
ffffffff80006fa0:	f3 0f 1e fa          	endbr64

namespace Lib {
    inline int strlen(const char *string) {
        int c = 0;

        while (*string != '\0') {
ffffffff80006fa4:	80 3f 00             	cmpb   $0x0,(%rdi)
ffffffff80006fa7:	48 89 fe             	mov    %rdi,%rsi
ffffffff80006faa:	74 2c                	je     ffffffff80006fd8 <_ZN2Kt5PrintEPKc+0x38>
ffffffff80006fac:	48 89 f8             	mov    %rdi,%rax
        int c = 0;
ffffffff80006faf:	31 d2                	xor    %edx,%edx
ffffffff80006fb1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            string++;
ffffffff80006fb8:	48 83 c0 01          	add    $0x1,%rax
            c++;            
ffffffff80006fbc:	83 c2 01             	add    $0x1,%edx
        while (*string != '\0') {
ffffffff80006fbf:	80 38 00             	cmpb   $0x0,(%rax)
ffffffff80006fc2:	75 f4                	jne    ffffffff80006fb8 <_ZN2Kt5PrintEPKc+0x18>
        flanterm_write(ctx, text, Lib::strlen(text));
ffffffff80006fc4:	48 8b 3d 0d a8 0d 00 	mov    0xda80d(%rip),%rdi        # ffffffff800e17d8 <_ZN2Kt3ctxE>
ffffffff80006fcb:	48 63 d2             	movslq %edx,%rdx
ffffffff80006fce:	e9 ed bf ff ff       	jmp    ffffffff80002fc0 <flanterm_write>
ffffffff80006fd3:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff80006fd8:	48 8b 3d f9 a7 0d 00 	mov    0xda7f9(%rip),%rdi        # ffffffff800e17d8 <_ZN2Kt3ctxE>
ffffffff80006fdf:	31 d2                	xor    %edx,%edx
ffffffff80006fe1:	e9 da bf ff ff       	jmp    ffffffff80002fc0 <flanterm_write>
ffffffff80006fe6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006fed:	00 00 00 

ffffffff80006ff0 <LoadGDT>:
ffffffff80006ff0:	0f 01 17             	lgdt   (%rdi)
ffffffff80006ff3:	c3                   	ret

ffffffff80006ff4 <ReloadSegments>:
ffffffff80006ff4:	6a 08                	push   $0x8
ffffffff80006ff6:	48 8d 05 03 00 00 00 	lea    0x3(%rip),%rax        # ffffffff80007000 <ReloadSegments.reload_CS>
ffffffff80006ffd:	50                   	push   %rax
ffffffff80006ffe:	48 cb                	lretq

ffffffff80007000 <ReloadSegments.reload_CS>:
ffffffff80007000:	66 b8 10 00          	mov    $0x10,%ax
ffffffff80007004:	8e d8                	mov    %eax,%ds
ffffffff80007006:	8e c0                	mov    %eax,%es
ffffffff80007008:	8e e0                	mov    %eax,%fs
ffffffff8000700a:	8e e8                	mov    %eax,%gs
ffffffff8000700c:	8e d0                	mov    %eax,%ss
ffffffff8000700e:	c3                   	ret

kernel/bin-x86_64/kernel:     file format elf64-x86-64


Disassembly of section .text:

ffffffff80001000 <bump_alloc>:
#endif

static uint8_t bump_alloc_pool[FLANTERM_FB_BUMP_ALLOC_POOL_SIZE];
static size_t bump_alloc_ptr = 0;

static void *bump_alloc(size_t s) {
ffffffff80001000:	f3 0f 1e fa          	endbr64
    static bool base_offset_added = false;
    if (!base_offset_added) {
ffffffff80001004:	80 3d f5 a0 00 00 00 	cmpb   $0x0,0xa0f5(%rip)        # ffffffff8000b100 <base_offset_added.0>
ffffffff8000100b:	75 07                	jne    ffffffff80001014 <bump_alloc+0x14>
        if ((uintptr_t)bump_alloc_pool & 0xf) {
            bump_alloc_ptr += 0x10 - ((uintptr_t)bump_alloc_pool & 0xf);
        }
        base_offset_added = true;
ffffffff8000100d:	c6 05 ec a0 00 00 01 	movb   $0x1,0xa0ec(%rip)        # ffffffff8000b100 <base_offset_added.0>
    }

    if ((s & 0xf) != 0) {
        s += 0x10;
        s &= ~(size_t)0xf;
ffffffff80001014:	48 8d 47 10          	lea    0x10(%rdi),%rax
ffffffff80001018:	48 83 e0 f0          	and    $0xfffffffffffffff0,%rax
ffffffff8000101c:	40 f6 c7 0f          	test   $0xf,%dil
ffffffff80001020:	48 0f 45 f8          	cmovne %rax,%rdi
    }

    size_t next_ptr = bump_alloc_ptr + s;
ffffffff80001024:	48 8b 05 dd a0 00 00 	mov    0xa0dd(%rip),%rax        # ffffffff8000b108 <bump_alloc_ptr>
ffffffff8000102b:	48 01 c7             	add    %rax,%rdi
    if (next_ptr > FLANTERM_FB_BUMP_ALLOC_POOL_SIZE) {
ffffffff8000102e:	48 81 ff 28 52 0d 00 	cmp    $0xd5228,%rdi
ffffffff80001035:	77 11                	ja     ffffffff80001048 <bump_alloc+0x48>
        return NULL;
    }
    void *ret = &bump_alloc_pool[bump_alloc_ptr];
    bump_alloc_ptr = next_ptr;
ffffffff80001037:	48 89 3d ca a0 00 00 	mov    %rdi,0xa0ca(%rip)        # ffffffff8000b108 <bump_alloc_ptr>
    void *ret = &bump_alloc_pool[bump_alloc_ptr];
ffffffff8000103e:	48 05 20 b1 00 80    	add    $0xffffffff8000b120,%rax
    return ret;
ffffffff80001044:	c3                   	ret
ffffffff80001045:	0f 1f 00             	nopl   (%rax)
        return NULL;
ffffffff80001048:	31 c0                	xor    %eax,%eax
}
ffffffff8000104a:	c3                   	ret
ffffffff8000104b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001050 <flanterm_fb_save_state>:
    uint32_t g = (colour >> 8) & 0xff;
    uint32_t b =  colour & 0xff;
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
}

static void flanterm_fb_save_state(struct flanterm_context *_ctx) {
ffffffff80001050:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    ctx->saved_state_text_fg = ctx->text_fg;
ffffffff80001054:	48 8b 87 e0 02 00 00 	mov    0x2e0(%rdi),%rax
    ctx->saved_state_text_bg = ctx->text_bg;
    ctx->saved_state_cursor_x = ctx->cursor_x;
ffffffff8000105b:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
    ctx->saved_state_text_fg = ctx->text_fg;
ffffffff80001062:	48 89 87 f8 02 00 00 	mov    %rax,0x2f8(%rdi)
    ctx->saved_state_cursor_x = ctx->cursor_x;
ffffffff80001069:	48 8b 87 f0 02 00 00 	mov    0x2f0(%rdi),%rax
ffffffff80001070:	48 89 97 00 03 00 00 	mov    %rdx,0x300(%rdi)
ffffffff80001077:	48 89 87 08 03 00 00 	mov    %rax,0x308(%rdi)
    ctx->saved_state_cursor_y = ctx->cursor_y;
}
ffffffff8000107e:	c3                   	ret
ffffffff8000107f:	90                   	nop

ffffffff80001080 <flanterm_fb_restore_state>:

static void flanterm_fb_restore_state(struct flanterm_context *_ctx) {
ffffffff80001080:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    ctx->text_fg = ctx->saved_state_text_fg;
ffffffff80001084:	48 8b 87 f8 02 00 00 	mov    0x2f8(%rdi),%rax
    ctx->text_bg = ctx->saved_state_text_bg;
    ctx->cursor_x = ctx->saved_state_cursor_x;
ffffffff8000108b:	48 8b 97 00 03 00 00 	mov    0x300(%rdi),%rdx
    ctx->text_fg = ctx->saved_state_text_fg;
ffffffff80001092:	48 89 87 e0 02 00 00 	mov    %rax,0x2e0(%rdi)
    ctx->cursor_x = ctx->saved_state_cursor_x;
ffffffff80001099:	48 8b 87 08 03 00 00 	mov    0x308(%rdi),%rax
ffffffff800010a0:	48 89 97 e8 02 00 00 	mov    %rdx,0x2e8(%rdi)
ffffffff800010a7:	48 89 87 f0 02 00 00 	mov    %rax,0x2f0(%rdi)
    ctx->cursor_y = ctx->saved_state_cursor_y;
}
ffffffff800010ae:	c3                   	ret
ffffffff800010af:	90                   	nop

ffffffff800010b0 <flanterm_fb_swap_palette>:

static void flanterm_fb_swap_palette(struct flanterm_context *_ctx) {
ffffffff800010b0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;
    uint32_t tmp = ctx->text_bg;
    ctx->text_bg = ctx->text_fg;
    ctx->text_fg = tmp;
ffffffff800010b4:	8b 97 e0 02 00 00    	mov    0x2e0(%rdi),%edx
ffffffff800010ba:	8b 87 e4 02 00 00    	mov    0x2e4(%rdi),%eax
ffffffff800010c0:	48 c1 e2 20          	shl    $0x20,%rdx
ffffffff800010c4:	48 09 d0             	or     %rdx,%rax
ffffffff800010c7:	48 89 87 e0 02 00 00 	mov    %rax,0x2e0(%rdi)
}
ffffffff800010ce:	c3                   	ret
ffffffff800010cf:	90                   	nop

ffffffff800010d0 <push_to_queue>:

static inline bool compare_char(struct flanterm_fb_char *a, struct flanterm_fb_char *b) {
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
}

static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff800010d0:	49 89 f0             	mov    %rsi,%r8
ffffffff800010d3:	48 89 ce             	mov    %rcx,%rsi
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff800010d6:	48 8b 8f e8 00 00 00 	mov    0xe8(%rdi),%rcx
static void push_to_queue(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff800010dd:	48 89 f8             	mov    %rdi,%rax
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff800010e0:	48 39 ca             	cmp    %rcx,%rdx
ffffffff800010e3:	73 31                	jae    ffffffff80001116 <push_to_queue+0x46>
ffffffff800010e5:	48 3b b7 e0 00 00 00 	cmp    0xe0(%rdi),%rsi
ffffffff800010ec:	73 28                	jae    ffffffff80001116 <push_to_queue+0x46>
        return;
    }

    size_t i = y * _ctx->cols + x;
ffffffff800010ee:	48 0f af ce          	imul   %rsi,%rcx

    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800010f2:	48 8b bf d8 02 00 00 	mov    0x2d8(%rdi),%rdi
    size_t i = y * _ctx->cols + x;
ffffffff800010f9:	48 01 d1             	add    %rdx,%rcx
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800010fc:	4c 8d 0c cf          	lea    (%rdi,%rcx,8),%r9
ffffffff80001100:	49 8b 39             	mov    (%r9),%rdi

    if (q == NULL) {
ffffffff80001103:	48 85 ff             	test   %rdi,%rdi
ffffffff80001106:	74 18                	je     ffffffff80001120 <push_to_queue+0x50>
        q->x = x;
        q->y = y;
        ctx->map[i] = q;
    }

    q->c = *c;
ffffffff80001108:	49 8b 00             	mov    (%r8),%rax
ffffffff8000110b:	48 89 47 10          	mov    %rax,0x10(%rdi)
ffffffff8000110f:	41 8b 40 08          	mov    0x8(%r8),%eax
ffffffff80001113:	89 47 18             	mov    %eax,0x18(%rdi)
}
ffffffff80001116:	c3                   	ret
ffffffff80001117:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000111e:	00 00 
        if (compare_char(&ctx->grid[i], c)) {
ffffffff80001120:	48 8d 3c 49          	lea    (%rcx,%rcx,2),%rdi
ffffffff80001124:	48 8b 88 c0 02 00 00 	mov    0x2c0(%rax),%rcx
ffffffff8000112b:	48 8d 0c b9          	lea    (%rcx,%rdi,4),%rcx
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
ffffffff8000112f:	41 8b 38             	mov    (%r8),%edi
ffffffff80001132:	39 39                	cmp    %edi,(%rcx)
ffffffff80001134:	74 2a                	je     ffffffff80001160 <push_to_queue+0x90>
        q = &ctx->queue[ctx->queue_i++];
ffffffff80001136:	48 8b b8 d0 02 00 00 	mov    0x2d0(%rax),%rdi
ffffffff8000113d:	48 8d 4f 01          	lea    0x1(%rdi),%rcx
ffffffff80001141:	48 c1 e7 05          	shl    $0x5,%rdi
ffffffff80001145:	48 03 b8 c8 02 00 00 	add    0x2c8(%rax),%rdi
ffffffff8000114c:	48 89 88 d0 02 00 00 	mov    %rcx,0x2d0(%rax)
        q->x = x;
ffffffff80001153:	48 89 17             	mov    %rdx,(%rdi)
        q->y = y;
ffffffff80001156:	48 89 77 08          	mov    %rsi,0x8(%rdi)
        ctx->map[i] = q;
ffffffff8000115a:	49 89 39             	mov    %rdi,(%r9)
ffffffff8000115d:	eb a9                	jmp    ffffffff80001108 <push_to_queue+0x38>
ffffffff8000115f:	90                   	nop
    return !(a->c != b->c || a->bg != b->bg || a->fg != b->fg);
ffffffff80001160:	41 8b 78 08          	mov    0x8(%r8),%edi
ffffffff80001164:	39 79 08             	cmp    %edi,0x8(%rcx)
ffffffff80001167:	75 cd                	jne    ffffffff80001136 <push_to_queue+0x66>
ffffffff80001169:	41 8b 78 04          	mov    0x4(%r8),%edi
ffffffff8000116d:	39 79 04             	cmp    %edi,0x4(%rcx)
ffffffff80001170:	75 c4                	jne    ffffffff80001136 <push_to_queue+0x66>
}
ffffffff80001172:	c3                   	ret
ffffffff80001173:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000117a:	00 00 00 
ffffffff8000117d:	0f 1f 00             	nopl   (%rax)

ffffffff80001180 <flanterm_fb_revscroll>:

static void flanterm_fb_revscroll(struct flanterm_context *_ctx) {
ffffffff80001180:	f3 0f 1e fa          	endbr64
ffffffff80001184:	41 55                	push   %r13
ffffffff80001186:	41 54                	push   %r12
ffffffff80001188:	55                   	push   %rbp
ffffffff80001189:	53                   	push   %rbx
ffffffff8000118a:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000118d:	48 83 ec 10          	sub    $0x10,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff80001191:	48 8b 47 70          	mov    0x70(%rdi),%rax
ffffffff80001195:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff8000119c:	48 8b 6f 68          	mov    0x68(%rdi),%rbp
    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff800011a0:	48 83 e8 01          	sub    $0x1,%rax
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff800011a4:	4d 89 dc             	mov    %r11,%r12
    for (size_t i = (_ctx->scroll_bottom_margin - 1) * _ctx->cols - 1;
ffffffff800011a7:	49 0f af c3          	imul   %r11,%rax
         i >= _ctx->scroll_top_margin * _ctx->cols; i--) {
ffffffff800011ab:	4c 0f af e5          	imul   %rbp,%r12
        if (i == (size_t)-1) {
ffffffff800011af:	48 85 c0             	test   %rax,%rax
ffffffff800011b2:	74 5c                	je     ffffffff80001210 <flanterm_fb_revscroll+0x90>
ffffffff800011b4:	4c 8d 50 ff          	lea    -0x1(%rax),%r10
ffffffff800011b8:	4d 39 e2             	cmp    %r12,%r10
ffffffff800011bb:	72 53                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
            break;
        }
        struct flanterm_fb_char *c;
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800011bd:	4c 8b af d8 02 00 00 	mov    0x2d8(%rdi),%r13
ffffffff800011c4:	eb 2d                	jmp    ffffffff800011f3 <flanterm_fb_revscroll+0x73>
ffffffff800011c6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800011cd:	00 00 00 
        if (q != NULL) {
            c = &q->c;
ffffffff800011d0:	48 83 c6 10          	add    $0x10,%rsi
        } else {
            c = &ctx->grid[i];
        }
        push_to_queue(_ctx, c, (i + _ctx->cols) % _ctx->cols, (i + _ctx->cols) / _ctx->cols);
ffffffff800011d4:	4b 8d 04 13          	lea    (%r11,%r10,1),%rax
ffffffff800011d8:	31 d2                	xor    %edx,%edx
ffffffff800011da:	48 89 df             	mov    %rbx,%rdi
ffffffff800011dd:	49 f7 f3             	div    %r11
ffffffff800011e0:	48 89 c1             	mov    %rax,%rcx
ffffffff800011e3:	e8 e8 fe ff ff       	call   ffffffff800010d0 <push_to_queue>
        if (i == (size_t)-1) {
ffffffff800011e8:	49 83 ea 01          	sub    $0x1,%r10
ffffffff800011ec:	72 22                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
ffffffff800011ee:	4d 39 e2             	cmp    %r12,%r10
ffffffff800011f1:	72 1d                	jb     ffffffff80001210 <flanterm_fb_revscroll+0x90>
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800011f3:	4b 8b 74 d5 00       	mov    0x0(%r13,%r10,8),%rsi
        if (q != NULL) {
ffffffff800011f8:	48 85 f6             	test   %rsi,%rsi
ffffffff800011fb:	75 d3                	jne    ffffffff800011d0 <flanterm_fb_revscroll+0x50>
            c = &ctx->grid[i];
ffffffff800011fd:	48 8b 93 c0 02 00 00 	mov    0x2c0(%rbx),%rdx
ffffffff80001204:	4b 8d 04 52          	lea    (%r10,%r10,2),%rax
ffffffff80001208:	48 8d 34 82          	lea    (%rdx,%rax,4),%rsi
ffffffff8000120c:	eb c6                	jmp    ffffffff800011d4 <flanterm_fb_revscroll+0x54>
ffffffff8000120e:	66 90                	xchg   %ax,%ax
    }

    // Clear the first line of the screen.
    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
ffffffff80001210:	48 8b 83 e0 02 00 00 	mov    0x2e0(%rbx),%rax
    empty.c  = ' ';
ffffffff80001217:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff8000121e:	00 
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff8000121f:	31 d2                	xor    %edx,%edx
    empty.fg = ctx->text_fg;
ffffffff80001221:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001226:	4d 85 db             	test   %r11,%r11
ffffffff80001229:	74 1e                	je     ffffffff80001249 <flanterm_fb_revscroll+0xc9>
ffffffff8000122b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        push_to_queue(_ctx, &empty, i, _ctx->scroll_top_margin);
ffffffff80001230:	48 89 e9             	mov    %rbp,%rcx
ffffffff80001233:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff80001238:	48 89 df             	mov    %rbx,%rdi
ffffffff8000123b:	e8 90 fe ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001240:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001244:	49 39 d3             	cmp    %rdx,%r11
ffffffff80001247:	75 e7                	jne    ffffffff80001230 <flanterm_fb_revscroll+0xb0>
    }
}
ffffffff80001249:	48 83 c4 10          	add    $0x10,%rsp
ffffffff8000124d:	5b                   	pop    %rbx
ffffffff8000124e:	5d                   	pop    %rbp
ffffffff8000124f:	41 5c                	pop    %r12
ffffffff80001251:	41 5d                	pop    %r13
ffffffff80001253:	c3                   	ret
ffffffff80001254:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000125b:	00 00 00 
ffffffff8000125e:	66 90                	xchg   %ax,%ax

ffffffff80001260 <flanterm_fb_scroll>:

static void flanterm_fb_scroll(struct flanterm_context *_ctx) {
ffffffff80001260:	f3 0f 1e fa          	endbr64
ffffffff80001264:	41 56                	push   %r14
ffffffff80001266:	41 55                	push   %r13
ffffffff80001268:	41 54                	push   %r12
ffffffff8000126a:	55                   	push   %rbp
ffffffff8000126b:	53                   	push   %rbx
ffffffff8000126c:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000126f:	48 83 ec 10          	sub    $0x10,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001273:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
ffffffff8000127a:	48 8b 47 68          	mov    0x68(%rdi),%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff8000127e:	48 8b 6f 70          	mov    0x70(%rdi),%rbp
    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001282:	48 83 c0 01          	add    $0x1,%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff80001286:	4d 89 dc             	mov    %r11,%r12
    for (size_t i = (_ctx->scroll_top_margin + 1) * _ctx->cols;
ffffffff80001289:	49 0f af c3          	imul   %r11,%rax
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff8000128d:	4c 0f af e5          	imul   %rbp,%r12
ffffffff80001291:	4c 39 e0             	cmp    %r12,%rax
ffffffff80001294:	73 62                	jae    ffffffff800012f8 <flanterm_fb_scroll+0x98>
ffffffff80001296:	49 89 c2             	mov    %rax,%r10
ffffffff80001299:	4c 8d 34 40          	lea    (%rax,%rax,2),%r14
ffffffff8000129d:	48 8b 87 d8 02 00 00 	mov    0x2d8(%rdi),%rax
ffffffff800012a4:	4d 29 dc             	sub    %r11,%r12
ffffffff800012a7:	4d 29 da             	sub    %r11,%r10
ffffffff800012aa:	49 c1 e6 02          	shl    $0x2,%r14
ffffffff800012ae:	4e 8d 2c d8          	lea    (%rax,%r11,8),%r13
ffffffff800012b2:	eb 28                	jmp    ffffffff800012dc <flanterm_fb_scroll+0x7c>
ffffffff800012b4:	0f 1f 40 00          	nopl   0x0(%rax)
        struct flanterm_fb_char *c;
        struct flanterm_fb_queue_item *q = ctx->map[i];
        if (q != NULL) {
            c = &q->c;
ffffffff800012b8:	48 83 c6 10          	add    $0x10,%rsi
        } else {
            c = &ctx->grid[i];
        }
        push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);
ffffffff800012bc:	4c 89 d0             	mov    %r10,%rax
ffffffff800012bf:	31 d2                	xor    %edx,%edx
ffffffff800012c1:	48 89 df             	mov    %rbx,%rdi
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff800012c4:	49 83 c2 01          	add    $0x1,%r10
ffffffff800012c8:	49 f7 f3             	div    %r11
ffffffff800012cb:	49 83 c6 0c          	add    $0xc,%r14
ffffffff800012cf:	48 89 c1             	mov    %rax,%rcx
        push_to_queue(_ctx, c, (i - _ctx->cols) % _ctx->cols, (i - _ctx->cols) / _ctx->cols);
ffffffff800012d2:	e8 f9 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
         i < _ctx->scroll_bottom_margin * _ctx->cols; i++) {
ffffffff800012d7:	4d 39 d4             	cmp    %r10,%r12
ffffffff800012da:	74 1c                	je     ffffffff800012f8 <flanterm_fb_scroll+0x98>
        struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800012dc:	4b 8b 74 d5 00       	mov    0x0(%r13,%r10,8),%rsi
        if (q != NULL) {
ffffffff800012e1:	48 85 f6             	test   %rsi,%rsi
ffffffff800012e4:	75 d2                	jne    ffffffff800012b8 <flanterm_fb_scroll+0x58>
            c = &ctx->grid[i];
ffffffff800012e6:	48 8b b3 c0 02 00 00 	mov    0x2c0(%rbx),%rsi
ffffffff800012ed:	4c 01 f6             	add    %r14,%rsi
ffffffff800012f0:	eb ca                	jmp    ffffffff800012bc <flanterm_fb_scroll+0x5c>
ffffffff800012f2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
    }

    // Clear the last line of the screen.
    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
ffffffff800012f8:	48 8b 83 e0 02 00 00 	mov    0x2e0(%rbx),%rax
    empty.c  = ' ';
ffffffff800012ff:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff80001306:	00 
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->cols; i++) {
        push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);
ffffffff80001307:	48 83 ed 01          	sub    $0x1,%rbp
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff8000130b:	31 d2                	xor    %edx,%edx
    empty.fg = ctx->text_fg;
ffffffff8000130d:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001312:	4d 85 db             	test   %r11,%r11
ffffffff80001315:	74 22                	je     ffffffff80001339 <flanterm_fb_scroll+0xd9>
ffffffff80001317:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000131e:	00 00 
        push_to_queue(_ctx, &empty, i, _ctx->scroll_bottom_margin - 1);
ffffffff80001320:	48 89 e9             	mov    %rbp,%rcx
ffffffff80001323:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff80001328:	48 89 df             	mov    %rbx,%rdi
ffffffff8000132b:	e8 a0 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->cols; i++) {
ffffffff80001330:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001334:	49 39 d3             	cmp    %rdx,%r11
ffffffff80001337:	75 e7                	jne    ffffffff80001320 <flanterm_fb_scroll+0xc0>
    }
}
ffffffff80001339:	48 83 c4 10          	add    $0x10,%rsp
ffffffff8000133d:	5b                   	pop    %rbx
ffffffff8000133e:	5d                   	pop    %rbp
ffffffff8000133f:	41 5c                	pop    %r12
ffffffff80001341:	41 5d                	pop    %r13
ffffffff80001343:	41 5e                	pop    %r14
ffffffff80001345:	c3                   	ret
ffffffff80001346:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000134d:	00 00 00 

ffffffff80001350 <flanterm_fb_clear>:

static void flanterm_fb_clear(struct flanterm_context *_ctx, bool move) {
ffffffff80001350:	f3 0f 1e fa          	endbr64
ffffffff80001354:	41 54                	push   %r12
ffffffff80001356:	41 89 f4             	mov    %esi,%r12d
ffffffff80001359:	55                   	push   %rbp
ffffffff8000135a:	53                   	push   %rbx
ffffffff8000135b:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000135e:	48 83 ec 10          	sub    $0x10,%rsp

    struct flanterm_fb_char empty;
    empty.c  = ' ';
    empty.fg = ctx->text_fg;
    empty.bg = ctx->text_bg;
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80001362:	4c 8b 9f e8 00 00 00 	mov    0xe8(%rdi),%r11
ffffffff80001369:	48 8b af e0 00 00 00 	mov    0xe0(%rdi),%rbp
    empty.fg = ctx->text_fg;
ffffffff80001370:	48 8b 87 e0 02 00 00 	mov    0x2e0(%rdi),%rax
    empty.c  = ' ';
ffffffff80001377:	c7 44 24 04 20 00 00 	movl   $0x20,0x4(%rsp)
ffffffff8000137e:	00 
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff8000137f:	49 0f af eb          	imul   %r11,%rbp
    empty.fg = ctx->text_fg;
ffffffff80001383:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80001388:	48 85 ed             	test   %rbp,%rbp
ffffffff8000138b:	74 24                	je     ffffffff800013b1 <flanterm_fb_clear+0x61>
ffffffff8000138d:	45 31 d2             	xor    %r10d,%r10d
        push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);
ffffffff80001390:	4c 89 d0             	mov    %r10,%rax
ffffffff80001393:	31 d2                	xor    %edx,%edx
ffffffff80001395:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff8000139a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000139d:	49 f7 f3             	div    %r11
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800013a0:	49 83 c2 01          	add    $0x1,%r10
ffffffff800013a4:	48 89 c1             	mov    %rax,%rcx
        push_to_queue(_ctx, &empty, i % _ctx->cols, i / _ctx->cols);
ffffffff800013a7:	e8 24 fd ff ff       	call   ffffffff800010d0 <push_to_queue>
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800013ac:	49 39 ea             	cmp    %rbp,%r10
ffffffff800013af:	75 df                	jne    ffffffff80001390 <flanterm_fb_clear+0x40>
    }

    if (move) {
ffffffff800013b1:	45 84 e4             	test   %r12b,%r12b
ffffffff800013b4:	74 16                	je     ffffffff800013cc <flanterm_fb_clear+0x7c>
        ctx->cursor_x = 0;
ffffffff800013b6:	48 c7 83 e8 02 00 00 	movq   $0x0,0x2e8(%rbx)
ffffffff800013bd:	00 00 00 00 
        ctx->cursor_y = 0;
ffffffff800013c1:	48 c7 83 f0 02 00 00 	movq   $0x0,0x2f0(%rbx)
ffffffff800013c8:	00 00 00 00 
    }
}
ffffffff800013cc:	48 83 c4 10          	add    $0x10,%rsp
ffffffff800013d0:	5b                   	pop    %rbx
ffffffff800013d1:	5d                   	pop    %rbp
ffffffff800013d2:	41 5c                	pop    %r12
ffffffff800013d4:	c3                   	ret
ffffffff800013d5:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800013dc:	00 00 00 
ffffffff800013df:	90                   	nop

ffffffff800013e0 <flanterm_fb_set_cursor_pos>:

static void flanterm_fb_set_cursor_pos(struct flanterm_context *_ctx, size_t x, size_t y) {
ffffffff800013e0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (x >= _ctx->cols) {
ffffffff800013e4:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff800013eb:	48 39 c6             	cmp    %rax,%rsi
ffffffff800013ee:	72 0f                	jb     ffffffff800013ff <flanterm_fb_set_cursor_pos+0x1f>
        if ((int)x < 0) {
            x = 0;
        } else {
            x = _ctx->cols - 1;
ffffffff800013f0:	48 83 e8 01          	sub    $0x1,%rax
ffffffff800013f4:	85 f6                	test   %esi,%esi
ffffffff800013f6:	be 00 00 00 00       	mov    $0x0,%esi
ffffffff800013fb:	48 0f 49 f0          	cmovns %rax,%rsi
        }
    }
    if (y >= _ctx->rows) {
ffffffff800013ff:	48 8b 87 e0 00 00 00 	mov    0xe0(%rdi),%rax
ffffffff80001406:	48 39 c2             	cmp    %rax,%rdx
ffffffff80001409:	72 0f                	jb     ffffffff8000141a <flanterm_fb_set_cursor_pos+0x3a>
        if ((int)y < 0) {
            y = 0;
        } else {
            y = _ctx->rows - 1;
ffffffff8000140b:	48 83 e8 01          	sub    $0x1,%rax
ffffffff8000140f:	85 d2                	test   %edx,%edx
ffffffff80001411:	ba 00 00 00 00       	mov    $0x0,%edx
ffffffff80001416:	48 0f 49 d0          	cmovns %rax,%rdx
        }
    }
    ctx->cursor_x = x;
ffffffff8000141a:	48 89 b7 e8 02 00 00 	mov    %rsi,0x2e8(%rdi)
    ctx->cursor_y = y;
ffffffff80001421:	48 89 97 f0 02 00 00 	mov    %rdx,0x2f0(%rdi)
}
ffffffff80001428:	c3                   	ret
ffffffff80001429:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80001430 <flanterm_fb_get_cursor_pos>:

static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {
ffffffff80001430:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;
ffffffff80001434:	48 8b 87 e8 02 00 00 	mov    0x2e8(%rdi),%rax
static void flanterm_fb_get_cursor_pos(struct flanterm_context *_ctx, size_t *x, size_t *y) {
ffffffff8000143b:	48 89 d1             	mov    %rdx,%rcx
    *x = ctx->cursor_x >= _ctx->cols ? _ctx->cols - 1 : ctx->cursor_x;
ffffffff8000143e:	48 8b 97 e8 00 00 00 	mov    0xe8(%rdi),%rdx
ffffffff80001445:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001448:	4c 8d 42 ff          	lea    -0x1(%rdx),%r8
ffffffff8000144c:	49 0f 43 c0          	cmovae %r8,%rax
ffffffff80001450:	48 89 06             	mov    %rax,(%rsi)
    *y = ctx->cursor_y >= _ctx->rows ? _ctx->rows - 1 : ctx->cursor_y;
ffffffff80001453:	48 8b 87 f0 02 00 00 	mov    0x2f0(%rdi),%rax
ffffffff8000145a:	48 8b 97 e0 00 00 00 	mov    0xe0(%rdi),%rdx
ffffffff80001461:	48 8d 72 ff          	lea    -0x1(%rdx),%rsi
ffffffff80001465:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001468:	48 0f 43 c6          	cmovae %rsi,%rax
ffffffff8000146c:	48 89 01             	mov    %rax,(%rcx)
}
ffffffff8000146f:	c3                   	ret

ffffffff80001470 <flanterm_fb_move_character>:

static void flanterm_fb_move_character(struct flanterm_context *_ctx, size_t new_x, size_t new_y, size_t old_x, size_t old_y) {
ffffffff80001470:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (old_x >= _ctx->cols || old_y >= _ctx->rows
ffffffff80001474:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff8000147b:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000147e:	73 1f                	jae    ffffffff8000149f <flanterm_fb_move_character+0x2f>
ffffffff80001480:	4c 8b 97 e0 00 00 00 	mov    0xe0(%rdi),%r10
     || new_x >= _ctx->cols || new_y >= _ctx->rows) {
ffffffff80001487:	48 39 c6             	cmp    %rax,%rsi
ffffffff8000148a:	41 0f 93 c1          	setae  %r9b
    if (old_x >= _ctx->cols || old_y >= _ctx->rows
ffffffff8000148e:	4d 39 d0             	cmp    %r10,%r8
ffffffff80001491:	41 0f 93 c3          	setae  %r11b
     || new_x >= _ctx->cols || new_y >= _ctx->rows) {
ffffffff80001495:	45 08 d9             	or     %r11b,%r9b
ffffffff80001498:	75 05                	jne    ffffffff8000149f <flanterm_fb_move_character+0x2f>
ffffffff8000149a:	4c 39 d2             	cmp    %r10,%rdx
ffffffff8000149d:	72 01                	jb     ffffffff800014a0 <flanterm_fb_move_character+0x30>
    } else {
        c = &ctx->grid[i];
    }

    push_to_queue(_ctx, c, new_x, new_y);
}
ffffffff8000149f:	c3                   	ret
    size_t i = old_x + old_y * _ctx->cols;
ffffffff800014a0:	49 0f af c0          	imul   %r8,%rax
ffffffff800014a4:	48 01 c8             	add    %rcx,%rax
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800014a7:	48 8b 8f d8 02 00 00 	mov    0x2d8(%rdi),%rcx
ffffffff800014ae:	48 8b 0c c1          	mov    (%rcx,%rax,8),%rcx
    if (q != NULL) {
ffffffff800014b2:	48 85 c9             	test   %rcx,%rcx
ffffffff800014b5:	74 19                	je     ffffffff800014d0 <flanterm_fb_move_character+0x60>
        c = &q->c;
ffffffff800014b7:	48 8d 41 10          	lea    0x10(%rcx),%rax
    push_to_queue(_ctx, c, new_x, new_y);
ffffffff800014bb:	48 89 d1             	mov    %rdx,%rcx
ffffffff800014be:	48 89 f2             	mov    %rsi,%rdx
ffffffff800014c1:	48 89 c6             	mov    %rax,%rsi
ffffffff800014c4:	e9 07 fc ff ff       	jmp    ffffffff800010d0 <push_to_queue>
ffffffff800014c9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        c = &ctx->grid[i];
ffffffff800014d0:	48 8d 0c 40          	lea    (%rax,%rax,2),%rcx
ffffffff800014d4:	48 8b 87 c0 02 00 00 	mov    0x2c0(%rdi),%rax
ffffffff800014db:	48 8d 04 88          	lea    (%rax,%rcx,4),%rax
ffffffff800014df:	eb da                	jmp    ffffffff800014bb <flanterm_fb_move_character+0x4b>
ffffffff800014e1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800014e8:	00 00 00 
ffffffff800014eb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff800014f0 <flanterm_fb_set_text_fg>:

static void flanterm_fb_set_text_fg(struct flanterm_context *_ctx, size_t fg) {
ffffffff800014f0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->ansi_colours[fg];
ffffffff800014f4:	8b 84 b7 48 02 00 00 	mov    0x248(%rdi,%rsi,4),%eax
ffffffff800014fb:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001501:	c3                   	ret
ffffffff80001502:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001509:	00 00 00 
ffffffff8000150c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001510 <flanterm_fb_set_text_bg>:

static void flanterm_fb_set_text_bg(struct flanterm_context *_ctx, size_t bg) {
ffffffff80001510:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->ansi_colours[bg];
ffffffff80001514:	8b 84 b7 48 02 00 00 	mov    0x248(%rdi,%rsi,4),%eax
ffffffff8000151b:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001521:	c3                   	ret
ffffffff80001522:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001529:	00 00 00 
ffffffff8000152c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001530 <flanterm_fb_set_text_fg_bright>:

static void flanterm_fb_set_text_fg_bright(struct flanterm_context *_ctx, size_t fg) {
ffffffff80001530:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->ansi_bright_colours[fg];
ffffffff80001534:	8b 84 b7 68 02 00 00 	mov    0x268(%rdi,%rsi,4),%eax
ffffffff8000153b:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001541:	c3                   	ret
ffffffff80001542:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001549:	00 00 00 
ffffffff8000154c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001550 <flanterm_fb_set_text_bg_bright>:

static void flanterm_fb_set_text_bg_bright(struct flanterm_context *_ctx, size_t bg) {
ffffffff80001550:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->ansi_bright_colours[bg];
ffffffff80001554:	8b 84 b7 68 02 00 00 	mov    0x268(%rdi,%rsi,4),%eax
ffffffff8000155b:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001561:	c3                   	ret
ffffffff80001562:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001569:	00 00 00 
ffffffff8000156c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001570 <flanterm_fb_set_text_fg_rgb>:

static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {
ffffffff80001570:	f3 0f 1e fa          	endbr64
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80001574:	89 f0                	mov    %esi,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80001576:	0f b6 8f 21 02 00 00 	movzbl 0x221(%rdi),%ecx
static void flanterm_fb_set_text_fg_rgb(struct flanterm_context *_ctx, uint32_t fg) {
ffffffff8000157d:	89 f2                	mov    %esi,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000157f:	c1 e8 10             	shr    $0x10,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80001582:	0f b6 f6             	movzbl %dh,%esi
    uint32_t b =  colour & 0xff;
ffffffff80001585:	0f b6 d2             	movzbl %dl,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80001588:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000158b:	d3 e0                	shl    %cl,%eax
ffffffff8000158d:	0f b6 8f 23 02 00 00 	movzbl 0x223(%rdi),%ecx
ffffffff80001594:	d3 e6                	shl    %cl,%esi
ffffffff80001596:	0f b6 8f 25 02 00 00 	movzbl 0x225(%rdi),%ecx
ffffffff8000159d:	09 f0                	or     %esi,%eax
ffffffff8000159f:	d3 e2                	shl    %cl,%edx
ffffffff800015a1:	09 d0                	or     %edx,%eax
ffffffff800015a3:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = convert_colour(_ctx, fg);
}
ffffffff800015a9:	c3                   	ret
ffffffff800015aa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800015b0 <flanterm_fb_set_text_bg_rgb>:

static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {
ffffffff800015b0:	f3 0f 1e fa          	endbr64
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015b4:	89 f0                	mov    %esi,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800015b6:	0f b6 8f 21 02 00 00 	movzbl 0x221(%rdi),%ecx
static void flanterm_fb_set_text_bg_rgb(struct flanterm_context *_ctx, uint32_t bg) {
ffffffff800015bd:	89 f2                	mov    %esi,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015bf:	c1 e8 10             	shr    $0x10,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800015c2:	0f b6 f6             	movzbl %dh,%esi
    uint32_t b =  colour & 0xff;
ffffffff800015c5:	0f b6 d2             	movzbl %dl,%edx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800015c8:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800015cb:	d3 e0                	shl    %cl,%eax
ffffffff800015cd:	0f b6 8f 23 02 00 00 	movzbl 0x223(%rdi),%ecx
ffffffff800015d4:	d3 e6                	shl    %cl,%esi
ffffffff800015d6:	0f b6 8f 25 02 00 00 	movzbl 0x225(%rdi),%ecx
ffffffff800015dd:	09 f0                	or     %esi,%eax
ffffffff800015df:	d3 e2                	shl    %cl,%edx
ffffffff800015e1:	09 d0                	or     %edx,%eax
ffffffff800015e3:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = convert_colour(_ctx, bg);
}
ffffffff800015e9:	c3                   	ret
ffffffff800015ea:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800015f0 <flanterm_fb_set_text_fg_default>:

static void flanterm_fb_set_text_fg_default(struct flanterm_context *_ctx) {
ffffffff800015f0:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->default_fg;
ffffffff800015f4:	8b 87 88 02 00 00    	mov    0x288(%rdi),%eax
ffffffff800015fa:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001600:	c3                   	ret
ffffffff80001601:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001608:	00 00 00 
ffffffff8000160b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001610 <flanterm_fb_set_text_bg_default>:

static void flanterm_fb_set_text_bg_default(struct flanterm_context *_ctx) {
ffffffff80001610:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = 0xffffffff;
ffffffff80001614:	c7 87 e4 02 00 00 ff 	movl   $0xffffffff,0x2e4(%rdi)
ffffffff8000161b:	ff ff ff 
}
ffffffff8000161e:	c3                   	ret
ffffffff8000161f:	90                   	nop

ffffffff80001620 <flanterm_fb_set_text_fg_default_bright>:

static void flanterm_fb_set_text_fg_default_bright(struct flanterm_context *_ctx) {
ffffffff80001620:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_fg = ctx->default_fg_bright;
ffffffff80001624:	8b 87 90 02 00 00    	mov    0x290(%rdi),%eax
ffffffff8000162a:	89 87 e0 02 00 00    	mov    %eax,0x2e0(%rdi)
}
ffffffff80001630:	c3                   	ret
ffffffff80001631:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001638:	00 00 00 
ffffffff8000163b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001640 <flanterm_fb_set_text_bg_default_bright>:

static void flanterm_fb_set_text_bg_default_bright(struct flanterm_context *_ctx) {
ffffffff80001640:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    ctx->text_bg = ctx->default_bg_bright;
ffffffff80001644:	8b 87 94 02 00 00    	mov    0x294(%rdi),%eax
ffffffff8000164a:	89 87 e4 02 00 00    	mov    %eax,0x2e4(%rdi)
}
ffffffff80001650:	c3                   	ret
ffffffff80001651:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001658:	00 00 00 
ffffffff8000165b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001660 <draw_cursor>:

static void draw_cursor(struct flanterm_context *_ctx) {
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {
ffffffff80001660:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
ffffffff80001667:	48 8b 87 e8 00 00 00 	mov    0xe8(%rdi),%rax
ffffffff8000166e:	48 39 c2             	cmp    %rax,%rdx
ffffffff80001671:	0f 83 a1 00 00 00    	jae    ffffffff80001718 <draw_cursor+0xb8>
static void draw_cursor(struct flanterm_context *_ctx) {
ffffffff80001677:	41 55                	push   %r13
ffffffff80001679:	41 54                	push   %r12
ffffffff8000167b:	55                   	push   %rbp
ffffffff8000167c:	53                   	push   %rbx
ffffffff8000167d:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001680:	48 83 ec 18          	sub    $0x18,%rsp
    if (ctx->cursor_x >= _ctx->cols || ctx->cursor_y >= _ctx->rows) {
ffffffff80001684:	48 8b 8f f0 02 00 00 	mov    0x2f0(%rdi),%rcx
ffffffff8000168b:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001692:	73 73                	jae    ffffffff80001707 <draw_cursor+0xa7>
        return;
    }

    size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;
ffffffff80001694:	48 0f af c1          	imul   %rcx,%rax
        c = ctx->grid[i];
    }
    uint32_t tmp = c.fg;
    c.fg = c.bg;
    c.bg = tmp;
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff80001698:	4c 8b 87 b0 01 00 00 	mov    0x1b0(%rdi),%r8
    size_t i = ctx->cursor_x + ctx->cursor_y * _ctx->cols;
ffffffff8000169f:	48 8d 2c 10          	lea    (%rax,%rdx,1),%rbp
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800016a3:	48 8b 87 d8 02 00 00 	mov    0x2d8(%rdi),%rax
    if (q != NULL) {
        ctx->grid[i] = q->c;
ffffffff800016aa:	4c 8d 64 6d 00       	lea    0x0(%rbp,%rbp,2),%r12
    struct flanterm_fb_queue_item *q = ctx->map[i];
ffffffff800016af:	4c 8b 2c e8          	mov    (%rax,%rbp,8),%r13
        ctx->grid[i] = q->c;
ffffffff800016b3:	49 c1 e4 02          	shl    $0x2,%r12
    if (q != NULL) {
ffffffff800016b7:	4d 85 ed             	test   %r13,%r13
ffffffff800016ba:	74 64                	je     ffffffff80001720 <draw_cursor+0xc0>
        c = q->c;
ffffffff800016bc:	49 8b 45 10          	mov    0x10(%r13),%rax
ffffffff800016c0:	48 89 44 24 04       	mov    %rax,0x4(%rsp)
ffffffff800016c5:	48 89 c6             	mov    %rax,%rsi
ffffffff800016c8:	41 8b 45 18          	mov    0x18(%r13),%eax
ffffffff800016cc:	48 c1 ee 20          	shr    $0x20,%rsi
    c.fg = c.bg;
ffffffff800016d0:	89 44 24 08          	mov    %eax,0x8(%rsp)
    c.bg = tmp;
ffffffff800016d4:	89 74 24 0c          	mov    %esi,0xc(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff800016d8:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
ffffffff800016dd:	41 ff d0             	call   *%r8
        ctx->grid[i] = q->c;
ffffffff800016e0:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff800016e7:	49 8b 55 10          	mov    0x10(%r13),%rdx
ffffffff800016eb:	4a 89 14 20          	mov    %rdx,(%rax,%r12,1)
ffffffff800016ef:	41 8b 55 18          	mov    0x18(%r13),%edx
ffffffff800016f3:	42 89 54 20 08       	mov    %edx,0x8(%rax,%r12,1)
        ctx->map[i] = NULL;
ffffffff800016f8:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff800016ff:	48 c7 04 e8 00 00 00 	movq   $0x0,(%rax,%rbp,8)
ffffffff80001706:	00 
    }
}
ffffffff80001707:	48 83 c4 18          	add    $0x18,%rsp
ffffffff8000170b:	5b                   	pop    %rbx
ffffffff8000170c:	5d                   	pop    %rbp
ffffffff8000170d:	41 5c                	pop    %r12
ffffffff8000170f:	41 5d                	pop    %r13
ffffffff80001711:	c3                   	ret
ffffffff80001712:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff80001718:	c3                   	ret
ffffffff80001719:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        c = ctx->grid[i];
ffffffff80001720:	48 8b 87 c0 02 00 00 	mov    0x2c0(%rdi),%rax
ffffffff80001727:	4a 8b 34 20          	mov    (%rax,%r12,1),%rsi
ffffffff8000172b:	48 89 74 24 04       	mov    %rsi,0x4(%rsp)
ffffffff80001730:	42 8b 74 20 08       	mov    0x8(%rax,%r12,1),%esi
    uint32_t tmp = c.fg;
ffffffff80001735:	8b 44 24 08          	mov    0x8(%rsp),%eax
    c.fg = c.bg;
ffffffff80001739:	89 74 24 08          	mov    %esi,0x8(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff8000173d:	48 8d 74 24 04       	lea    0x4(%rsp),%rsi
    c.bg = tmp;
ffffffff80001742:	89 44 24 0c          	mov    %eax,0xc(%rsp)
    ctx->plot_char(_ctx, &c, ctx->cursor_x, ctx->cursor_y);
ffffffff80001746:	41 ff d0             	call   *%r8
}
ffffffff80001749:	48 83 c4 18          	add    $0x18,%rsp
ffffffff8000174d:	5b                   	pop    %rbx
ffffffff8000174e:	5d                   	pop    %rbp
ffffffff8000174f:	41 5c                	pop    %r12
ffffffff80001751:	41 5d                	pop    %r13
ffffffff80001753:	c3                   	ret
ffffffff80001754:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000175b:	00 00 00 
ffffffff8000175e:	66 90                	xchg   %ax,%ax

ffffffff80001760 <flanterm_fb_double_buffer_flush>:

static void flanterm_fb_double_buffer_flush(struct flanterm_context *_ctx) {
ffffffff80001760:	f3 0f 1e fa          	endbr64
ffffffff80001764:	41 55                	push   %r13
ffffffff80001766:	41 54                	push   %r12
ffffffff80001768:	55                   	push   %rbp
ffffffff80001769:	53                   	push   %rbx
ffffffff8000176a:	48 89 fb             	mov    %rdi,%rbx
ffffffff8000176d:	48 83 ec 08          	sub    $0x8,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (_ctx->cursor_enabled) {
ffffffff80001771:	80 7f 09 00          	cmpb   $0x0,0x9(%rdi)
ffffffff80001775:	0f 85 35 01 00 00    	jne    ffffffff800018b0 <flanterm_fb_double_buffer_flush+0x150>
        draw_cursor(_ctx);
    }

    for (size_t i = 0; i < ctx->queue_i; i++) {
ffffffff8000177b:	48 83 bb d0 02 00 00 	cmpq   $0x0,0x2d0(%rbx)
ffffffff80001782:	00 
ffffffff80001783:	74 7b                	je     ffffffff80001800 <flanterm_fb_double_buffer_flush+0xa0>
ffffffff80001785:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff8000178c:	45 31 ed             	xor    %r13d,%r13d
ffffffff8000178f:	90                   	nop
        struct flanterm_fb_queue_item *q = &ctx->queue[i];
ffffffff80001790:	4c 89 ed             	mov    %r13,%rbp
        size_t offset = q->y * _ctx->cols + q->x;
ffffffff80001793:	4c 8b a3 e8 00 00 00 	mov    0xe8(%rbx),%r12
        struct flanterm_fb_queue_item *q = &ctx->queue[i];
ffffffff8000179a:	48 c1 e5 05          	shl    $0x5,%rbp
ffffffff8000179e:	48 03 ab c8 02 00 00 	add    0x2c8(%rbx),%rbp
        size_t offset = q->y * _ctx->cols + q->x;
ffffffff800017a5:	48 8b 4d 08          	mov    0x8(%rbp),%rcx
ffffffff800017a9:	48 8b 55 00          	mov    0x0(%rbp),%rdx
ffffffff800017ad:	4c 0f af e1          	imul   %rcx,%r12
ffffffff800017b1:	49 01 d4             	add    %rdx,%r12
        if (ctx->map[offset] == NULL) {
ffffffff800017b4:	4a 83 3c e0 00       	cmpq   $0x0,(%rax,%r12,8)
ffffffff800017b9:	74 38                	je     ffffffff800017f3 <flanterm_fb_double_buffer_flush+0x93>
            continue;
        }
        ctx->plot_char(_ctx, &q->c, q->x, q->y);
ffffffff800017bb:	48 8d 75 10          	lea    0x10(%rbp),%rsi
ffffffff800017bf:	48 89 df             	mov    %rbx,%rdi
ffffffff800017c2:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
        ctx->grid[offset] = q->c;
ffffffff800017c8:	48 8b 93 c0 02 00 00 	mov    0x2c0(%rbx),%rdx
ffffffff800017cf:	4b 8d 04 64          	lea    (%r12,%r12,2),%rax
ffffffff800017d3:	48 8d 04 82          	lea    (%rdx,%rax,4),%rax
ffffffff800017d7:	48 8b 55 10          	mov    0x10(%rbp),%rdx
ffffffff800017db:	48 89 10             	mov    %rdx,(%rax)
ffffffff800017de:	8b 55 18             	mov    0x18(%rbp),%edx
ffffffff800017e1:	89 50 08             	mov    %edx,0x8(%rax)
        ctx->map[offset] = NULL;
ffffffff800017e4:	48 8b 83 d8 02 00 00 	mov    0x2d8(%rbx),%rax
ffffffff800017eb:	4a c7 04 e0 00 00 00 	movq   $0x0,(%rax,%r12,8)
ffffffff800017f2:	00 
    for (size_t i = 0; i < ctx->queue_i; i++) {
ffffffff800017f3:	49 83 c5 01          	add    $0x1,%r13
ffffffff800017f7:	4c 3b ab d0 02 00 00 	cmp    0x2d0(%rbx),%r13
ffffffff800017fe:	72 90                	jb     ffffffff80001790 <flanterm_fb_double_buffer_flush+0x30>
    }

    if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {
ffffffff80001800:	48 8b 93 10 03 00 00 	mov    0x310(%rbx),%rdx
ffffffff80001807:	48 8b 8b e8 02 00 00 	mov    0x2e8(%rbx),%rcx
ffffffff8000180e:	48 39 ca             	cmp    %rcx,%rdx
ffffffff80001811:	74 7d                	je     ffffffff80001890 <flanterm_fb_double_buffer_flush+0x130>
        if (ctx->old_cursor_x < _ctx->cols && ctx->old_cursor_y < _ctx->rows) {
ffffffff80001813:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000181a:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000181d:	73 3c                	jae    ffffffff8000185b <flanterm_fb_double_buffer_flush+0xfb>
ffffffff8000181f:	48 8b b3 18 03 00 00 	mov    0x318(%rbx),%rsi
ffffffff80001826:	48 3b b3 e0 00 00 00 	cmp    0xe0(%rbx),%rsi
ffffffff8000182d:	73 2c                	jae    ffffffff8000185b <flanterm_fb_double_buffer_flush+0xfb>
            ctx->plot_char(_ctx, &ctx->grid[ctx->old_cursor_x + ctx->old_cursor_y * _ctx->cols], ctx->old_cursor_x, ctx->old_cursor_y);
ffffffff8000182f:	48 0f af c6          	imul   %rsi,%rax
ffffffff80001833:	48 89 df             	mov    %rbx,%rdi
ffffffff80001836:	48 01 d0             	add    %rdx,%rax
ffffffff80001839:	48 8d 0c 40          	lea    (%rax,%rax,2),%rcx
ffffffff8000183d:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff80001844:	48 8d 04 88          	lea    (%rax,%rcx,4),%rax
ffffffff80001848:	48 89 f1             	mov    %rsi,%rcx
ffffffff8000184b:	48 89 c6             	mov    %rax,%rsi
ffffffff8000184e:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
        }
    }

    ctx->old_cursor_x = ctx->cursor_x;
ffffffff80001854:	48 8b 8b e8 02 00 00 	mov    0x2e8(%rbx),%rcx
    ctx->old_cursor_y = ctx->cursor_y;
ffffffff8000185b:	48 8b 83 f0 02 00 00 	mov    0x2f0(%rbx),%rax
    ctx->old_cursor_x = ctx->cursor_x;
ffffffff80001862:	48 89 8b 10 03 00 00 	mov    %rcx,0x310(%rbx)
    ctx->old_cursor_y = ctx->cursor_y;
ffffffff80001869:	48 89 83 18 03 00 00 	mov    %rax,0x318(%rbx)

    ctx->queue_i = 0;
ffffffff80001870:	48 c7 83 d0 02 00 00 	movq   $0x0,0x2d0(%rbx)
ffffffff80001877:	00 00 00 00 
}
ffffffff8000187b:	48 83 c4 08          	add    $0x8,%rsp
ffffffff8000187f:	5b                   	pop    %rbx
ffffffff80001880:	5d                   	pop    %rbp
ffffffff80001881:	41 5c                	pop    %r12
ffffffff80001883:	41 5d                	pop    %r13
ffffffff80001885:	c3                   	ret
ffffffff80001886:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000188d:	00 00 00 
    if ((ctx->old_cursor_x != ctx->cursor_x || ctx->old_cursor_y != ctx->cursor_y) || _ctx->cursor_enabled == false) {
ffffffff80001890:	48 8b 83 f0 02 00 00 	mov    0x2f0(%rbx),%rax
ffffffff80001897:	48 39 83 18 03 00 00 	cmp    %rax,0x318(%rbx)
ffffffff8000189e:	0f 85 6f ff ff ff    	jne    ffffffff80001813 <flanterm_fb_double_buffer_flush+0xb3>
ffffffff800018a4:	80 7b 09 00          	cmpb   $0x0,0x9(%rbx)
ffffffff800018a8:	75 b8                	jne    ffffffff80001862 <flanterm_fb_double_buffer_flush+0x102>
ffffffff800018aa:	e9 64 ff ff ff       	jmp    ffffffff80001813 <flanterm_fb_double_buffer_flush+0xb3>
ffffffff800018af:	90                   	nop
        draw_cursor(_ctx);
ffffffff800018b0:	e8 ab fd ff ff       	call   ffffffff80001660 <draw_cursor>
ffffffff800018b5:	e9 c1 fe ff ff       	jmp    ffffffff8000177b <flanterm_fb_double_buffer_flush+0x1b>
ffffffff800018ba:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff800018c0 <flanterm_fb_raw_putchar>:

static void flanterm_fb_raw_putchar(struct flanterm_context *_ctx, uint8_t c) {
ffffffff800018c0:	f3 0f 1e fa          	endbr64
ffffffff800018c4:	55                   	push   %rbp
ffffffff800018c5:	53                   	push   %rbx
ffffffff800018c6:	89 f3                	mov    %esi,%ebx
ffffffff800018c8:	48 83 ec 20          	sub    $0x20,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {
ffffffff800018cc:	48 8b 97 e8 02 00 00 	mov    0x2e8(%rdi),%rdx
ffffffff800018d3:	48 8b af e8 00 00 00 	mov    0xe8(%rdi),%rbp
ffffffff800018da:	48 8b 8f f0 02 00 00 	mov    0x2f0(%rdi),%rcx
ffffffff800018e1:	48 39 ea             	cmp    %rbp,%rdx
ffffffff800018e4:	72 50                	jb     ffffffff80001936 <flanterm_fb_raw_putchar+0x76>
ffffffff800018e6:	48 8b 47 70          	mov    0x70(%rdi),%rax
ffffffff800018ea:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
ffffffff800018ee:	48 39 f1             	cmp    %rsi,%rcx
ffffffff800018f1:	73 3d                	jae    ffffffff80001930 <flanterm_fb_raw_putchar+0x70>
        ctx->cursor_x = 0;
ffffffff800018f3:	48 c7 87 e8 02 00 00 	movq   $0x0,0x2e8(%rdi)
ffffffff800018fa:	00 00 00 00 
        ctx->cursor_y++;
ffffffff800018fe:	48 8d 51 01          	lea    0x1(%rcx),%rdx
        if (ctx->cursor_y == _ctx->scroll_bottom_margin) {
ffffffff80001902:	48 39 d0             	cmp    %rdx,%rax
ffffffff80001905:	0f 84 7d 00 00 00    	je     ffffffff80001988 <flanterm_fb_raw_putchar+0xc8>
        ctx->cursor_y++;
ffffffff8000190b:	48 89 97 f0 02 00 00 	mov    %rdx,0x2f0(%rdi)
ffffffff80001912:	48 89 d1             	mov    %rdx,%rcx
            ctx->cursor_y--;
            flanterm_fb_scroll(_ctx);
        }
        if (ctx->cursor_y >= _ctx->cols) {
ffffffff80001915:	48 39 e9             	cmp    %rbp,%rcx
ffffffff80001918:	72 5e                	jb     ffffffff80001978 <flanterm_fb_raw_putchar+0xb8>
            ctx->cursor_y = _ctx->cols - 1;
ffffffff8000191a:	48 8d 4d ff          	lea    -0x1(%rbp),%rcx
ffffffff8000191e:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80001923:	31 d2                	xor    %edx,%edx
ffffffff80001925:	48 89 8f f0 02 00 00 	mov    %rcx,0x2f0(%rdi)
ffffffff8000192c:	eb 0c                	jmp    ffffffff8000193a <flanterm_fb_raw_putchar+0x7a>
ffffffff8000192e:	66 90                	xchg   %ax,%ax
    if (ctx->cursor_x >= _ctx->cols && (ctx->cursor_y < _ctx->scroll_bottom_margin - 1 || _ctx->scroll_enabled)) {
ffffffff80001930:	80 7f 0a 00          	cmpb   $0x0,0xa(%rdi)
ffffffff80001934:	75 bd                	jne    ffffffff800018f3 <flanterm_fb_raw_putchar+0x33>

    struct flanterm_fb_char ch;
    ch.c  = c;
    ch.fg = ctx->text_fg;
    ch.bg = ctx->text_bg;
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001936:	48 8d 72 01          	lea    0x1(%rdx),%rsi
    ch.c  = c;
ffffffff8000193a:	8b 87 e0 02 00 00    	mov    0x2e0(%rdi),%eax
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001940:	48 89 b7 e8 02 00 00 	mov    %rsi,0x2e8(%rdi)
    ch.c  = c;
ffffffff80001947:	0f b6 db             	movzbl %bl,%ebx
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff8000194a:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
    ch.c  = c;
ffffffff8000194f:	48 c1 e0 20          	shl    $0x20,%rax
ffffffff80001953:	48 09 c3             	or     %rax,%rbx
    ch.bg = ctx->text_bg;
ffffffff80001956:	8b 87 e4 02 00 00    	mov    0x2e4(%rdi),%eax
    ch.c  = c;
ffffffff8000195c:	48 89 5c 24 10       	mov    %rbx,0x10(%rsp)
    ch.bg = ctx->text_bg;
ffffffff80001961:	89 44 24 18          	mov    %eax,0x18(%rsp)
    push_to_queue(_ctx, &ch, ctx->cursor_x++, ctx->cursor_y);
ffffffff80001965:	e8 66 f7 ff ff       	call   ffffffff800010d0 <push_to_queue>
}
ffffffff8000196a:	48 83 c4 20          	add    $0x20,%rsp
ffffffff8000196e:	5b                   	pop    %rbx
ffffffff8000196f:	5d                   	pop    %rbp
ffffffff80001970:	c3                   	ret
ffffffff80001971:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80001978:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff8000197d:	31 d2                	xor    %edx,%edx
ffffffff8000197f:	eb b9                	jmp    ffffffff8000193a <flanterm_fb_raw_putchar+0x7a>
ffffffff80001981:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80001988:	48 89 4c 24 08       	mov    %rcx,0x8(%rsp)
            flanterm_fb_scroll(_ctx);
ffffffff8000198d:	48 89 3c 24          	mov    %rdi,(%rsp)
ffffffff80001991:	e8 ca f8 ff ff       	call   ffffffff80001260 <flanterm_fb_scroll>
ffffffff80001996:	48 8b 4c 24 08       	mov    0x8(%rsp),%rcx
ffffffff8000199b:	48 8b 3c 24          	mov    (%rsp),%rdi
ffffffff8000199f:	e9 71 ff ff ff       	jmp    ffffffff80001915 <flanterm_fb_raw_putchar+0x55>
ffffffff800019a4:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800019ab:	00 00 00 
ffffffff800019ae:	66 90                	xchg   %ax,%ax

ffffffff800019b0 <flanterm_fb_full_refresh>:

static void flanterm_fb_full_refresh(struct flanterm_context *_ctx) {
ffffffff800019b0:	f3 0f 1e fa          	endbr64
ffffffff800019b4:	41 55                	push   %r13
ffffffff800019b6:	41 54                	push   %r12
ffffffff800019b8:	55                   	push   %rbp
ffffffff800019b9:	53                   	push   %rbx
ffffffff800019ba:	48 89 fb             	mov    %rdi,%rbx
ffffffff800019bd:	48 83 ec 08          	sub    $0x8,%rsp
    struct flanterm_fb_context *ctx = (void *)_ctx;

    uint32_t default_bg = ctx->default_bg;

    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019c1:	4c 8b a7 10 02 00 00 	mov    0x210(%rdi),%r12
    uint32_t default_bg = ctx->default_bg;
ffffffff800019c8:	8b af 8c 02 00 00    	mov    0x28c(%rdi),%ebp
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019ce:	4d 85 e4             	test   %r12,%r12
ffffffff800019d1:	0f 84 7c 00 00 00    	je     ffffffff80001a53 <flanterm_fb_full_refresh+0xa3>
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff800019d7:	48 8b bf 08 02 00 00 	mov    0x208(%rdi),%rdi
ffffffff800019de:	45 31 db             	xor    %r11d,%r11d
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff800019e1:	45 31 d2             	xor    %r10d,%r10d
ffffffff800019e4:	4c 8d 2c bd 00 00 00 	lea    0x0(,%rdi,4),%r13
ffffffff800019eb:	00 
ffffffff800019ec:	0f 1f 40 00          	nopl   0x0(%rax)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff800019f0:	48 85 ff             	test   %rdi,%rdi
ffffffff800019f3:	74 52                	je     ffffffff80001a47 <flanterm_fb_full_refresh+0x97>
            if (ctx->canvas != NULL) {
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff800019f5:	48 8b 8b 00 02 00 00 	mov    0x200(%rbx),%rcx
ffffffff800019fc:	4c 8b 83 f8 01 00 00 	mov    0x1f8(%rbx),%r8
ffffffff80001a03:	31 c0                	xor    %eax,%eax
            if (ctx->canvas != NULL) {
ffffffff80001a05:	48 8b b3 a0 02 00 00 	mov    0x2a0(%rbx),%rsi
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a0c:	48 c1 e9 02          	shr    $0x2,%rcx
ffffffff80001a10:	49 0f af ca          	imul   %r10,%rcx
ffffffff80001a14:	49 8d 14 88          	lea    (%r8,%rcx,4),%rdx
            if (ctx->canvas != NULL) {
ffffffff80001a18:	48 85 f6             	test   %rsi,%rsi
ffffffff80001a1b:	0f 84 a7 00 00 00    	je     ffffffff80001ac8 <flanterm_fb_full_refresh+0x118>
ffffffff80001a21:	4e 8d 0c 1e          	lea    (%rsi,%r11,1),%r9
ffffffff80001a25:	eb 11                	jmp    ffffffff80001a38 <flanterm_fb_full_refresh+0x88>
ffffffff80001a27:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80001a2e:	00 00 
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a30:	48 8d 14 08          	lea    (%rax,%rcx,1),%rdx
ffffffff80001a34:	49 8d 14 90          	lea    (%r8,%rdx,4),%rdx
ffffffff80001a38:	41 8b 34 81          	mov    (%r9,%rax,4),%esi
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001a3c:	48 83 c0 01          	add    $0x1,%rax
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001a40:	89 32                	mov    %esi,(%rdx)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001a42:	48 39 c7             	cmp    %rax,%rdi
ffffffff80001a45:	75 e9                	jne    ffffffff80001a30 <flanterm_fb_full_refresh+0x80>
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff80001a47:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001a4b:	4d 01 eb             	add    %r13,%r11
ffffffff80001a4e:	4d 39 e2             	cmp    %r12,%r10
ffffffff80001a51:	75 9d                	jne    ffffffff800019f0 <flanterm_fb_full_refresh+0x40>
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;
            }
        }
    }

    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a53:	48 8b 8b e8 00 00 00 	mov    0xe8(%rbx),%rcx
ffffffff80001a5a:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80001a61:	31 ed                	xor    %ebp,%ebp
ffffffff80001a63:	48 0f af c1          	imul   %rcx,%rax
ffffffff80001a67:	48 85 c0             	test   %rax,%rax
ffffffff80001a6a:	74 43                	je     ffffffff80001aaf <flanterm_fb_full_refresh+0xff>
ffffffff80001a6c:	0f 1f 40 00          	nopl   0x0(%rax)
        size_t x = i % _ctx->cols;
ffffffff80001a70:	48 89 e8             	mov    %rbp,%rax
ffffffff80001a73:	31 d2                	xor    %edx,%edx
        size_t y = i / _ctx->cols;

        ctx->plot_char(_ctx, &ctx->grid[i], x, y);
ffffffff80001a75:	48 8d 74 6d 00       	lea    0x0(%rbp,%rbp,2),%rsi
ffffffff80001a7a:	48 89 df             	mov    %rbx,%rdi
ffffffff80001a7d:	48 f7 f1             	div    %rcx
    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a80:	48 83 c5 01          	add    $0x1,%rbp
ffffffff80001a84:	48 89 c1             	mov    %rax,%rcx
        ctx->plot_char(_ctx, &ctx->grid[i], x, y);
ffffffff80001a87:	48 8b 83 c0 02 00 00 	mov    0x2c0(%rbx),%rax
ffffffff80001a8e:	48 8d 34 b0          	lea    (%rax,%rsi,4),%rsi
ffffffff80001a92:	ff 93 b0 01 00 00    	call   *0x1b0(%rbx)
    for (size_t i = 0; i < (size_t)_ctx->rows * _ctx->cols; i++) {
ffffffff80001a98:	48 8b 8b e8 00 00 00 	mov    0xe8(%rbx),%rcx
ffffffff80001a9f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80001aa6:	48 0f af c1          	imul   %rcx,%rax
ffffffff80001aaa:	48 39 c5             	cmp    %rax,%rbp
ffffffff80001aad:	72 c1                	jb     ffffffff80001a70 <flanterm_fb_full_refresh+0xc0>
    }

    if (_ctx->cursor_enabled) {
ffffffff80001aaf:	80 7b 09 00          	cmpb   $0x0,0x9(%rbx)
ffffffff80001ab3:	75 33                	jne    ffffffff80001ae8 <flanterm_fb_full_refresh+0x138>
        draw_cursor(_ctx);
    }
}
ffffffff80001ab5:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80001ab9:	5b                   	pop    %rbx
ffffffff80001aba:	5d                   	pop    %rbp
ffffffff80001abb:	41 5c                	pop    %r12
ffffffff80001abd:	41 5d                	pop    %r13
ffffffff80001abf:	c3                   	ret
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = ctx->canvas[y * ctx->width + x];
ffffffff80001ac0:	48 8d 14 08          	lea    (%rax,%rcx,1),%rdx
ffffffff80001ac4:	49 8d 14 90          	lea    (%r8,%rdx,4),%rdx
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001ac8:	48 83 c0 01          	add    $0x1,%rax
                ctx->framebuffer[y * (ctx->pitch / sizeof(uint32_t)) + x] = default_bg;
ffffffff80001acc:	89 2a                	mov    %ebp,(%rdx)
        for (size_t x = 0; x < ctx->width; x++) {
ffffffff80001ace:	48 39 f8             	cmp    %rdi,%rax
ffffffff80001ad1:	75 ed                	jne    ffffffff80001ac0 <flanterm_fb_full_refresh+0x110>
    for (size_t y = 0; y < ctx->height; y++) {
ffffffff80001ad3:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001ad7:	4d 01 eb             	add    %r13,%r11
ffffffff80001ada:	4d 39 e2             	cmp    %r12,%r10
ffffffff80001add:	0f 85 0d ff ff ff    	jne    ffffffff800019f0 <flanterm_fb_full_refresh+0x40>
ffffffff80001ae3:	e9 6b ff ff ff       	jmp    ffffffff80001a53 <flanterm_fb_full_refresh+0xa3>
}
ffffffff80001ae8:	48 83 c4 08          	add    $0x8,%rsp
        draw_cursor(_ctx);
ffffffff80001aec:	48 89 df             	mov    %rbx,%rdi
}
ffffffff80001aef:	5b                   	pop    %rbx
ffffffff80001af0:	5d                   	pop    %rbp
ffffffff80001af1:	41 5c                	pop    %r12
ffffffff80001af3:	41 5d                	pop    %r13
        draw_cursor(_ctx);
ffffffff80001af5:	e9 66 fb ff ff       	jmp    ffffffff80001660 <draw_cursor>
ffffffff80001afa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80001b00 <flanterm_fb_deinit>:

static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {
ffffffff80001b00:	f3 0f 1e fa          	endbr64
    struct flanterm_fb_context *ctx = (void *)_ctx;

    if (_free == NULL) {
ffffffff80001b04:	48 85 f6             	test   %rsi,%rsi
ffffffff80001b07:	0f 84 8b 00 00 00    	je     ffffffff80001b98 <flanterm_fb_deinit+0x98>
static void flanterm_fb_deinit(struct flanterm_context *_ctx, void (*_free)(void *, size_t)) {
ffffffff80001b0d:	55                   	push   %rbp
ffffffff80001b0e:	48 89 f5             	mov    %rsi,%rbp
ffffffff80001b11:	53                   	push   %rbx
ffffffff80001b12:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001b15:	48 83 ec 08          	sub    $0x8,%rsp
        }
#endif
        return;
    }

    _free(ctx->font_bits, ctx->font_bits_size);
ffffffff80001b19:	48 8b b7 28 02 00 00 	mov    0x228(%rdi),%rsi
ffffffff80001b20:	48 8b bf 30 02 00 00 	mov    0x230(%rdi),%rdi
ffffffff80001b27:	ff d5                	call   *%rbp
    _free(ctx->font_bool, ctx->font_bool_size);
ffffffff80001b29:	48 8b b3 38 02 00 00 	mov    0x238(%rbx),%rsi
ffffffff80001b30:	48 8b bb 40 02 00 00 	mov    0x240(%rbx),%rdi
ffffffff80001b37:	ff d5                	call   *%rbp
    _free(ctx->grid, ctx->grid_size);
ffffffff80001b39:	48 8b b3 a8 02 00 00 	mov    0x2a8(%rbx),%rsi
ffffffff80001b40:	48 8b bb c0 02 00 00 	mov    0x2c0(%rbx),%rdi
ffffffff80001b47:	ff d5                	call   *%rbp
    _free(ctx->queue, ctx->queue_size);
ffffffff80001b49:	48 8b b3 b0 02 00 00 	mov    0x2b0(%rbx),%rsi
ffffffff80001b50:	48 8b bb c8 02 00 00 	mov    0x2c8(%rbx),%rdi
ffffffff80001b57:	ff d5                	call   *%rbp
    _free(ctx->map, ctx->map_size);
ffffffff80001b59:	48 8b bb d8 02 00 00 	mov    0x2d8(%rbx),%rdi
ffffffff80001b60:	48 8b b3 b8 02 00 00 	mov    0x2b8(%rbx),%rsi
ffffffff80001b67:	ff d5                	call   *%rbp

    if (ctx->canvas != NULL) {
ffffffff80001b69:	48 8b bb a0 02 00 00 	mov    0x2a0(%rbx),%rdi
ffffffff80001b70:	48 85 ff             	test   %rdi,%rdi
ffffffff80001b73:	74 09                	je     ffffffff80001b7e <flanterm_fb_deinit+0x7e>
        _free(ctx->canvas, ctx->canvas_size);
ffffffff80001b75:	48 8b b3 98 02 00 00 	mov    0x298(%rbx),%rsi
ffffffff80001b7c:	ff d5                	call   *%rbp
    }

    _free(ctx, sizeof(struct flanterm_fb_context));
}
ffffffff80001b7e:	48 83 c4 08          	add    $0x8,%rsp
    _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80001b82:	48 89 df             	mov    %rbx,%rdi
ffffffff80001b85:	48 89 e8             	mov    %rbp,%rax
ffffffff80001b88:	be 20 03 00 00       	mov    $0x320,%esi
}
ffffffff80001b8d:	5b                   	pop    %rbx
ffffffff80001b8e:	5d                   	pop    %rbp
    _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80001b8f:	ff e0                	jmp    *%rax
ffffffff80001b91:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        if (bump_allocated_instance == true) {
ffffffff80001b98:	80 3d 62 95 00 00 00 	cmpb   $0x0,0x9562(%rip)        # ffffffff8000b101 <bump_allocated_instance>
ffffffff80001b9f:	74 17                	je     ffffffff80001bb8 <flanterm_fb_deinit+0xb8>
            bump_alloc_ptr = 0;
ffffffff80001ba1:	48 c7 05 5c 95 00 00 	movq   $0x0,0x955c(%rip)        # ffffffff8000b108 <bump_alloc_ptr>
ffffffff80001ba8:	00 00 00 00 
            bump_allocated_instance = false;
ffffffff80001bac:	c6 05 4e 95 00 00 00 	movb   $0x0,0x954e(%rip)        # ffffffff8000b101 <bump_allocated_instance>
ffffffff80001bb3:	c3                   	ret
ffffffff80001bb4:	0f 1f 40 00          	nopl   0x0(%rax)
ffffffff80001bb8:	c3                   	ret
ffffffff80001bb9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80001bc0 <plot_char_scaled_canvas>:
static void plot_char_scaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001bc0:	f3 0f 1e fa          	endbr64
ffffffff80001bc4:	41 57                	push   %r15
ffffffff80001bc6:	41 56                	push   %r14
ffffffff80001bc8:	41 55                	push   %r13
ffffffff80001bca:	41 54                	push   %r12
ffffffff80001bcc:	55                   	push   %rbp
ffffffff80001bcd:	53                   	push   %rbx
ffffffff80001bce:	48 89 fb             	mov    %rdi,%rbx
ffffffff80001bd1:	48 83 ec 48          	sub    $0x48,%rsp
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001bd5:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001bdc:	0f 83 9b 01 00 00    	jae    ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
ffffffff80001be2:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001be9:	0f 83 8e 01 00 00    	jae    ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
ffffffff80001bef:	48 89 f7             	mov    %rsi,%rdi
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001bf2:	48 8b b3 d0 01 00 00 	mov    0x1d0(%rbx),%rsi
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001bf9:	48 0f af 93 c8 01 00 	imul   0x1c8(%rbx),%rdx
ffffffff80001c00:	00 
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c01:	48 8b ab b8 01 00 00 	mov    0x1b8(%rbx),%rbp
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001c08:	48 03 93 e8 01 00 00 	add    0x1e8(%rbx),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001c0f:	48 89 f0             	mov    %rsi,%rax
ffffffff80001c12:	48 89 74 24 10       	mov    %rsi,0x10(%rsp)
ffffffff80001c17:	48 0f af c1          	imul   %rcx,%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c1b:	48 8b 8b 40 02 00 00 	mov    0x240(%rbx),%rcx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001c22:	48 03 83 f0 01 00 00 	add    0x1f0(%rbx),%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001c29:	48 89 4c 24 18       	mov    %rcx,0x18(%rsp)
ffffffff80001c2e:	8b 0f                	mov    (%rdi),%ecx
ffffffff80001c30:	48 0f af 8b c0 01 00 	imul   0x1c0(%rbx),%rcx
ffffffff80001c37:	00 
ffffffff80001c38:	48 89 4c 24 20       	mov    %rcx,0x20(%rsp)
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c3d:	48 85 f6             	test   %rsi,%rsi
ffffffff80001c40:	0f 84 37 01 00 00    	je     ffffffff80001d7d <plot_char_scaled_canvas+0x1bd>
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001c46:	48 8b b3 e0 01 00 00 	mov    0x1e0(%rbx),%rsi
        uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;
ffffffff80001c4d:	48 8b 8b 08 02 00 00 	mov    0x208(%rbx),%rcx
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c54:	45 31 c9             	xor    %r9d,%r9d
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001c57:	4c 8b 93 00 02 00 00 	mov    0x200(%rbx),%r10
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001c5e:	48 89 74 24 28       	mov    %rsi,0x28(%rsp)
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001c63:	48 8b b3 f8 01 00 00 	mov    0x1f8(%rbx),%rsi
ffffffff80001c6a:	49 c1 ea 02          	shr    $0x2,%r10
ffffffff80001c6e:	48 89 74 24 40       	mov    %rsi,0x40(%rsp)
ffffffff80001c73:	48 8d 34 8d 00 00 00 	lea    0x0(,%rcx,4),%rsi
ffffffff80001c7a:	00 
ffffffff80001c7b:	48 0f af c8          	imul   %rax,%rcx
ffffffff80001c7f:	48 89 74 24 38       	mov    %rsi,0x38(%rsp)
ffffffff80001c84:	48 8b b3 a0 02 00 00 	mov    0x2a0(%rbx),%rsi
ffffffff80001c8b:	49 0f af c2          	imul   %r10,%rax
ffffffff80001c8f:	4c 89 54 24 30       	mov    %r10,0x30(%rsp)
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001c94:	49 89 da             	mov    %rbx,%r10
ffffffff80001c97:	48 01 d1             	add    %rdx,%rcx
ffffffff80001c9a:	4c 8d 34 8e          	lea    (%rsi,%rcx,4),%r14
ffffffff80001c9e:	4c 8d 3c 10          	lea    (%rax,%rdx,1),%r15
ffffffff80001ca2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80001ca8:	4c 89 c8             	mov    %r9,%rax
ffffffff80001cab:	31 d2                	xor    %edx,%edx
ffffffff80001cad:	48 f7 74 24 28       	divq   0x28(%rsp)
        bool *glyph_pointer = glyph + (fy * ctx->font_width);
ffffffff80001cb2:	0f b6 c8             	movzbl %al,%ecx
ffffffff80001cb5:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
ffffffff80001cba:	48 01 c1             	add    %rax,%rcx
ffffffff80001cbd:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80001cc2:	48 0f af cd          	imul   %rbp,%rcx
ffffffff80001cc6:	48 01 c1             	add    %rax,%rcx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001cc9:	48 85 ed             	test   %rbp,%rbp
ffffffff80001ccc:	0f 84 8c 00 00 00    	je     ffffffff80001d5e <plot_char_scaled_canvas+0x19e>
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001cd2:	4d 8b a2 d8 01 00 00 	mov    0x1d8(%r10),%r12
ffffffff80001cd9:	48 8b 44 24 40       	mov    0x40(%rsp),%rax
ffffffff80001cde:	4c 8d 2c 29          	lea    (%rcx,%rbp,1),%r13
ffffffff80001ce2:	4c 89 ce             	mov    %r9,%rsi
ffffffff80001ce5:	48 89 6c 24 08       	mov    %rbp,0x8(%rsp)
ffffffff80001cea:	4e 8d 1c a5 00 00 00 	lea    0x0(,%r12,4),%r11
ffffffff80001cf1:	00 
ffffffff80001cf2:	4a 8d 1c b8          	lea    (%rax,%r15,4),%rbx
ffffffff80001cf6:	4f 8d 04 33          	lea    (%r11,%r14,1),%r8
ffffffff80001cfa:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff80001d00:	4d 85 e4             	test   %r12,%r12
ffffffff80001d03:	74 42                	je     ffffffff80001d47 <plot_char_scaled_canvas+0x187>
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d05:	48 89 0c 24          	mov    %rcx,(%rsp)
ffffffff80001d09:	4c 89 c2             	mov    %r8,%rdx
ffffffff80001d0c:	0f b6 29             	movzbl (%rcx),%ebp
ffffffff80001d0f:	49 89 d9             	mov    %rbx,%r9
ffffffff80001d12:	4c 29 da             	sub    %r11,%rdx
ffffffff80001d15:	0f 1f 00             	nopl   (%rax)
                uint32_t bg = c->bg == 0xffffffff ? canvas_line[gx] : c->bg;
ffffffff80001d18:	8b 47 08             	mov    0x8(%rdi),%eax
ffffffff80001d1b:	83 f8 ff             	cmp    $0xffffffff,%eax
ffffffff80001d1e:	75 02                	jne    ffffffff80001d22 <plot_char_scaled_canvas+0x162>
ffffffff80001d20:	8b 02                	mov    (%rdx),%eax
                uint32_t fg = c->fg == 0xffffffff ? canvas_line[gx] : c->fg;
ffffffff80001d22:	8b 4f 04             	mov    0x4(%rdi),%ecx
ffffffff80001d25:	83 f9 ff             	cmp    $0xffffffff,%ecx
ffffffff80001d28:	75 02                	jne    ffffffff80001d2c <plot_char_scaled_canvas+0x16c>
ffffffff80001d2a:	8b 0a                	mov    (%rdx),%ecx
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d2c:	40 84 ed             	test   %bpl,%bpl
ffffffff80001d2f:	0f 45 c1             	cmovne %ecx,%eax
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001d32:	48 83 c2 04          	add    $0x4,%rdx
ffffffff80001d36:	49 83 c1 04          	add    $0x4,%r9
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80001d3a:	41 89 41 fc          	mov    %eax,-0x4(%r9)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80001d3e:	49 39 d0             	cmp    %rdx,%r8
ffffffff80001d41:	75 d5                	jne    ffffffff80001d18 <plot_char_scaled_canvas+0x158>
ffffffff80001d43:	48 8b 0c 24          	mov    (%rsp),%rcx
            glyph_pointer++;
ffffffff80001d47:	48 83 c1 01          	add    $0x1,%rcx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001d4b:	4d 01 d8             	add    %r11,%r8
ffffffff80001d4e:	4c 01 db             	add    %r11,%rbx
ffffffff80001d51:	4c 39 e9             	cmp    %r13,%rcx
ffffffff80001d54:	75 aa                	jne    ffffffff80001d00 <plot_char_scaled_canvas+0x140>
ffffffff80001d56:	48 8b 6c 24 08       	mov    0x8(%rsp),%rbp
ffffffff80001d5b:	49 89 f1             	mov    %rsi,%r9
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001d5e:	48 8b 44 24 38       	mov    0x38(%rsp),%rax
ffffffff80001d63:	49 83 c1 01          	add    $0x1,%r9
ffffffff80001d67:	49 01 c6             	add    %rax,%r14
ffffffff80001d6a:	48 8b 44 24 30       	mov    0x30(%rsp),%rax
ffffffff80001d6f:	49 01 c7             	add    %rax,%r15
ffffffff80001d72:	4c 39 4c 24 10       	cmp    %r9,0x10(%rsp)
ffffffff80001d77:	0f 85 2b ff ff ff    	jne    ffffffff80001ca8 <plot_char_scaled_canvas+0xe8>
}
ffffffff80001d7d:	48 83 c4 48          	add    $0x48,%rsp
ffffffff80001d81:	5b                   	pop    %rbx
ffffffff80001d82:	5d                   	pop    %rbp
ffffffff80001d83:	41 5c                	pop    %r12
ffffffff80001d85:	41 5d                	pop    %r13
ffffffff80001d87:	41 5e                	pop    %r14
ffffffff80001d89:	41 5f                	pop    %r15
ffffffff80001d8b:	c3                   	ret
ffffffff80001d8c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80001d90 <plot_char_unscaled_canvas>:
static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001d90:	f3 0f 1e fa          	endbr64
ffffffff80001d94:	48 89 f8             	mov    %rdi,%rax
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001d97:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001d9e:	0f 83 0c 01 00 00    	jae    ffffffff80001eb0 <plot_char_unscaled_canvas+0x120>
ffffffff80001da4:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001dab:	0f 83 ff 00 00 00    	jae    ffffffff80001eb0 <plot_char_unscaled_canvas+0x120>
static void plot_char_unscaled_canvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001db1:	41 56                	push   %r14
ffffffff80001db3:	48 89 f7             	mov    %rsi,%rdi
ffffffff80001db6:	41 55                	push   %r13
ffffffff80001db8:	41 54                	push   %r12
ffffffff80001dba:	55                   	push   %rbp
ffffffff80001dbb:	53                   	push   %rbx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001dbc:	4c 8b a0 d0 01 00 00 	mov    0x1d0(%rax),%r12
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001dc3:	8b 1e                	mov    (%rsi),%ebx
ffffffff80001dc5:	4c 8b 88 b8 01 00 00 	mov    0x1b8(%rax),%r9
ffffffff80001dcc:	48 8b b0 c0 01 00 00 	mov    0x1c0(%rax),%rsi
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001dd3:	48 0f af 90 c8 01 00 	imul   0x1c8(%rax),%rdx
ffffffff80001dda:	00 
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001ddb:	49 0f af cc          	imul   %r12,%rcx
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001ddf:	4c 8b 80 40 02 00 00 	mov    0x240(%rax),%r8
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001de6:	48 03 90 e8 01 00 00 	add    0x1e8(%rax),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001ded:	49 0f af f1          	imul   %r9,%rsi
ffffffff80001df1:	48 03 88 f0 01 00 00 	add    0x1f0(%rax),%rcx
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001df8:	4d 85 e4             	test   %r12,%r12
ffffffff80001dfb:	0f 84 a1 00 00 00    	je     ffffffff80001ea2 <plot_char_unscaled_canvas+0x112>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e01:	48 8b a8 00 02 00 00 	mov    0x200(%rax),%rbp
        uint32_t *canvas_line = ctx->canvas + x + (y + gy) * ctx->width;
ffffffff80001e08:	4c 8b 90 08 02 00 00 	mov    0x208(%rax),%r10
ffffffff80001e0f:	49 89 cb             	mov    %rcx,%r11
ffffffff80001e12:	48 0f af f3          	imul   %rbx,%rsi
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e16:	4c 8b b0 f8 01 00 00 	mov    0x1f8(%rax),%r14
ffffffff80001e1d:	48 8b 80 a0 02 00 00 	mov    0x2a0(%rax),%rax
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001e24:	31 db                	xor    %ebx,%ebx
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001e26:	48 c1 ed 02          	shr    $0x2,%rbp
ffffffff80001e2a:	49 0f af ca          	imul   %r10,%rcx
ffffffff80001e2e:	4e 8d 2c 95 00 00 00 	lea    0x0(,%r10,4),%r13
ffffffff80001e35:	00 
ffffffff80001e36:	4c 0f af dd          	imul   %rbp,%r11
ffffffff80001e3a:	49 01 f0             	add    %rsi,%r8
ffffffff80001e3d:	49 01 d3             	add    %rdx,%r11
ffffffff80001e40:	48 01 ca             	add    %rcx,%rdx
ffffffff80001e43:	4c 8d 14 90          	lea    (%rax,%rdx,4),%r10
ffffffff80001e47:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80001e4e:	00 00 
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e50:	4d 85 c9             	test   %r9,%r9
ffffffff80001e53:	74 3b                	je     ffffffff80001e90 <plot_char_unscaled_canvas+0x100>
ffffffff80001e55:	4b 8d 34 9e          	lea    (%r14,%r11,4),%rsi
ffffffff80001e59:	31 d2                	xor    %edx,%edx
ffffffff80001e5b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            uint32_t bg = c->bg == 0xffffffff ? canvas_line[fx] : c->bg;
ffffffff80001e60:	8b 47 08             	mov    0x8(%rdi),%eax
ffffffff80001e63:	83 f8 ff             	cmp    $0xffffffff,%eax
ffffffff80001e66:	75 04                	jne    ffffffff80001e6c <plot_char_unscaled_canvas+0xdc>
ffffffff80001e68:	41 8b 04 92          	mov    (%r10,%rdx,4),%eax
            uint32_t fg = c->fg == 0xffffffff ? canvas_line[fx] : c->fg;
ffffffff80001e6c:	8b 4f 04             	mov    0x4(%rdi),%ecx
ffffffff80001e6f:	83 f9 ff             	cmp    $0xffffffff,%ecx
ffffffff80001e72:	75 04                	jne    ffffffff80001e78 <plot_char_unscaled_canvas+0xe8>
ffffffff80001e74:	41 8b 0c 92          	mov    (%r10,%rdx,4),%ecx
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001e78:	41 80 3c 10 00       	cmpb   $0x0,(%r8,%rdx,1)
ffffffff80001e7d:	0f 45 c1             	cmovne %ecx,%eax
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e80:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001e84:	48 83 c6 04          	add    $0x4,%rsi
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001e88:	89 46 fc             	mov    %eax,-0x4(%rsi)
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001e8b:	49 39 d1             	cmp    %rdx,%r9
ffffffff80001e8e:	75 d0                	jne    ffffffff80001e60 <plot_char_unscaled_canvas+0xd0>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001e90:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80001e94:	49 01 eb             	add    %rbp,%r11
ffffffff80001e97:	4d 01 c8             	add    %r9,%r8
ffffffff80001e9a:	4d 01 ea             	add    %r13,%r10
ffffffff80001e9d:	49 39 dc             	cmp    %rbx,%r12
ffffffff80001ea0:	75 ae                	jne    ffffffff80001e50 <plot_char_unscaled_canvas+0xc0>
}
ffffffff80001ea2:	5b                   	pop    %rbx
ffffffff80001ea3:	5d                   	pop    %rbp
ffffffff80001ea4:	41 5c                	pop    %r12
ffffffff80001ea6:	41 5d                	pop    %r13
ffffffff80001ea8:	41 5e                	pop    %r14
ffffffff80001eaa:	c3                   	ret
ffffffff80001eab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff80001eb0:	c3                   	ret
ffffffff80001eb1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001eb8:	00 00 00 
ffffffff80001ebb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001ec0 <plot_char_unscaled_uncanvas>:
static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ec0:	f3 0f 1e fa          	endbr64
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001ec4:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001ecb:	0f 83 ff 00 00 00    	jae    ffffffff80001fd0 <plot_char_unscaled_uncanvas+0x110>
ffffffff80001ed1:	48 89 f8             	mov    %rdi,%rax
ffffffff80001ed4:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80001edb:	0f 83 ef 00 00 00    	jae    ffffffff80001fd0 <plot_char_unscaled_uncanvas+0x110>
static void plot_char_unscaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ee1:	41 57                	push   %r15
ffffffff80001ee3:	41 56                	push   %r14
ffffffff80001ee5:	41 55                	push   %r13
ffffffff80001ee7:	41 54                	push   %r12
ffffffff80001ee9:	55                   	push   %rbp
ffffffff80001eea:	53                   	push   %rbx
ffffffff80001eeb:	44 8b 46 08          	mov    0x8(%rsi),%r8d
    uint32_t default_bg = ctx->default_bg;
ffffffff80001eef:	44 8b 88 8c 02 00 00 	mov    0x28c(%rax),%r9d
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80001ef6:	8b 7e 04             	mov    0x4(%rsi),%edi
ffffffff80001ef9:	41 83 f8 ff          	cmp    $0xffffffff,%r8d
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001efd:	4c 8b a0 d0 01 00 00 	mov    0x1d0(%rax),%r12
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f04:	44 8b 3e             	mov    (%rsi),%r15d
ffffffff80001f07:	48 8b 98 b8 01 00 00 	mov    0x1b8(%rax),%rbx
ffffffff80001f0e:	4c 8b 90 c0 01 00 00 	mov    0x1c0(%rax),%r10
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80001f15:	45 0f 44 c1          	cmove  %r9d,%r8d
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff80001f19:	83 ff ff             	cmp    $0xffffffff,%edi
ffffffff80001f1c:	41 0f 44 f9          	cmove  %r9d,%edi
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f20:	4c 8b 88 40 02 00 00 	mov    0x240(%rax),%r9
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80001f27:	48 0f af 90 c8 01 00 	imul   0x1c8(%rax),%rdx
ffffffff80001f2e:	00 
ffffffff80001f2f:	48 03 90 e8 01 00 00 	add    0x1e8(%rax),%rdx
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80001f36:	49 0f af cc          	imul   %r12,%rcx
ffffffff80001f3a:	48 03 88 f0 01 00 00 	add    0x1f0(%rax),%rcx
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80001f41:	4c 0f af d3          	imul   %rbx,%r10
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001f45:	4d 85 e4             	test   %r12,%r12
ffffffff80001f48:	74 7a                	je     ffffffff80001fc4 <plot_char_unscaled_uncanvas+0x104>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80001f4a:	48 8b a8 00 02 00 00 	mov    0x200(%rax),%rbp
ffffffff80001f51:	4d 0f af d7          	imul   %r15,%r10
ffffffff80001f55:	4c 8b b0 f8 01 00 00 	mov    0x1f8(%rax),%r14
ffffffff80001f5c:	48 8d 04 1a          	lea    (%rdx,%rbx,1),%rax
ffffffff80001f60:	48 c1 ed 02          	shr    $0x2,%rbp
ffffffff80001f64:	48 0f af cd          	imul   %rbp,%rcx
ffffffff80001f68:	4d 01 d1             	add    %r10,%r9
ffffffff80001f6b:	4c 8d 2c ad 00 00 00 	lea    0x0(,%rbp,4),%r13
ffffffff80001f72:	00 
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001f73:	45 31 d2             	xor    %r10d,%r10d
ffffffff80001f76:	48 01 c8             	add    %rcx,%rax
ffffffff80001f79:	4c 8d 1c 0a          	lea    (%rdx,%rcx,1),%r11
ffffffff80001f7d:	49 8d 34 86          	lea    (%r14,%rax,4),%rsi
ffffffff80001f81:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        bool *glyph_pointer = glyph + (gy * ctx->font_width);
ffffffff80001f88:	4c 89 ca             	mov    %r9,%rdx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001f8b:	48 85 db             	test   %rbx,%rbx
ffffffff80001f8e:	74 22                	je     ffffffff80001fb2 <plot_char_unscaled_uncanvas+0xf2>
ffffffff80001f90:	4b 8d 04 9e          	lea    (%r14,%r11,4),%rax
ffffffff80001f94:	0f 1f 40 00          	nopl   0x0(%rax)
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001f98:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80001f9c:	89 f9                	mov    %edi,%ecx
ffffffff80001f9e:	80 7a ff 00          	cmpb   $0x0,-0x1(%rdx)
ffffffff80001fa2:	41 0f 44 c8          	cmove  %r8d,%ecx
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001fa6:	48 83 c0 04          	add    $0x4,%rax
            fb_line[fx] = *(glyph_pointer++) ? fg : bg;
ffffffff80001faa:	89 48 fc             	mov    %ecx,-0x4(%rax)
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80001fad:	48 39 f0             	cmp    %rsi,%rax
ffffffff80001fb0:	75 e6                	jne    ffffffff80001f98 <plot_char_unscaled_uncanvas+0xd8>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80001fb2:	49 83 c2 01          	add    $0x1,%r10
ffffffff80001fb6:	49 01 eb             	add    %rbp,%r11
ffffffff80001fb9:	4c 01 ee             	add    %r13,%rsi
ffffffff80001fbc:	49 01 d9             	add    %rbx,%r9
ffffffff80001fbf:	4d 39 d4             	cmp    %r10,%r12
ffffffff80001fc2:	75 c4                	jne    ffffffff80001f88 <plot_char_unscaled_uncanvas+0xc8>
}
ffffffff80001fc4:	5b                   	pop    %rbx
ffffffff80001fc5:	5d                   	pop    %rbp
ffffffff80001fc6:	41 5c                	pop    %r12
ffffffff80001fc8:	41 5d                	pop    %r13
ffffffff80001fca:	41 5e                	pop    %r14
ffffffff80001fcc:	41 5f                	pop    %r15
ffffffff80001fce:	c3                   	ret
ffffffff80001fcf:	90                   	nop
ffffffff80001fd0:	c3                   	ret
ffffffff80001fd1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80001fd8:	00 00 00 
ffffffff80001fdb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80001fe0 <plot_char_scaled_uncanvas>:
static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001fe0:	f3 0f 1e fa          	endbr64
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80001fe4:	48 3b 97 e8 00 00 00 	cmp    0xe8(%rdi),%rdx
ffffffff80001feb:	0f 83 69 01 00 00    	jae    ffffffff8000215a <plot_char_scaled_uncanvas+0x17a>
static void plot_char_scaled_uncanvas(struct flanterm_context *_ctx, struct flanterm_fb_char *c, size_t x, size_t y) {
ffffffff80001ff1:	41 57                	push   %r15
ffffffff80001ff3:	41 56                	push   %r14
ffffffff80001ff5:	41 55                	push   %r13
ffffffff80001ff7:	41 54                	push   %r12
ffffffff80001ff9:	55                   	push   %rbp
ffffffff80001ffa:	48 89 fd             	mov    %rdi,%rbp
ffffffff80001ffd:	53                   	push   %rbx
ffffffff80001ffe:	48 83 ec 20          	sub    $0x20,%rsp
    if (x >= _ctx->cols || y >= _ctx->rows) {
ffffffff80002002:	48 3b 8f e0 00 00 00 	cmp    0xe0(%rdi),%rcx
ffffffff80002009:	0f 83 3c 01 00 00    	jae    ffffffff8000214b <plot_char_scaled_uncanvas+0x16b>
ffffffff8000200f:	44 8b 7e 08          	mov    0x8(%rsi),%r15d
    uint32_t default_bg = ctx->default_bg;
ffffffff80002013:	8b 87 8c 02 00 00    	mov    0x28c(%rdi),%eax
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80002019:	44 8b 76 04          	mov    0x4(%rsi),%r14d
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000201d:	48 8b 9d 40 02 00 00 	mov    0x240(%rbp),%rbx
    uint32_t bg = c->bg == 0xffffffff ? default_bg : c->bg;
ffffffff80002024:	41 83 ff ff          	cmp    $0xffffffff,%r15d
ffffffff80002028:	44 0f 44 f8          	cmove  %eax,%r15d
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff8000202c:	41 83 fe ff          	cmp    $0xffffffff,%r14d
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80002030:	48 89 5c 24 08       	mov    %rbx,0x8(%rsp)
ffffffff80002035:	48 8b 9d b8 01 00 00 	mov    0x1b8(%rbp),%rbx
    uint32_t fg = c->fg == 0xffffffff ? default_bg : c->fg;
ffffffff8000203c:	44 0f 44 f0          	cmove  %eax,%r14d
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff80002040:	48 8b 87 c8 01 00 00 	mov    0x1c8(%rdi),%rax
ffffffff80002047:	48 0f af c2          	imul   %rdx,%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000204b:	8b 16                	mov    (%rsi),%edx
    x = ctx->offset_x + x * ctx->glyph_width;
ffffffff8000204d:	48 03 87 e8 01 00 00 	add    0x1e8(%rdi),%rax
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff80002054:	48 0f af 95 c0 01 00 	imul   0x1c0(%rbp),%rdx
ffffffff8000205b:	00 
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff8000205c:	48 8b bf d0 01 00 00 	mov    0x1d0(%rdi),%rdi
ffffffff80002063:	49 89 fb             	mov    %rdi,%r11
ffffffff80002066:	48 89 3c 24          	mov    %rdi,(%rsp)
ffffffff8000206a:	4c 0f af d9          	imul   %rcx,%r11
    bool *glyph = &ctx->font_bool[c->c * ctx->font_height * ctx->font_width];
ffffffff8000206e:	48 89 54 24 10       	mov    %rdx,0x10(%rsp)
    y = ctx->offset_y + y * ctx->glyph_height;
ffffffff80002073:	4c 03 9d f0 01 00 00 	add    0x1f0(%rbp),%r11
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff8000207a:	48 85 ff             	test   %rdi,%rdi
ffffffff8000207d:	0f 84 c8 00 00 00    	je     ffffffff8000214b <plot_char_scaled_uncanvas+0x16b>
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff80002083:	4c 8b ad 00 02 00 00 	mov    0x200(%rbp),%r13
ffffffff8000208a:	48 8b bd f8 01 00 00 	mov    0x1f8(%rbp),%rdi
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff80002091:	45 31 d2             	xor    %r10d,%r10d
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff80002094:	4c 8b a5 e0 01 00 00 	mov    0x1e0(%rbp),%r12
        volatile uint32_t *fb_line = ctx->framebuffer + x + (y + gy) * (ctx->pitch / 4);
ffffffff8000209b:	49 c1 ed 02          	shr    $0x2,%r13
ffffffff8000209f:	48 89 7c 24 18       	mov    %rdi,0x18(%rsp)
ffffffff800020a4:	4d 0f af dd          	imul   %r13,%r11
ffffffff800020a8:	49 01 c3             	add    %rax,%r11
ffffffff800020ab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        uint8_t fy = gy / ctx->font_scale_y;
ffffffff800020b0:	4c 89 d0             	mov    %r10,%rax
ffffffff800020b3:	31 d2                	xor    %edx,%edx
ffffffff800020b5:	49 f7 f4             	div    %r12
        bool *glyph_pointer = glyph + (fy * ctx->font_width);
ffffffff800020b8:	0f b6 f0             	movzbl %al,%esi
ffffffff800020bb:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800020c0:	48 01 c6             	add    %rax,%rsi
ffffffff800020c3:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
ffffffff800020c8:	48 0f af f3          	imul   %rbx,%rsi
ffffffff800020cc:	48 01 c6             	add    %rax,%rsi
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff800020cf:	48 85 db             	test   %rbx,%rbx
ffffffff800020d2:	74 66                	je     ffffffff8000213a <plot_char_scaled_uncanvas+0x15a>
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff800020d4:	4c 8b 85 d8 01 00 00 	mov    0x1d8(%rbp),%r8
ffffffff800020db:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800020e0:	4c 8d 0c 1e          	lea    (%rsi,%rbx,1),%r9
ffffffff800020e4:	4b 8d 04 18          	lea    (%r8,%r11,1),%rax
ffffffff800020e8:	4a 8d 3c 85 00 00 00 	lea    0x0(,%r8,4),%rdi
ffffffff800020ef:	00 
ffffffff800020f0:	48 8d 0c 81          	lea    (%rcx,%rax,4),%rcx
ffffffff800020f4:	0f 1f 40 00          	nopl   0x0(%rax)
ffffffff800020f8:	4d 85 c0             	test   %r8,%r8
ffffffff800020fb:	74 31                	je     ffffffff8000212e <plot_char_scaled_uncanvas+0x14e>
ffffffff800020fd:	80 3e 00             	cmpb   $0x0,(%rsi)
ffffffff80002100:	44 89 fa             	mov    %r15d,%edx
ffffffff80002103:	48 89 c8             	mov    %rcx,%rax
ffffffff80002106:	41 0f 45 d6          	cmovne %r14d,%edx
ffffffff8000210a:	48 29 f8             	sub    %rdi,%rax
ffffffff8000210d:	40 f6 c7 04          	test   $0x4,%dil
ffffffff80002111:	74 0d                	je     ffffffff80002120 <plot_char_scaled_uncanvas+0x140>
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002113:	89 10                	mov    %edx,(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002115:	48 83 c0 04          	add    $0x4,%rax
ffffffff80002119:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000211c:	74 10                	je     ffffffff8000212e <plot_char_scaled_uncanvas+0x14e>
ffffffff8000211e:	66 90                	xchg   %ax,%ax
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002120:	89 10                	mov    %edx,(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002122:	48 83 c0 08          	add    $0x8,%rax
                fb_line[gx] = *glyph_pointer ? fg : bg;
ffffffff80002126:	89 50 fc             	mov    %edx,-0x4(%rax)
            for (size_t i = 0; i < ctx->font_scale_x; i++) {
ffffffff80002129:	48 39 c1             	cmp    %rax,%rcx
ffffffff8000212c:	75 f2                	jne    ffffffff80002120 <plot_char_scaled_uncanvas+0x140>
            glyph_pointer++;
ffffffff8000212e:	48 83 c6 01          	add    $0x1,%rsi
        for (size_t fx = 0; fx < ctx->font_width; fx++) {
ffffffff80002132:	48 01 f9             	add    %rdi,%rcx
ffffffff80002135:	4c 39 ce             	cmp    %r9,%rsi
ffffffff80002138:	75 be                	jne    ffffffff800020f8 <plot_char_scaled_uncanvas+0x118>
    for (size_t gy = 0; gy < ctx->glyph_height; gy++) {
ffffffff8000213a:	49 83 c2 01          	add    $0x1,%r10
ffffffff8000213e:	4d 01 eb             	add    %r13,%r11
ffffffff80002141:	4c 39 14 24          	cmp    %r10,(%rsp)
ffffffff80002145:	0f 85 65 ff ff ff    	jne    ffffffff800020b0 <plot_char_scaled_uncanvas+0xd0>
}
ffffffff8000214b:	48 83 c4 20          	add    $0x20,%rsp
ffffffff8000214f:	5b                   	pop    %rbx
ffffffff80002150:	5d                   	pop    %rbp
ffffffff80002151:	41 5c                	pop    %r12
ffffffff80002153:	41 5d                	pop    %r13
ffffffff80002155:	41 5e                	pop    %r14
ffffffff80002157:	41 5f                	pop    %r15
ffffffff80002159:	c3                   	ret
ffffffff8000215a:	c3                   	ret
ffffffff8000215b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80002160 <flanterm_fb_init>:
    uint32_t *default_bg, uint32_t *default_fg,
    uint32_t *default_bg_bright, uint32_t *default_fg_bright,
    void *font, size_t font_width, size_t font_height, size_t font_spacing,
    size_t font_scale_x, size_t font_scale_y,
    size_t margin
) {
ffffffff80002160:	f3 0f 1e fa          	endbr64
ffffffff80002164:	41 57                	push   %r15
ffffffff80002166:	49 89 ff             	mov    %rdi,%r15
ffffffff80002169:	41 56                	push   %r14
ffffffff8000216b:	41 55                	push   %r13
ffffffff8000216d:	49 89 cd             	mov    %rcx,%r13
ffffffff80002170:	41 54                	push   %r12
ffffffff80002172:	4d 89 c4             	mov    %r8,%r12
ffffffff80002175:	55                   	push   %rbp
ffffffff80002176:	53                   	push   %rbx
ffffffff80002177:	48 83 ec 48          	sub    $0x48,%rsp
ffffffff8000217b:	8b 84 24 88 00 00 00 	mov    0x88(%rsp),%eax
ffffffff80002182:	44 8b b4 24 80 00 00 	mov    0x80(%rsp),%r14d
ffffffff80002189:	00 
ffffffff8000218a:	48 89 74 24 18       	mov    %rsi,0x18(%rsp)
    if (font_scale_x == 0 || font_scale_y == 0) {
ffffffff8000218f:	48 83 bc 24 08 01 00 	cmpq   $0x0,0x108(%rsp)
ffffffff80002196:	00 00 
) {
ffffffff80002198:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
ffffffff8000219d:	89 44 24 34          	mov    %eax,0x34(%rsp)
ffffffff800021a1:	8b 84 24 90 00 00 00 	mov    0x90(%rsp),%eax
ffffffff800021a8:	4c 89 4c 24 20       	mov    %r9,0x20(%rsp)
ffffffff800021ad:	48 8b ac 24 f8 00 00 	mov    0xf8(%rsp),%rbp
ffffffff800021b4:	00 
ffffffff800021b5:	89 44 24 10          	mov    %eax,0x10(%rsp)
ffffffff800021b9:	8b 84 24 98 00 00 00 	mov    0x98(%rsp),%eax
ffffffff800021c0:	44 88 74 24 33       	mov    %r14b,0x33(%rsp)
ffffffff800021c5:	89 44 24 38          	mov    %eax,0x38(%rsp)
ffffffff800021c9:	8b 84 24 a0 00 00 00 	mov    0xa0(%rsp),%eax
ffffffff800021d0:	89 44 24 2c          	mov    %eax,0x2c(%rsp)
ffffffff800021d4:	8b 84 24 a8 00 00 00 	mov    0xa8(%rsp),%eax
ffffffff800021db:	89 44 24 3c          	mov    %eax,0x3c(%rsp)
    if (font_scale_x == 0 || font_scale_y == 0) {
ffffffff800021df:	0f 84 b4 07 00 00    	je     ffffffff80002999 <flanterm_fb_init+0x839>
ffffffff800021e5:	48 83 bc 24 10 01 00 	cmpq   $0x0,0x110(%rsp)
ffffffff800021ec:	00 00 
ffffffff800021ee:	0f 84 a5 07 00 00    	je     ffffffff80002999 <flanterm_fb_init+0x839>
            font_scale_x = 4;
            font_scale_y = 4;
        }
    }

    if (red_mask_size < 8 || red_mask_size != green_mask_size || red_mask_size != blue_mask_size) {
ffffffff800021f4:	41 80 fe 07          	cmp    $0x7,%r14b
ffffffff800021f8:	0f 96 c0             	setbe  %al
ffffffff800021fb:	44 3a 74 24 10       	cmp    0x10(%rsp),%r14b
ffffffff80002200:	0f 95 c2             	setne  %dl
ffffffff80002203:	08 d0                	or     %dl,%al
ffffffff80002205:	0f 85 d0 08 00 00    	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
ffffffff8000220b:	44 3a 74 24 2c       	cmp    0x2c(%rsp),%r14b
ffffffff80002210:	0f 85 c5 08 00 00    	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
        return NULL;
    }

    if (_malloc == NULL) {
ffffffff80002216:	4d 85 ff             	test   %r15,%r15
ffffffff80002219:	0f 84 c9 08 00 00    	je     ffffffff80002ae8 <flanterm_fb_init+0x988>
        return NULL;
#endif
    }

    struct flanterm_fb_context *ctx = NULL;
    ctx = _malloc(sizeof(struct flanterm_fb_context));
ffffffff8000221f:	bf 20 03 00 00       	mov    $0x320,%edi
ffffffff80002224:	41 ff d7             	call   *%r15
ffffffff80002227:	48 89 c3             	mov    %rax,%rbx
    if (ctx == NULL) {
ffffffff8000222a:	48 85 c0             	test   %rax,%rax
ffffffff8000222d:	0f 84 a8 08 00 00    	je     ffffffff80002adb <flanterm_fb_init+0x97b>
        goto fail;
    }

    struct flanterm_context *_ctx = (void *)ctx;
    memset(ctx, 0, sizeof(struct flanterm_fb_context));
ffffffff80002233:	31 f6                	xor    %esi,%esi
ffffffff80002235:	ba 20 03 00 00       	mov    $0x320,%edx
ffffffff8000223a:	48 89 c7             	mov    %rax,%rdi
ffffffff8000223d:	e8 2e 45 00 00       	call   ffffffff80006770 <memset>

    ctx->red_mask_size = red_mask_size;
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
    ctx->green_mask_size = green_mask_size;
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002242:	8b 74 24 10          	mov    0x10(%rsp),%esi
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
ffffffff80002246:	0f b6 44 24 34       	movzbl 0x34(%rsp),%eax
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff8000224b:	0f b6 54 24 38       	movzbl 0x38(%rsp),%edx
    ctx->red_mask_size = red_mask_size;
ffffffff80002250:	0f b6 4c 24 33       	movzbl 0x33(%rsp),%ecx
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002255:	89 f7                	mov    %esi,%edi
    ctx->red_mask_shift = red_mask_shift + (red_mask_size - 8);
ffffffff80002257:	42 8d 44 30 f8       	lea    -0x8(%rax,%r14,1),%eax
    ctx->red_mask_size = red_mask_size;
ffffffff8000225c:	40 0f b6 f6          	movzbl %sil,%esi
    ctx->green_mask_shift = green_mask_shift + (green_mask_size - 8);
ffffffff80002260:	8d 54 3a f8          	lea    -0x8(%rdx,%rdi,1),%edx
    ctx->red_mask_size = red_mask_size;
ffffffff80002264:	88 c5                	mov    %al,%ch
ffffffff80002266:	c1 e6 10             	shl    $0x10,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002269:	44 0f b6 f0          	movzbl %al,%r14d
    ctx->red_mask_size = red_mask_size;
ffffffff8000226d:	0f b7 c9             	movzwl %cx,%ecx
ffffffff80002270:	89 d7                	mov    %edx,%edi
ffffffff80002272:	44 0f b6 da          	movzbl %dl,%r11d
ffffffff80002276:	c1 e7 18             	shl    $0x18,%edi
ffffffff80002279:	09 f1                	or     %esi,%ecx
    ctx->blue_mask_size = blue_mask_size;
ffffffff8000227b:	8b 74 24 2c          	mov    0x2c(%rsp),%esi
    ctx->red_mask_size = red_mask_size;
ffffffff8000227f:	09 f9                	or     %edi,%ecx
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff80002281:	0f b6 7c 24 3c       	movzbl 0x3c(%rsp),%edi

    if (ansi_colours != NULL) {
ffffffff80002286:	48 83 bc 24 b8 00 00 	cmpq   $0x0,0xb8(%rsp)
ffffffff8000228d:	00 00 
    ctx->blue_mask_size = blue_mask_size;
ffffffff8000228f:	40 88 b3 24 02 00 00 	mov    %sil,0x224(%rbx)
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff80002296:	8d 74 37 f8          	lea    -0x8(%rdi,%rsi,1),%esi
    ctx->red_mask_size = red_mask_size;
ffffffff8000229a:	89 8b 20 02 00 00    	mov    %ecx,0x220(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022a0:	40 0f b6 fe          	movzbl %sil,%edi
    ctx->blue_mask_shift = blue_mask_shift + (blue_mask_size - 8);
ffffffff800022a4:	40 88 b3 25 02 00 00 	mov    %sil,0x225(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022ab:	89 7c 24 10          	mov    %edi,0x10(%rsp)
    if (ansi_colours != NULL) {
ffffffff800022af:	0f 84 d6 08 00 00    	je     ffffffff80002b8b <flanterm_fb_init+0xa2b>
        for (size_t i = 0; i < 8; i++) {
ffffffff800022b5:	45 31 c9             	xor    %r9d,%r9d
            ctx->ansi_colours[i] = convert_colour(_ctx, ansi_colours[i]);
ffffffff800022b8:	48 8b bc 24 b8 00 00 	mov    0xb8(%rsp),%rdi
ffffffff800022bf:	00 
ffffffff800022c0:	46 8b 04 8f          	mov    (%rdi,%r9,4),%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800022c4:	44 89 c1             	mov    %r8d,%ecx
ffffffff800022c7:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022ca:	44 89 d9             	mov    %r11d,%ecx
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800022cd:	41 89 fa             	mov    %edi,%r10d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022d0:	44 89 c7             	mov    %r8d,%edi
    uint32_t b =  colour & 0xff;
ffffffff800022d3:	45 0f b6 c0          	movzbl %r8b,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022d7:	c1 ef 10             	shr    $0x10,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022da:	41 d3 e2             	shl    %cl,%r10d
ffffffff800022dd:	44 89 f1             	mov    %r14d,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800022e0:	40 0f b6 ff          	movzbl %dil,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800022e4:	d3 e7                	shl    %cl,%edi
ffffffff800022e6:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
ffffffff800022eb:	44 09 d7             	or     %r10d,%edi
ffffffff800022ee:	41 d3 e0             	shl    %cl,%r8d
ffffffff800022f1:	44 09 c7             	or     %r8d,%edi
ffffffff800022f4:	42 89 bc 8b 48 02 00 	mov    %edi,0x248(%rbx,%r9,4)
ffffffff800022fb:	00 
        for (size_t i = 0; i < 8; i++) {
ffffffff800022fc:	49 83 c1 01          	add    $0x1,%r9
ffffffff80002300:	49 83 f9 08          	cmp    $0x8,%r9
ffffffff80002304:	75 b2                	jne    ffffffff800022b8 <flanterm_fb_init+0x158>
        ctx->ansi_colours[5] = convert_colour(_ctx, 0x00aa00aa); // magenta
        ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan
        ctx->ansi_colours[7] = convert_colour(_ctx, 0x00aaaaaa); // grey
    }

    if (ansi_bright_colours != NULL) {
ffffffff80002306:	48 83 bc 24 c0 00 00 	cmpq   $0x0,0xc0(%rsp)
ffffffff8000230d:	00 00 
ffffffff8000230f:	0f 84 ee 08 00 00    	je     ffffffff80002c03 <flanterm_fb_init+0xaa3>
        for (size_t i = 0; i < 8; i++) {
ffffffff80002315:	45 31 c9             	xor    %r9d,%r9d
            ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);
ffffffff80002318:	48 8b bc 24 c0 00 00 	mov    0xc0(%rsp),%rdi
ffffffff8000231f:	00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002320:	44 89 f1             	mov    %r14d,%ecx
            ctx->ansi_bright_colours[i] = convert_colour(_ctx, ansi_bright_colours[i]);
ffffffff80002323:	46 8b 04 8f          	mov    (%rdi,%r9,4),%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002327:	45 89 c2             	mov    %r8d,%r10d
ffffffff8000232a:	41 c1 ea 10          	shr    $0x10,%r10d
ffffffff8000232e:	45 0f b6 d2          	movzbl %r10b,%r10d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002332:	41 d3 e2             	shl    %cl,%r10d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002335:	44 89 c1             	mov    %r8d,%ecx
    uint32_t b =  colour & 0xff;
ffffffff80002338:	45 0f b6 c0          	movzbl %r8b,%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000233c:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000233f:	44 89 d9             	mov    %r11d,%ecx
ffffffff80002342:	d3 e7                	shl    %cl,%edi
ffffffff80002344:	0f b6 4c 24 10       	movzbl 0x10(%rsp),%ecx
ffffffff80002349:	44 09 d7             	or     %r10d,%edi
ffffffff8000234c:	41 d3 e0             	shl    %cl,%r8d
ffffffff8000234f:	44 09 c7             	or     %r8d,%edi
ffffffff80002352:	42 89 bc 8b 68 02 00 	mov    %edi,0x268(%rbx,%r9,4)
ffffffff80002359:	00 
        for (size_t i = 0; i < 8; i++) {
ffffffff8000235a:	49 83 c1 01          	add    $0x1,%r9
ffffffff8000235e:	49 83 f9 08          	cmp    $0x8,%r9
ffffffff80002362:	75 b4                	jne    ffffffff80002318 <flanterm_fb_init+0x1b8>
    }

    if (default_bg != NULL) {
        ctx->default_bg = convert_colour(_ctx, *default_bg);
    } else {
        ctx->default_bg = 0x00000000; // background (black)
ffffffff80002364:	45 31 c0             	xor    %r8d,%r8d
    if (default_bg != NULL) {
ffffffff80002367:	48 83 bc 24 c8 00 00 	cmpq   $0x0,0xc8(%rsp)
ffffffff8000236e:	00 00 
ffffffff80002370:	74 31                	je     ffffffff800023a3 <flanterm_fb_init+0x243>
        ctx->default_bg = convert_colour(_ctx, *default_bg);
ffffffff80002372:	48 8b bc 24 c8 00 00 	mov    0xc8(%rsp),%rdi
ffffffff80002379:	00 
ffffffff8000237a:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000237c:	89 f9                	mov    %edi,%ecx
    uint32_t b =  colour & 0xff;
ffffffff8000237e:	44 0f b6 c7          	movzbl %dil,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002382:	c1 ef 10             	shr    $0x10,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002385:	0f b6 cd             	movzbl %ch,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002388:	40 0f b6 ff          	movzbl %dil,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000238c:	41 89 c9             	mov    %ecx,%r9d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000238f:	89 d1                	mov    %edx,%ecx
ffffffff80002391:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002394:	89 f1                	mov    %esi,%ecx
ffffffff80002396:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002399:	89 c1                	mov    %eax,%ecx
ffffffff8000239b:	45 09 c8             	or     %r9d,%r8d
ffffffff8000239e:	d3 e7                	shl    %cl,%edi
ffffffff800023a0:	41 09 f8             	or     %edi,%r8d
    }

    if (default_fg != NULL) {
ffffffff800023a3:	48 83 bc 24 d0 00 00 	cmpq   $0x0,0xd0(%rsp)
ffffffff800023aa:	00 00 
ffffffff800023ac:	44 89 83 8c 02 00 00 	mov    %r8d,0x28c(%rbx)
ffffffff800023b3:	0f 84 a3 09 00 00    	je     ffffffff80002d5c <flanterm_fb_init+0xbfc>
        ctx->default_fg = convert_colour(_ctx, *default_fg);
ffffffff800023b9:	48 8b bc 24 d0 00 00 	mov    0xd0(%rsp),%rdi
ffffffff800023c0:	00 
ffffffff800023c1:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023c3:	89 f9                	mov    %edi,%ecx
    uint32_t b =  colour & 0xff;
ffffffff800023c5:	44 0f b6 c7          	movzbl %dil,%r8d
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800023c9:	c1 ef 10             	shr    $0x10,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023cc:	0f b6 cd             	movzbl %ch,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff800023cf:	40 0f b6 ff          	movzbl %dil,%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff800023d3:	41 89 c9             	mov    %ecx,%r9d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800023d6:	89 d1                	mov    %edx,%ecx
ffffffff800023d8:	41 d3 e1             	shl    %cl,%r9d
ffffffff800023db:	89 f1                	mov    %esi,%ecx
ffffffff800023dd:	41 d3 e0             	shl    %cl,%r8d
ffffffff800023e0:	89 c1                	mov    %eax,%ecx
ffffffff800023e2:	45 09 c8             	or     %r9d,%r8d
ffffffff800023e5:	d3 e7                	shl    %cl,%edi
ffffffff800023e7:	41 09 f8             	or     %edi,%r8d
ffffffff800023ea:	45 89 c2             	mov    %r8d,%r10d
    } else {
        ctx->default_fg = convert_colour(_ctx, 0x00aaaaaa); // foreground (grey)
    }

    if (default_bg_bright != NULL) {
ffffffff800023ed:	48 83 bc 24 d8 00 00 	cmpq   $0x0,0xd8(%rsp)
ffffffff800023f4:	00 00 
ffffffff800023f6:	44 89 93 88 02 00 00 	mov    %r10d,0x288(%rbx)
ffffffff800023fd:	0f 84 cf 08 00 00    	je     ffffffff80002cd2 <flanterm_fb_init+0xb72>
        ctx->default_bg_bright = convert_colour(_ctx, *default_bg_bright);
ffffffff80002403:	48 8b bc 24 d8 00 00 	mov    0xd8(%rsp),%rdi
ffffffff8000240a:	00 
ffffffff8000240b:	44 8b 07             	mov    (%rdi),%r8d
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000240e:	44 89 c1             	mov    %r8d,%ecx
ffffffff80002411:	0f b6 fd             	movzbl %ch,%edi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002414:	89 d1                	mov    %edx,%ecx
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002416:	41 89 f9             	mov    %edi,%r9d
    uint32_t b =  colour & 0xff;
ffffffff80002419:	41 0f b6 f8          	movzbl %r8b,%edi
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000241d:	41 c1 e8 10          	shr    $0x10,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002421:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002424:	89 f1                	mov    %esi,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002426:	45 0f b6 c0          	movzbl %r8b,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000242a:	d3 e7                	shl    %cl,%edi
ffffffff8000242c:	89 c1                	mov    %eax,%ecx
ffffffff8000242e:	44 09 cf             	or     %r9d,%edi
ffffffff80002431:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002434:	44 09 c7             	or     %r8d,%edi
    } else {
        ctx->default_bg_bright = convert_colour(_ctx, 0x00555555); // background (black)
    }

    if (default_fg_bright != NULL) {
ffffffff80002437:	48 83 bc 24 e0 00 00 	cmpq   $0x0,0xe0(%rsp)
ffffffff8000243e:	00 00 
ffffffff80002440:	89 bb 94 02 00 00    	mov    %edi,0x294(%rbx)
ffffffff80002446:	0f 84 60 08 00 00    	je     ffffffff80002cac <flanterm_fb_init+0xb4c>
        ctx->default_fg_bright = convert_colour(_ctx, *default_fg_bright);
ffffffff8000244c:	48 8b bc 24 e0 00 00 	mov    0xe0(%rsp),%rdi
ffffffff80002453:	00 
ffffffff80002454:	8b 3f                	mov    (%rdi),%edi
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002456:	89 f9                	mov    %edi,%ecx
ffffffff80002458:	0f b6 cd             	movzbl %ch,%ecx
ffffffff8000245b:	41 89 c8             	mov    %ecx,%r8d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000245e:	89 d1                	mov    %edx,%ecx
    uint32_t b =  colour & 0xff;
ffffffff80002460:	40 0f b6 d7          	movzbl %dil,%edx
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002464:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002467:	89 f1                	mov    %esi,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002469:	89 fe                	mov    %edi,%esi
ffffffff8000246b:	c1 ee 10             	shr    $0x10,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000246e:	d3 e2                	shl    %cl,%edx
ffffffff80002470:	89 c1                	mov    %eax,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff80002472:	40 0f b6 f6          	movzbl %sil,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002476:	44 09 c2             	or     %r8d,%edx
ffffffff80002479:	d3 e6                	shl    %cl,%esi
ffffffff8000247b:	09 f2                	or     %esi,%edx
    }

    ctx->text_fg = ctx->default_fg;
    ctx->text_bg = 0xffffffff;

    ctx->framebuffer = (void *)framebuffer;
ffffffff8000247d:	48 8b 44 24 08       	mov    0x8(%rsp),%rax
ffffffff80002482:	89 93 90 02 00 00    	mov    %edx,0x290(%rbx)
    ctx->height = height;
    ctx->pitch = pitch;

#define FONT_BYTES ((font_width * font_height * FLANTERM_FB_FONT_GLYPHS) / 8)

    if (font != NULL) {
ffffffff80002488:	48 83 bc 24 e8 00 00 	cmpq   $0x0,0xe8(%rsp)
ffffffff8000248f:	00 00 
    ctx->text_fg = ctx->default_fg;
ffffffff80002491:	44 89 93 e0 02 00 00 	mov    %r10d,0x2e0(%rbx)
    ctx->framebuffer = (void *)framebuffer;
ffffffff80002498:	48 89 83 f8 01 00 00 	mov    %rax,0x1f8(%rbx)
    ctx->pitch = pitch;
ffffffff8000249f:	48 8b 44 24 20       	mov    0x20(%rsp),%rax
    ctx->text_bg = 0xffffffff;
ffffffff800024a4:	c7 83 e4 02 00 00 ff 	movl   $0xffffffff,0x2e4(%rbx)
ffffffff800024ab:	ff ff ff 
    ctx->width = width;
ffffffff800024ae:	4c 89 ab 08 02 00 00 	mov    %r13,0x208(%rbx)
    ctx->height = height;
ffffffff800024b5:	4c 89 a3 10 02 00 00 	mov    %r12,0x210(%rbx)
    ctx->pitch = pitch;
ffffffff800024bc:	48 89 83 00 02 00 00 	mov    %rax,0x200(%rbx)
    if (font != NULL) {
ffffffff800024c3:	0f 84 2e 08 00 00    	je     ffffffff80002cf7 <flanterm_fb_init+0xb97>
        ctx->font_width = font_width;
ffffffff800024c9:	48 8b 84 24 f0 00 00 	mov    0xf0(%rsp),%rax
ffffffff800024d0:	00 
        ctx->font_height = font_height;
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024d1:	48 89 ef             	mov    %rbp,%rdi
        ctx->font_height = font_height;
ffffffff800024d4:	48 89 ab c0 01 00 00 	mov    %rbp,0x1c0(%rbx)
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024db:	48 0f af f8          	imul   %rax,%rdi
        ctx->font_width = font_width;
ffffffff800024df:	48 89 83 b8 01 00 00 	mov    %rax,0x1b8(%rbx)
        ctx->font_bits_size = FONT_BYTES;
ffffffff800024e6:	48 c1 e7 08          	shl    $0x8,%rdi
ffffffff800024ea:	48 c1 ef 03          	shr    $0x3,%rdi
ffffffff800024ee:	48 89 bb 28 02 00 00 	mov    %rdi,0x228(%rbx)
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff800024f5:	41 ff d7             	call   *%r15
ffffffff800024f8:	48 89 83 30 02 00 00 	mov    %rax,0x230(%rbx)
ffffffff800024ff:	48 89 c7             	mov    %rax,%rdi
        if (ctx->font_bits == NULL) {
ffffffff80002502:	48 85 c0             	test   %rax,%rax
ffffffff80002505:	0f 84 0f 05 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
            goto fail;
        }
        memcpy(ctx->font_bits, font, ctx->font_bits_size);
ffffffff8000250b:	48 8b 93 28 02 00 00 	mov    0x228(%rbx),%rdx
ffffffff80002512:	48 8b b4 24 e8 00 00 	mov    0xe8(%rsp),%rsi
ffffffff80002519:	00 
ffffffff8000251a:	e8 21 42 00 00       	call   ffffffff80006740 <memcpy>
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
    }

#undef FONT_BYTES

    ctx->font_width += font_spacing;
ffffffff8000251f:	48 8b 84 24 00 01 00 	mov    0x100(%rsp),%rax
ffffffff80002526:	00 
ffffffff80002527:	48 03 83 b8 01 00 00 	add    0x1b8(%rbx),%rax
ffffffff8000252e:	48 89 83 b8 01 00 00 	mov    %rax,0x1b8(%rbx)

    ctx->font_bool_size = FLANTERM_FB_FONT_GLYPHS * font_height * ctx->font_width * sizeof(bool);
ffffffff80002535:	48 0f af c5          	imul   %rbp,%rax
ffffffff80002539:	48 c1 e0 08          	shl    $0x8,%rax
ffffffff8000253d:	48 89 83 38 02 00 00 	mov    %rax,0x238(%rbx)
ffffffff80002544:	48 89 c7             	mov    %rax,%rdi
    ctx->font_bool = _malloc(ctx->font_bool_size);
ffffffff80002547:	41 ff d7             	call   *%r15
ffffffff8000254a:	48 89 83 40 02 00 00 	mov    %rax,0x240(%rbx)
ffffffff80002551:	48 89 c2             	mov    %rax,%rdx
    if (ctx->font_bool == NULL) {
ffffffff80002554:	48 85 c0             	test   %rax,%rax
ffffffff80002557:	0f 84 bd 04 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
    }

    ctx->font_scale_x = font_scale_x;
    ctx->font_scale_y = font_scale_y;

    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff8000255d:	4c 8b 93 b8 01 00 00 	mov    0x1b8(%rbx),%r10
ffffffff80002564:	49 89 ee             	mov    %rbp,%r14
ffffffff80002567:	45 31 e4             	xor    %r12d,%r12d
                if ((glyph[y] & (0x80 >> x))) {
ffffffff8000256a:	48 89 de             	mov    %rbx,%rsi
ffffffff8000256d:	4c 8b ab 30 02 00 00 	mov    0x230(%rbx),%r13
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002574:	49 c7 c1 40 ff ff ff 	mov    $0xffffffffffffff40,%r9
                if ((glyph[y] & (0x80 >> x))) {
ffffffff8000257b:	41 b8 80 00 00 00    	mov    $0x80,%r8d
ffffffff80002581:	4d 0f af f2          	imul   %r10,%r14
ffffffff80002585:	4e 8d 5c 2d 00       	lea    0x0(%rbp,%r13,1),%r11
ffffffff8000258a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        for (size_t y = 0; y < font_height; y++) {
ffffffff80002590:	4a 8d 3c 12          	lea    (%rdx,%r10,1),%rdi
ffffffff80002594:	4b 8d 04 2c          	lea    (%r12,%r13,1),%rax
ffffffff80002598:	48 89 d3             	mov    %rdx,%rbx
ffffffff8000259b:	48 85 ed             	test   %rbp,%rbp
ffffffff8000259e:	74 64                	je     ffffffff80002604 <flanterm_fb_init+0x4a4>
ffffffff800025a0:	4c 89 64 24 10       	mov    %r12,0x10(%rsp)
ffffffff800025a5:	0f 1f 00             	nopl   (%rax)
            for (size_t x = 0; x < 8; x++) {
ffffffff800025a8:	4c 89 74 24 08       	mov    %r14,0x8(%rsp)
ffffffff800025ad:	31 c9                	xor    %ecx,%ecx
ffffffff800025af:	90                   	nop
                if ((glyph[y] & (0x80 >> x))) {
ffffffff800025b0:	44 0f b6 20          	movzbl (%rax),%r12d
ffffffff800025b4:	45 89 c6             	mov    %r8d,%r14d
ffffffff800025b7:	41 d3 fe             	sar    %cl,%r14d
ffffffff800025ba:	45 85 e6             	test   %r12d,%r14d
                    ctx->font_bool[offset] = true;
ffffffff800025bd:	0f 95 04 0b          	setne  (%rbx,%rcx,1)
            for (size_t x = 0; x < 8; x++) {
ffffffff800025c1:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800025c5:	48 83 f9 08          	cmp    $0x8,%rcx
ffffffff800025c9:	75 e5                	jne    ffffffff800025b0 <flanterm_fb_init+0x450>
ffffffff800025cb:	4c 8b 74 24 08       	mov    0x8(%rsp),%r14
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff800025d0:	48 8d 4b 08          	lea    0x8(%rbx),%rcx
ffffffff800025d4:	49 83 fa 08          	cmp    $0x8,%r10
ffffffff800025d8:	76 16                	jbe    ffffffff800025f0 <flanterm_fb_init+0x490>
                if (i >= 0xc0 && i <= 0xdf) {
ffffffff800025da:	49 83 f9 1f          	cmp    $0x1f,%r9
ffffffff800025de:	0f 86 1c 04 00 00    	jbe    ffffffff80002a00 <flanterm_fb_init+0x8a0>
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff800025e4:	c6 01 00             	movb   $0x0,(%rcx)
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff800025e7:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800025eb:	48 39 f9             	cmp    %rdi,%rcx
ffffffff800025ee:	75 ea                	jne    ffffffff800025da <flanterm_fb_init+0x47a>
        for (size_t y = 0; y < font_height; y++) {
ffffffff800025f0:	48 83 c0 01          	add    $0x1,%rax
ffffffff800025f4:	4c 01 d7             	add    %r10,%rdi
ffffffff800025f7:	4c 01 d3             	add    %r10,%rbx
ffffffff800025fa:	49 39 c3             	cmp    %rax,%r11
ffffffff800025fd:	75 a9                	jne    ffffffff800025a8 <flanterm_fb_init+0x448>
ffffffff800025ff:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
    for (size_t i = 0; i < FLANTERM_FB_FONT_GLYPHS; i++) {
ffffffff80002604:	49 83 c1 01          	add    $0x1,%r9
ffffffff80002608:	49 01 eb             	add    %rbp,%r11
ffffffff8000260b:	4c 01 f2             	add    %r14,%rdx
ffffffff8000260e:	49 01 ec             	add    %rbp,%r12
ffffffff80002611:	49 83 f9 40          	cmp    $0x40,%r9
ffffffff80002615:	0f 85 75 ff ff ff    	jne    ffffffff80002590 <flanterm_fb_init+0x430>
    ctx->font_scale_x = font_scale_x;
ffffffff8000261b:	48 8b 84 24 08 01 00 	mov    0x108(%rsp),%rax
ffffffff80002622:	00 
ffffffff80002623:	31 d2                	xor    %edx,%edx
ffffffff80002625:	48 89 f3             	mov    %rsi,%rbx
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002628:	4c 0f af 94 24 08 01 	imul   0x108(%rsp),%r10
ffffffff8000262f:	00 00 
    ctx->font_scale_x = font_scale_x;
ffffffff80002631:	48 89 86 d8 01 00 00 	mov    %rax,0x1d8(%rsi)
    ctx->font_scale_y = font_scale_y;
ffffffff80002638:	48 8b 84 24 10 01 00 	mov    0x110(%rsp),%rax
ffffffff8000263f:	00 
ffffffff80002640:	48 89 86 e0 01 00 00 	mov    %rax,0x1e0(%rsi)
    ctx->glyph_height = font_height * font_scale_y;
ffffffff80002647:	48 0f af e8          	imul   %rax,%rbp

    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000264b:	48 8b 84 24 18 01 00 	mov    0x118(%rsp),%rax
ffffffff80002652:	00 
    ctx->glyph_width = ctx->font_width * font_scale_x;
ffffffff80002653:	4c 89 96 c8 01 00 00 	mov    %r10,0x1c8(%rsi)
    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000265a:	48 8d 3c 00          	lea    (%rax,%rax,1),%rdi
ffffffff8000265e:	48 8b 86 08 02 00 00 	mov    0x208(%rsi),%rax
    ctx->glyph_height = font_height * font_scale_y;
ffffffff80002665:	48 89 ae d0 01 00 00 	mov    %rbp,0x1d0(%rsi)
    _ctx->cols = (ctx->width - margin * 2) / ctx->glyph_width;
ffffffff8000266c:	48 29 f8             	sub    %rdi,%rax
ffffffff8000266f:	49 f7 f2             	div    %r10
ffffffff80002672:	48 89 83 e8 00 00 00 	mov    %rax,0xe8(%rbx)
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff80002679:	48 89 c1             	mov    %rax,%rcx
ffffffff8000267c:	48 89 d6             	mov    %rdx,%rsi
ffffffff8000267f:	31 d2                	xor    %edx,%edx
ffffffff80002681:	48 8b 83 10 02 00 00 	mov    0x210(%rbx),%rax

    ctx->offset_x = margin + ((ctx->width - margin * 2) % ctx->glyph_width) / 2;
ffffffff80002688:	48 d1 ee             	shr    $1,%rsi
ffffffff8000268b:	48 03 b4 24 18 01 00 	add    0x118(%rsp),%rsi
ffffffff80002692:	00 
ffffffff80002693:	48 89 b3 e8 01 00 00 	mov    %rsi,0x1e8(%rbx)
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff8000269a:	48 29 f8             	sub    %rdi,%rax
ffffffff8000269d:	48 f7 f5             	div    %rbp
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;

    ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);
ffffffff800026a0:	48 0f af c8          	imul   %rax,%rcx
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;
ffffffff800026a4:	48 d1 ea             	shr    $1,%rdx
ffffffff800026a7:	48 03 94 24 18 01 00 	add    0x118(%rsp),%rdx
ffffffff800026ae:	00 
    _ctx->rows = (ctx->height - margin * 2) / ctx->glyph_height;
ffffffff800026af:	48 89 83 e0 00 00 00 	mov    %rax,0xe0(%rbx)
    ctx->offset_y = margin + ((ctx->height - margin * 2) % ctx->glyph_height) / 2;
ffffffff800026b6:	48 89 93 f0 01 00 00 	mov    %rdx,0x1f0(%rbx)
    ctx->grid_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_char);
ffffffff800026bd:	48 8d 3c 49          	lea    (%rcx,%rcx,2),%rdi
ffffffff800026c1:	48 c1 e7 02          	shl    $0x2,%rdi
ffffffff800026c5:	48 89 bb a8 02 00 00 	mov    %rdi,0x2a8(%rbx)
    ctx->grid = _malloc(ctx->grid_size);
ffffffff800026cc:	41 ff d7             	call   *%r15
ffffffff800026cf:	48 89 83 c0 02 00 00 	mov    %rax,0x2c0(%rbx)
    if (ctx->grid == NULL) {
ffffffff800026d6:	48 85 c0             	test   %rax,%rax
ffffffff800026d9:	0f 84 3b 03 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff800026df:	48 8b bb e0 00 00 00 	mov    0xe0(%rbx),%rdi
ffffffff800026e6:	48 0f af bb e8 00 00 	imul   0xe8(%rbx),%rdi
ffffffff800026ed:	00 
ffffffff800026ee:	48 85 ff             	test   %rdi,%rdi
ffffffff800026f1:	74 2d                	je     ffffffff80002720 <flanterm_fb_init+0x5c0>
ffffffff800026f3:	48 8d 14 7f          	lea    (%rdi,%rdi,2),%rdx
        ctx->grid[i].c = ' ';
        ctx->grid[i].fg = ctx->text_fg;
ffffffff800026f7:	8b b3 e0 02 00 00    	mov    0x2e0(%rbx),%esi
        ctx->grid[i].bg = ctx->text_bg;
ffffffff800026fd:	8b 8b e4 02 00 00    	mov    0x2e4(%rbx),%ecx
ffffffff80002703:	48 8d 14 90          	lea    (%rax,%rdx,4),%rdx
        ctx->grid[i].c = ' ';
ffffffff80002707:	c7 00 20 00 00 00    	movl   $0x20,(%rax)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff8000270d:	48 83 c0 0c          	add    $0xc,%rax
        ctx->grid[i].fg = ctx->text_fg;
ffffffff80002711:	89 70 f8             	mov    %esi,-0x8(%rax)
        ctx->grid[i].bg = ctx->text_bg;
ffffffff80002714:	89 48 fc             	mov    %ecx,-0x4(%rax)
    for (size_t i = 0; i < _ctx->rows * _ctx->cols; i++) {
ffffffff80002717:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000271a:	75 eb                	jne    ffffffff80002707 <flanterm_fb_init+0x5a7>
    }

    ctx->queue_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item);
ffffffff8000271c:	48 c1 e7 05          	shl    $0x5,%rdi
ffffffff80002720:	48 89 bb b0 02 00 00 	mov    %rdi,0x2b0(%rbx)
    ctx->queue = _malloc(ctx->queue_size);
ffffffff80002727:	41 ff d7             	call   *%r15
ffffffff8000272a:	48 89 83 c8 02 00 00 	mov    %rax,0x2c8(%rbx)
ffffffff80002731:	48 89 c7             	mov    %rax,%rdi
    if (ctx->queue == NULL) {
ffffffff80002734:	48 85 c0             	test   %rax,%rax
ffffffff80002737:	0f 84 dd 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    ctx->queue_i = 0;
ffffffff8000273d:	48 c7 83 d0 02 00 00 	movq   $0x0,0x2d0(%rbx)
ffffffff80002744:	00 00 00 00 
    memset(ctx->queue, 0, ctx->queue_size);
ffffffff80002748:	48 8b 93 b0 02 00 00 	mov    0x2b0(%rbx),%rdx
ffffffff8000274f:	31 f6                	xor    %esi,%esi
ffffffff80002751:	e8 1a 40 00 00       	call   ffffffff80006770 <memset>

    ctx->map_size = _ctx->rows * _ctx->cols * sizeof(struct flanterm_fb_queue_item *);
ffffffff80002756:	48 8b bb e0 00 00 00 	mov    0xe0(%rbx),%rdi
ffffffff8000275d:	48 0f af bb e8 00 00 	imul   0xe8(%rbx),%rdi
ffffffff80002764:	00 
ffffffff80002765:	48 c1 e7 03          	shl    $0x3,%rdi
ffffffff80002769:	48 89 bb b8 02 00 00 	mov    %rdi,0x2b8(%rbx)
    ctx->map = _malloc(ctx->map_size);
ffffffff80002770:	41 ff d7             	call   *%r15
ffffffff80002773:	48 89 83 d8 02 00 00 	mov    %rax,0x2d8(%rbx)
ffffffff8000277a:	48 89 c7             	mov    %rax,%rdi
    if (ctx->map == NULL) {
ffffffff8000277d:	48 85 c0             	test   %rax,%rax
ffffffff80002780:	0f 84 94 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        goto fail;
    }
    memset(ctx->map, 0, ctx->map_size);
ffffffff80002786:	48 8b 93 b8 02 00 00 	mov    0x2b8(%rbx),%rdx
ffffffff8000278d:	31 f6                	xor    %esi,%esi
ffffffff8000278f:	e8 dc 3f 00 00       	call   ffffffff80006770 <memset>

    if (canvas != NULL) {
ffffffff80002794:	48 83 bc 24 b0 00 00 	cmpq   $0x0,0xb0(%rsp)
ffffffff8000279b:	00 00 
ffffffff8000279d:	0f 84 e0 05 00 00    	je     ffffffff80002d83 <flanterm_fb_init+0xc23>
        ctx->canvas_size = ctx->width * ctx->height * sizeof(uint32_t);
ffffffff800027a3:	48 8b bb 08 02 00 00 	mov    0x208(%rbx),%rdi
ffffffff800027aa:	48 0f af bb 10 02 00 	imul   0x210(%rbx),%rdi
ffffffff800027b1:	00 
ffffffff800027b2:	48 c1 e7 02          	shl    $0x2,%rdi
ffffffff800027b6:	48 89 bb 98 02 00 00 	mov    %rdi,0x298(%rbx)
        ctx->canvas = _malloc(ctx->canvas_size);
ffffffff800027bd:	41 ff d7             	call   *%r15
ffffffff800027c0:	48 89 83 a0 02 00 00 	mov    %rax,0x2a0(%rbx)
ffffffff800027c7:	48 89 c7             	mov    %rax,%rdi
        if (ctx->canvas == NULL) {
ffffffff800027ca:	48 85 c0             	test   %rax,%rax
ffffffff800027cd:	0f 84 47 02 00 00    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
            goto fail;
        }
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff800027d3:	4c 8b 9b 08 02 00 00 	mov    0x208(%rbx),%r11
ffffffff800027da:	4c 0f af 9b 10 02 00 	imul   0x210(%rbx),%r11
ffffffff800027e1:	00 
ffffffff800027e2:	4d 85 db             	test   %r11,%r11
ffffffff800027e5:	74 5a                	je     ffffffff80002841 <flanterm_fb_init+0x6e1>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800027e7:	44 0f b6 93 21 02 00 	movzbl 0x221(%rbx),%r10d
ffffffff800027ee:	00 
ffffffff800027ef:	44 0f b6 8b 23 02 00 	movzbl 0x223(%rbx),%r9d
ffffffff800027f6:	00 
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff800027f7:	31 f6                	xor    %esi,%esi
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff800027f9:	44 0f b6 83 25 02 00 	movzbl 0x225(%rbx),%r8d
ffffffff80002800:	00 
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff80002801:	48 8b 94 24 b0 00 00 	mov    0xb0(%rsp),%rdx
ffffffff80002808:	00 
            ctx->canvas[i] = convert_colour(_ctx, canvas[i]);
ffffffff80002809:	8b 2c b2             	mov    (%rdx,%rsi,4),%ebp
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff8000280c:	44 89 d1             	mov    %r10d,%ecx
    uint32_t r = (colour >> 16) & 0xff;
ffffffff8000280f:	89 e8                	mov    %ebp,%eax
ffffffff80002811:	c1 e8 10             	shr    $0x10,%eax
ffffffff80002814:	0f b6 c0             	movzbl %al,%eax
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002817:	d3 e0                	shl    %cl,%eax
    uint32_t g = (colour >> 8) & 0xff;
ffffffff80002819:	89 e9                	mov    %ebp,%ecx
    uint32_t b =  colour & 0xff;
ffffffff8000281b:	40 0f b6 ed          	movzbl %bpl,%ebp
    uint32_t g = (colour >> 8) & 0xff;
ffffffff8000281f:	0f b6 cd             	movzbl %ch,%ecx
ffffffff80002822:	41 89 cc             	mov    %ecx,%r12d
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002825:	44 89 c9             	mov    %r9d,%ecx
ffffffff80002828:	41 d3 e4             	shl    %cl,%r12d
ffffffff8000282b:	44 89 c1             	mov    %r8d,%ecx
ffffffff8000282e:	44 09 e0             	or     %r12d,%eax
ffffffff80002831:	d3 e5                	shl    %cl,%ebp
ffffffff80002833:	09 e8                	or     %ebp,%eax
ffffffff80002835:	89 04 b7             	mov    %eax,(%rdi,%rsi,4)
        for (size_t i = 0; i < ctx->width * ctx->height; i++) {
ffffffff80002838:	48 83 c6 01          	add    $0x1,%rsi
ffffffff8000283c:	49 39 f3             	cmp    %rsi,%r11
ffffffff8000283f:	75 c8                	jne    ffffffff80002809 <flanterm_fb_init+0x6a9>
        }
    }

    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002841:	48 83 bc 24 08 01 00 	cmpq   $0x1,0x108(%rsp)
ffffffff80002848:	00 01 
ffffffff8000284a:	0f 85 6c 05 00 00    	jne    ffffffff80002dbc <flanterm_fb_init+0xc5c>
ffffffff80002850:	48 83 bc 24 10 01 00 	cmpq   $0x1,0x110(%rsp)
ffffffff80002857:	00 01 
ffffffff80002859:	48 c7 c0 90 1d 00 80 	mov    $0xffffffff80001d90,%rax
ffffffff80002860:	0f 85 56 05 00 00    	jne    ffffffff80002dbc <flanterm_fb_init+0xc5c>
        if (canvas == NULL) {
            ctx->plot_char = plot_char_unscaled_uncanvas;
        } else {
            ctx->plot_char = plot_char_unscaled_canvas;
ffffffff80002866:	48 89 83 b0 01 00 00 	mov    %rax,0x1b0(%rbx)
    _ctx->restore_state = flanterm_fb_restore_state;
    _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;
    _ctx->full_refresh = flanterm_fb_full_refresh;
    _ctx->deinit = flanterm_fb_deinit;

    flanterm_context_reinit(_ctx);
ffffffff8000286d:	48 89 df             	mov    %rbx,%rdi
    _ctx->raw_putchar = flanterm_fb_raw_putchar;
ffffffff80002870:	48 c7 83 f0 00 00 00 	movq   $0xffffffff800018c0,0xf0(%rbx)
ffffffff80002877:	c0 18 00 80 
    _ctx->clear = flanterm_fb_clear;
ffffffff8000287b:	48 c7 83 f8 00 00 00 	movq   $0xffffffff80001350,0xf8(%rbx)
ffffffff80002882:	50 13 00 80 
    _ctx->set_cursor_pos = flanterm_fb_set_cursor_pos;
ffffffff80002886:	48 c7 83 00 01 00 00 	movq   $0xffffffff800013e0,0x100(%rbx)
ffffffff8000288d:	e0 13 00 80 
    _ctx->get_cursor_pos = flanterm_fb_get_cursor_pos;
ffffffff80002891:	48 c7 83 08 01 00 00 	movq   $0xffffffff80001430,0x108(%rbx)
ffffffff80002898:	30 14 00 80 
    _ctx->set_text_fg = flanterm_fb_set_text_fg;
ffffffff8000289c:	48 c7 83 10 01 00 00 	movq   $0xffffffff800014f0,0x110(%rbx)
ffffffff800028a3:	f0 14 00 80 
    _ctx->set_text_bg = flanterm_fb_set_text_bg;
ffffffff800028a7:	48 c7 83 18 01 00 00 	movq   $0xffffffff80001510,0x118(%rbx)
ffffffff800028ae:	10 15 00 80 
    _ctx->set_text_fg_bright = flanterm_fb_set_text_fg_bright;
ffffffff800028b2:	48 c7 83 20 01 00 00 	movq   $0xffffffff80001530,0x120(%rbx)
ffffffff800028b9:	30 15 00 80 
    _ctx->set_text_bg_bright = flanterm_fb_set_text_bg_bright;
ffffffff800028bd:	48 c7 83 28 01 00 00 	movq   $0xffffffff80001550,0x128(%rbx)
ffffffff800028c4:	50 15 00 80 
    _ctx->set_text_fg_rgb = flanterm_fb_set_text_fg_rgb;
ffffffff800028c8:	48 c7 83 30 01 00 00 	movq   $0xffffffff80001570,0x130(%rbx)
ffffffff800028cf:	70 15 00 80 
    _ctx->set_text_bg_rgb = flanterm_fb_set_text_bg_rgb;
ffffffff800028d3:	48 c7 83 38 01 00 00 	movq   $0xffffffff800015b0,0x138(%rbx)
ffffffff800028da:	b0 15 00 80 
    _ctx->set_text_fg_default = flanterm_fb_set_text_fg_default;
ffffffff800028de:	48 c7 83 40 01 00 00 	movq   $0xffffffff800015f0,0x140(%rbx)
ffffffff800028e5:	f0 15 00 80 
    _ctx->set_text_bg_default = flanterm_fb_set_text_bg_default;
ffffffff800028e9:	48 c7 83 48 01 00 00 	movq   $0xffffffff80001610,0x148(%rbx)
ffffffff800028f0:	10 16 00 80 
    _ctx->set_text_fg_default_bright = flanterm_fb_set_text_fg_default_bright;
ffffffff800028f4:	48 c7 83 50 01 00 00 	movq   $0xffffffff80001620,0x150(%rbx)
ffffffff800028fb:	20 16 00 80 
    _ctx->set_text_bg_default_bright = flanterm_fb_set_text_bg_default_bright;
ffffffff800028ff:	48 c7 83 58 01 00 00 	movq   $0xffffffff80001640,0x158(%rbx)
ffffffff80002906:	40 16 00 80 
    _ctx->move_character = flanterm_fb_move_character;
ffffffff8000290a:	48 c7 83 60 01 00 00 	movq   $0xffffffff80001470,0x160(%rbx)
ffffffff80002911:	70 14 00 80 
    _ctx->scroll = flanterm_fb_scroll;
ffffffff80002915:	48 c7 83 68 01 00 00 	movq   $0xffffffff80001260,0x168(%rbx)
ffffffff8000291c:	60 12 00 80 
    _ctx->revscroll = flanterm_fb_revscroll;
ffffffff80002920:	48 c7 83 70 01 00 00 	movq   $0xffffffff80001180,0x170(%rbx)
ffffffff80002927:	80 11 00 80 
    _ctx->swap_palette = flanterm_fb_swap_palette;
ffffffff8000292b:	48 c7 83 78 01 00 00 	movq   $0xffffffff800010b0,0x178(%rbx)
ffffffff80002932:	b0 10 00 80 
    _ctx->save_state = flanterm_fb_save_state;
ffffffff80002936:	48 c7 83 80 01 00 00 	movq   $0xffffffff80001050,0x180(%rbx)
ffffffff8000293d:	50 10 00 80 
    _ctx->restore_state = flanterm_fb_restore_state;
ffffffff80002941:	48 c7 83 88 01 00 00 	movq   $0xffffffff80001080,0x188(%rbx)
ffffffff80002948:	80 10 00 80 
    _ctx->double_buffer_flush = flanterm_fb_double_buffer_flush;
ffffffff8000294c:	48 c7 83 90 01 00 00 	movq   $0xffffffff80001760,0x190(%rbx)
ffffffff80002953:	60 17 00 80 
    _ctx->full_refresh = flanterm_fb_full_refresh;
ffffffff80002957:	48 c7 83 98 01 00 00 	movq   $0xffffffff800019b0,0x198(%rbx)
ffffffff8000295e:	b0 19 00 80 
    _ctx->deinit = flanterm_fb_deinit;
ffffffff80002962:	48 c7 83 a0 01 00 00 	movq   $0xffffffff80001b00,0x1a0(%rbx)
ffffffff80002969:	00 1b 00 80 
    flanterm_context_reinit(_ctx);
ffffffff8000296d:	e8 6e 04 00 00       	call   ffffffff80002de0 <flanterm_context_reinit>
    flanterm_fb_full_refresh(_ctx);
ffffffff80002972:	48 89 df             	mov    %rbx,%rdi
ffffffff80002975:	e8 36 f0 ff ff       	call   ffffffff800019b0 <flanterm_fb_full_refresh>

#ifndef FLANTERM_FB_DISABLE_BUMP_ALLOC
    if (_malloc == bump_alloc) {
ffffffff8000297a:	49 81 ff 00 10 00 80 	cmp    $0xffffffff80001000,%r15
ffffffff80002981:	0f 84 29 04 00 00    	je     ffffffff80002db0 <flanterm_fb_init+0xc50>
    if (ctx != NULL) {
        _free(ctx, sizeof(struct flanterm_fb_context));
    }

    return NULL;
}
ffffffff80002987:	48 83 c4 48          	add    $0x48,%rsp
ffffffff8000298b:	48 89 d8             	mov    %rbx,%rax
ffffffff8000298e:	5b                   	pop    %rbx
ffffffff8000298f:	5d                   	pop    %rbp
ffffffff80002990:	41 5c                	pop    %r12
ffffffff80002992:	41 5d                	pop    %r13
ffffffff80002994:	41 5e                	pop    %r14
ffffffff80002996:	41 5f                	pop    %r15
ffffffff80002998:	c3                   	ret
        if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {
ffffffff80002999:	49 81 fd ff 13 00 00 	cmp    $0x13ff,%r13
ffffffff800029a0:	76 25                	jbe    ffffffff800029c7 <flanterm_fb_init+0x867>
            font_scale_y = 4;
ffffffff800029a2:	48 c7 84 24 10 01 00 	movq   $0x4,0x110(%rsp)
ffffffff800029a9:	00 04 00 00 00 
            font_scale_x = 4;
ffffffff800029ae:	48 c7 84 24 08 01 00 	movq   $0x4,0x108(%rsp)
ffffffff800029b5:	00 04 00 00 00 
        if (width >= (3840 + 3840 / 3) && height >= (2160 + 2160 / 3)) {
ffffffff800029ba:	49 81 fc 3f 0b 00 00 	cmp    $0xb3f,%r12
ffffffff800029c1:	0f 87 2d f8 ff ff    	ja     ffffffff800021f4 <flanterm_fb_init+0x94>
        if (width >= (1920 + 1920 / 3) && height >= (1080 + 1080 / 3)) {
ffffffff800029c7:	49 81 fd ff 09 00 00 	cmp    $0x9ff,%r13
ffffffff800029ce:	0f 97 c2             	seta   %dl
ffffffff800029d1:	31 c0                	xor    %eax,%eax
ffffffff800029d3:	49 81 fc 9f 05 00 00 	cmp    $0x59f,%r12
ffffffff800029da:	0f 97 c0             	seta   %al
ffffffff800029dd:	48 21 d0             	and    %rdx,%rax
ffffffff800029e0:	48 83 c0 01          	add    $0x1,%rax
ffffffff800029e4:	48 89 84 24 08 01 00 	mov    %rax,0x108(%rsp)
ffffffff800029eb:	00 
ffffffff800029ec:	48 89 84 24 10 01 00 	mov    %rax,0x110(%rsp)
ffffffff800029f3:	00 
ffffffff800029f4:	e9 fb f7 ff ff       	jmp    ffffffff800021f4 <flanterm_fb_init+0x94>
ffffffff800029f9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff80002a00:	44 0f b6 20          	movzbl (%rax),%r12d
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff80002a04:	48 83 c1 01          	add    $0x1,%rcx
                    ctx->font_bool[offset] = (glyph[y] & 1);
ffffffff80002a08:	41 83 e4 01          	and    $0x1,%r12d
ffffffff80002a0c:	44 88 61 ff          	mov    %r12b,-0x1(%rcx)
            for (size_t x = 8; x < ctx->font_width; x++) {
ffffffff80002a10:	48 39 f9             	cmp    %rdi,%rcx
ffffffff80002a13:	75 eb                	jne    ffffffff80002a00 <flanterm_fb_init+0x8a0>
ffffffff80002a15:	e9 d6 fb ff ff       	jmp    ffffffff800025f0 <flanterm_fb_init+0x490>
    if (_malloc == bump_alloc) {
ffffffff80002a1a:	49 81 ff 00 10 00 80 	cmp    $0xffffffff80001000,%r15
ffffffff80002a21:	0f 84 a1 03 00 00    	je     ffffffff80002dc8 <flanterm_fb_init+0xc68>
    if (_free == NULL) {
ffffffff80002a27:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a2c:	48 85 c0             	test   %rax,%rax
ffffffff80002a2f:	0f 84 a6 00 00 00    	je     ffffffff80002adb <flanterm_fb_init+0x97b>
    if (ctx->canvas != NULL) {
ffffffff80002a35:	48 8b bb a0 02 00 00 	mov    0x2a0(%rbx),%rdi
ffffffff80002a3c:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a3f:	74 09                	je     ffffffff80002a4a <flanterm_fb_init+0x8ea>
        _free(ctx->canvas, ctx->canvas_size);
ffffffff80002a41:	48 8b b3 98 02 00 00 	mov    0x298(%rbx),%rsi
ffffffff80002a48:	ff d0                	call   *%rax
    if (ctx->map != NULL) {
ffffffff80002a4a:	48 8b bb d8 02 00 00 	mov    0x2d8(%rbx),%rdi
ffffffff80002a51:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a54:	74 0e                	je     ffffffff80002a64 <flanterm_fb_init+0x904>
        _free(ctx->map, ctx->map_size);
ffffffff80002a56:	48 8b b3 b8 02 00 00 	mov    0x2b8(%rbx),%rsi
ffffffff80002a5d:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a62:	ff d0                	call   *%rax
    if (ctx->queue != NULL) {
ffffffff80002a64:	48 8b bb c8 02 00 00 	mov    0x2c8(%rbx),%rdi
ffffffff80002a6b:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a6e:	74 0e                	je     ffffffff80002a7e <flanterm_fb_init+0x91e>
        _free(ctx->queue, ctx->queue_size);
ffffffff80002a70:	48 8b b3 b0 02 00 00 	mov    0x2b0(%rbx),%rsi
ffffffff80002a77:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a7c:	ff d0                	call   *%rax
    if (ctx->grid != NULL) {
ffffffff80002a7e:	48 8b bb c0 02 00 00 	mov    0x2c0(%rbx),%rdi
ffffffff80002a85:	48 85 ff             	test   %rdi,%rdi
ffffffff80002a88:	74 0e                	je     ffffffff80002a98 <flanterm_fb_init+0x938>
        _free(ctx->grid, ctx->grid_size);
ffffffff80002a8a:	48 8b b3 a8 02 00 00 	mov    0x2a8(%rbx),%rsi
ffffffff80002a91:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002a96:	ff d0                	call   *%rax
    if (ctx->font_bool != NULL) {
ffffffff80002a98:	48 8b bb 40 02 00 00 	mov    0x240(%rbx),%rdi
ffffffff80002a9f:	48 85 ff             	test   %rdi,%rdi
ffffffff80002aa2:	74 0e                	je     ffffffff80002ab2 <flanterm_fb_init+0x952>
        _free(ctx->font_bool, ctx->font_bool_size);
ffffffff80002aa4:	48 8b b3 38 02 00 00 	mov    0x238(%rbx),%rsi
ffffffff80002aab:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002ab0:	ff d0                	call   *%rax
    if (ctx->font_bits != NULL) {
ffffffff80002ab2:	48 8b bb 30 02 00 00 	mov    0x230(%rbx),%rdi
ffffffff80002ab9:	48 85 ff             	test   %rdi,%rdi
ffffffff80002abc:	74 0e                	je     ffffffff80002acc <flanterm_fb_init+0x96c>
        _free(ctx->font_bits, ctx->font_bits_size);
ffffffff80002abe:	48 8b b3 28 02 00 00 	mov    0x228(%rbx),%rsi
ffffffff80002ac5:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002aca:	ff d0                	call   *%rax
        _free(ctx, sizeof(struct flanterm_fb_context));
ffffffff80002acc:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80002ad1:	be 20 03 00 00       	mov    $0x320,%esi
ffffffff80002ad6:	48 89 df             	mov    %rbx,%rdi
ffffffff80002ad9:	ff d0                	call   *%rax
        return NULL;
ffffffff80002adb:	31 db                	xor    %ebx,%ebx
ffffffff80002add:	e9 a5 fe ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
ffffffff80002ae2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        if (bump_allocated_instance == true) {
ffffffff80002ae8:	80 3d 12 86 00 00 00 	cmpb   $0x0,0x8612(%rip)        # ffffffff8000b101 <bump_allocated_instance>
ffffffff80002aef:	75 ea                	jne    ffffffff80002adb <flanterm_fb_init+0x97b>
        if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) {
ffffffff80002af1:	49 81 fd 80 07 00 00 	cmp    $0x780,%r13
ffffffff80002af8:	77 20                	ja     ffffffff80002b1a <flanterm_fb_init+0x9ba>
        canvas = NULL;
ffffffff80002afa:	48 c7 84 24 b0 00 00 	movq   $0x0,0xb0(%rsp)
ffffffff80002b01:	00 00 00 00 00 
        _malloc = bump_alloc;
ffffffff80002b06:	49 c7 c7 00 10 00 80 	mov    $0xffffffff80001000,%r15
        if (width > FLANTERM_FB_WIDTH_LIMIT || height > FLANTERM_FB_HEIGHT_LIMIT) {
ffffffff80002b0d:	49 81 fc b0 04 00 00 	cmp    $0x4b0,%r12
ffffffff80002b14:	0f 86 05 f7 ff ff    	jbe    ffffffff8000221f <flanterm_fb_init+0xbf>
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b1a:	ba 80 07 00 00       	mov    $0x780,%edx
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b1f:	4c 89 e0             	mov    %r12,%rax
            size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height;
ffffffff80002b22:	be b0 04 00 00       	mov    $0x4b0,%esi
        canvas = NULL;
ffffffff80002b27:	48 c7 84 24 b0 00 00 	movq   $0x0,0xb0(%rsp)
ffffffff80002b2e:	00 00 00 00 00 
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b33:	49 39 d5             	cmp    %rdx,%r13
        _malloc = bump_alloc;
ffffffff80002b36:	49 c7 c7 00 10 00 80 	mov    $0xffffffff80001000,%r15
            size_t width_limit = width > FLANTERM_FB_WIDTH_LIMIT ? FLANTERM_FB_WIDTH_LIMIT : width;
ffffffff80002b3d:	49 0f 46 d5          	cmovbe %r13,%rdx
            size_t height_limit = height > FLANTERM_FB_HEIGHT_LIMIT ? FLANTERM_FB_HEIGHT_LIMIT : height;
ffffffff80002b41:	49 39 f4             	cmp    %rsi,%r12
ffffffff80002b44:	49 0f 46 f4          	cmovbe %r12,%rsi
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b48:	48 d1 e8             	shr    $1,%rax
ffffffff80002b4b:	49 89 d0             	mov    %rdx,%r8
ffffffff80002b4e:	48 89 f7             	mov    %rsi,%rdi
ffffffff80002b51:	49 d1 e8             	shr    $1,%r8
            height = height_limit;
ffffffff80002b54:	49 89 f4             	mov    %rsi,%r12
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b57:	48 d1 ef             	shr    $1,%rdi
ffffffff80002b5a:	48 29 f8             	sub    %rdi,%rax
ffffffff80002b5d:	48 8b 7c 24 20       	mov    0x20(%rsp),%rdi
ffffffff80002b62:	48 0f af c7          	imul   %rdi,%rax
ffffffff80002b66:	48 8b 7c 24 08       	mov    0x8(%rsp),%rdi
ffffffff80002b6b:	48 01 c7             	add    %rax,%rdi
ffffffff80002b6e:	48 89 f8             	mov    %rdi,%rax
ffffffff80002b71:	4c 89 ef             	mov    %r13,%rdi
            width = width_limit;
ffffffff80002b74:	49 89 d5             	mov    %rdx,%r13
            framebuffer = (uint32_t *)((uintptr_t)framebuffer + ((((height / 2) - (height_limit / 2)) * pitch) + (((width / 2) - (width_limit / 2)) * 4)));
ffffffff80002b77:	48 d1 ef             	shr    $1,%rdi
ffffffff80002b7a:	4c 29 c7             	sub    %r8,%rdi
ffffffff80002b7d:	48 8d 04 b8          	lea    (%rax,%rdi,4),%rax
ffffffff80002b81:	48 89 44 24 08       	mov    %rax,0x8(%rsp)
            height = height_limit;
ffffffff80002b86:	e9 94 f6 ff ff       	jmp    ffffffff8000221f <flanterm_fb_init+0xbf>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002b8b:	bf aa 00 00 00       	mov    $0xaa,%edi
ffffffff80002b90:	89 c1                	mov    %eax,%ecx
ffffffff80002b92:	41 b8 55 00 00 00    	mov    $0x55,%r8d
        ctx->ansi_colours[0] = convert_colour(_ctx, 0x00000000); // black
ffffffff80002b98:	c7 83 48 02 00 00 00 	movl   $0x0,0x248(%rbx)
ffffffff80002b9f:	00 00 00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002ba2:	41 89 f9             	mov    %edi,%r9d
ffffffff80002ba5:	41 89 fa             	mov    %edi,%r10d
ffffffff80002ba8:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002bab:	89 d1                	mov    %edx,%ecx
ffffffff80002bad:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002bb0:	41 d3 e2             	shl    %cl,%r10d
        ctx->ansi_colours[1] = convert_colour(_ctx, 0x00aa0000); // red
ffffffff80002bb3:	44 89 8b 4c 02 00 00 	mov    %r9d,0x24c(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bba:	44 89 c1             	mov    %r8d,%ecx
        ctx->ansi_colours[2] = convert_colour(_ctx, 0x0000aa00); // green
ffffffff80002bbd:	44 89 93 50 02 00 00 	mov    %r10d,0x250(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bc4:	44 09 c9             	or     %r9d,%ecx
ffffffff80002bc7:	89 8b 54 02 00 00    	mov    %ecx,0x254(%rbx)
ffffffff80002bcd:	89 f1                	mov    %esi,%ecx
ffffffff80002bcf:	d3 e7                	shl    %cl,%edi
ffffffff80002bd1:	89 f9                	mov    %edi,%ecx
        ctx->ansi_colours[4] = convert_colour(_ctx, 0x000000aa); // blue
ffffffff80002bd3:	89 bb 58 02 00 00    	mov    %edi,0x258(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bd9:	44 09 d7             	or     %r10d,%edi
ffffffff80002bdc:	44 09 c9             	or     %r9d,%ecx
        ctx->ansi_colours[6] = convert_colour(_ctx, 0x0000aaaa); // cyan
ffffffff80002bdf:	89 bb 60 02 00 00    	mov    %edi,0x260(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002be5:	44 09 cf             	or     %r9d,%edi
    if (ansi_bright_colours != NULL) {
ffffffff80002be8:	48 83 bc 24 c0 00 00 	cmpq   $0x0,0xc0(%rsp)
ffffffff80002bef:	00 00 
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002bf1:	89 8b 5c 02 00 00    	mov    %ecx,0x25c(%rbx)
ffffffff80002bf7:	89 bb 64 02 00 00    	mov    %edi,0x264(%rbx)
    if (ansi_bright_colours != NULL) {
ffffffff80002bfd:	0f 85 12 f7 ff ff    	jne    ffffffff80002315 <flanterm_fb_init+0x1b5>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002c03:	bf 55 00 00 00       	mov    $0x55,%edi
ffffffff80002c08:	41 b8 ff 00 00 00    	mov    $0xff,%r8d
ffffffff80002c0e:	89 c1                	mov    %eax,%ecx
ffffffff80002c10:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002c13:	41 89 fb             	mov    %edi,%r11d
ffffffff80002c16:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002c19:	41 d3 e3             	shl    %cl,%r11d
ffffffff80002c1c:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c20:	4c 89 d9             	mov    %r11,%rcx
ffffffff80002c23:	41 89 fb             	mov    %edi,%r11d
ffffffff80002c26:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c29:	49 89 ca             	mov    %rcx,%r10
ffffffff80002c2c:	89 d1                	mov    %edx,%ecx
ffffffff80002c2e:	41 d3 e3             	shl    %cl,%r11d
ffffffff80002c31:	4d 89 d9             	mov    %r11,%r9
ffffffff80002c34:	4c 89 d9             	mov    %r11,%rcx
ffffffff80002c37:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c3b:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c3e:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002c41:	4c 09 d1             	or     %r10,%rcx
ffffffff80002c44:	49 89 cb             	mov    %rcx,%r11
ffffffff80002c47:	89 d1                	mov    %edx,%ecx
ffffffff80002c49:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002c4c:	4c 89 c9             	mov    %r9,%rcx
ffffffff80002c4f:	49 c1 e1 20          	shl    $0x20,%r9
ffffffff80002c53:	4c 09 c9             	or     %r9,%rcx
ffffffff80002c56:	4c 09 d1             	or     %r10,%rcx
ffffffff80002c59:	49 89 c9             	mov    %rcx,%r9
ffffffff80002c5c:	89 f1                	mov    %esi,%ecx
ffffffff80002c5e:	d3 e7                	shl    %cl,%edi
ffffffff80002c60:	48 89 f9             	mov    %rdi,%rcx
ffffffff80002c63:	48 c1 e1 20          	shl    $0x20,%rcx
ffffffff80002c67:	48 09 cf             	or     %rcx,%rdi
ffffffff80002c6a:	89 f1                	mov    %esi,%ecx
ffffffff80002c6c:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002c6f:	4c 89 c1             	mov    %r8,%rcx
ffffffff80002c72:	48 c1 e1 20          	shl    $0x20,%rcx
ffffffff80002c76:	4c 09 c1             	or     %r8,%rcx
ffffffff80002c79:	4d 89 d8             	mov    %r11,%r8
ffffffff80002c7c:	49 09 f8             	or     %rdi,%r8
ffffffff80002c7f:	4c 09 cf             	or     %r9,%rdi
        ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black
ffffffff80002c82:	48 89 bb 70 02 00 00 	mov    %rdi,0x270(%rbx)
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002c89:	4c 89 df             	mov    %r11,%rdi
ffffffff80002c8c:	48 09 cf             	or     %rcx,%rdi
ffffffff80002c8f:	4c 09 c9             	or     %r9,%rcx
        ctx->ansi_bright_colours[0] = convert_colour(_ctx, 0x00555555); // black
ffffffff80002c92:	4c 89 83 68 02 00 00 	mov    %r8,0x268(%rbx)
ffffffff80002c99:	48 89 bb 78 02 00 00 	mov    %rdi,0x278(%rbx)
ffffffff80002ca0:	48 89 8b 80 02 00 00 	mov    %rcx,0x280(%rbx)
ffffffff80002ca7:	e9 b8 f6 ff ff       	jmp    ffffffff80002364 <flanterm_fb_init+0x204>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002cac:	bf ff 00 00 00       	mov    $0xff,%edi
ffffffff80002cb1:	89 d1                	mov    %edx,%ecx
ffffffff80002cb3:	41 89 f8             	mov    %edi,%r8d
ffffffff80002cb6:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cb9:	89 f1                	mov    %esi,%ecx
ffffffff80002cbb:	44 89 c2             	mov    %r8d,%edx
ffffffff80002cbe:	41 89 f8             	mov    %edi,%r8d
ffffffff80002cc1:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cc4:	89 c1                	mov    %eax,%ecx
ffffffff80002cc6:	44 09 c2             	or     %r8d,%edx
ffffffff80002cc9:	d3 e7                	shl    %cl,%edi
ffffffff80002ccb:	09 fa                	or     %edi,%edx
ffffffff80002ccd:	e9 ab f7 ff ff       	jmp    ffffffff8000247d <flanterm_fb_init+0x31d>
ffffffff80002cd2:	41 b8 55 00 00 00    	mov    $0x55,%r8d
ffffffff80002cd8:	89 d1                	mov    %edx,%ecx
ffffffff80002cda:	45 89 c1             	mov    %r8d,%r9d
ffffffff80002cdd:	44 89 c7             	mov    %r8d,%edi
ffffffff80002ce0:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002ce3:	89 f1                	mov    %esi,%ecx
ffffffff80002ce5:	d3 e7                	shl    %cl,%edi
ffffffff80002ce7:	89 c1                	mov    %eax,%ecx
ffffffff80002ce9:	44 09 cf             	or     %r9d,%edi
ffffffff80002cec:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002cef:	44 09 c7             	or     %r8d,%edi
ffffffff80002cf2:	e9 40 f7 ff ff       	jmp    ffffffff80002437 <flanterm_fb_init+0x2d7>
        ctx->font_width = font_width = 8;
ffffffff80002cf7:	48 c7 83 b8 01 00 00 	movq   $0x8,0x1b8(%rbx)
ffffffff80002cfe:	08 00 00 00 
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff80002d02:	bf 00 10 00 00       	mov    $0x1000,%edi
        ctx->font_height = font_height = 16;
ffffffff80002d07:	48 c7 83 c0 01 00 00 	movq   $0x10,0x1c0(%rbx)
ffffffff80002d0e:	10 00 00 00 
        ctx->font_bits_size = FONT_BYTES;
ffffffff80002d12:	48 c7 83 28 02 00 00 	movq   $0x1000,0x228(%rbx)
ffffffff80002d19:	00 10 00 00 
        ctx->font_bits = _malloc(ctx->font_bits_size);
ffffffff80002d1d:	41 ff d7             	call   *%r15
ffffffff80002d20:	48 89 83 30 02 00 00 	mov    %rax,0x230(%rbx)
ffffffff80002d27:	48 89 c7             	mov    %rax,%rdi
        if (ctx->font_bits == NULL) {
ffffffff80002d2a:	48 85 c0             	test   %rax,%rax
ffffffff80002d2d:	0f 84 e7 fc ff ff    	je     ffffffff80002a1a <flanterm_fb_init+0x8ba>
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
ffffffff80002d33:	48 8b 93 28 02 00 00 	mov    0x228(%rbx),%rdx
ffffffff80002d3a:	48 c7 c6 00 70 00 80 	mov    $0xffffffff80007000,%rsi
        ctx->font_height = font_height = 16;
ffffffff80002d41:	bd 10 00 00 00       	mov    $0x10,%ebp
        memcpy(ctx->font_bits, builtin_font, ctx->font_bits_size);
ffffffff80002d46:	e8 f5 39 00 00       	call   ffffffff80006740 <memcpy>
        font_spacing = 1;
ffffffff80002d4b:	48 c7 84 24 00 01 00 	movq   $0x1,0x100(%rsp)
ffffffff80002d52:	00 01 00 00 00 
ffffffff80002d57:	e9 c3 f7 ff ff       	jmp    ffffffff8000251f <flanterm_fb_init+0x3bf>
    return (r << ctx->red_mask_shift) | (g << ctx->green_mask_shift) | (b << ctx->blue_mask_shift);
ffffffff80002d5c:	bf aa 00 00 00       	mov    $0xaa,%edi
ffffffff80002d61:	89 d1                	mov    %edx,%ecx
ffffffff80002d63:	41 89 f9             	mov    %edi,%r9d
ffffffff80002d66:	41 89 f8             	mov    %edi,%r8d
ffffffff80002d69:	41 d3 e1             	shl    %cl,%r9d
ffffffff80002d6c:	89 f1                	mov    %esi,%ecx
ffffffff80002d6e:	41 d3 e0             	shl    %cl,%r8d
ffffffff80002d71:	89 c1                	mov    %eax,%ecx
ffffffff80002d73:	45 09 c8             	or     %r9d,%r8d
ffffffff80002d76:	d3 e7                	shl    %cl,%edi
ffffffff80002d78:	41 09 f8             	or     %edi,%r8d
ffffffff80002d7b:	45 89 c2             	mov    %r8d,%r10d
ffffffff80002d7e:	e9 6a f6 ff ff       	jmp    ffffffff800023ed <flanterm_fb_init+0x28d>
    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002d83:	48 83 bc 24 10 01 00 	cmpq   $0x1,0x110(%rsp)
ffffffff80002d8a:	00 01 
ffffffff80002d8c:	75 16                	jne    ffffffff80002da4 <flanterm_fb_init+0xc44>
ffffffff80002d8e:	48 83 bc 24 08 01 00 	cmpq   $0x1,0x108(%rsp)
ffffffff80002d95:	00 01 
ffffffff80002d97:	48 c7 c0 c0 1e 00 80 	mov    $0xffffffff80001ec0,%rax
ffffffff80002d9e:	0f 84 c2 fa ff ff    	je     ffffffff80002866 <flanterm_fb_init+0x706>
ffffffff80002da4:	48 c7 c0 e0 1f 00 80 	mov    $0xffffffff80001fe0,%rax
ffffffff80002dab:	e9 b6 fa ff ff       	jmp    ffffffff80002866 <flanterm_fb_init+0x706>
        bump_allocated_instance = true;
ffffffff80002db0:	c6 05 4a 83 00 00 01 	movb   $0x1,0x834a(%rip)        # ffffffff8000b101 <bump_allocated_instance>
ffffffff80002db7:	e9 cb fb ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
    if (font_scale_x == 1 && font_scale_y == 1) {
ffffffff80002dbc:	48 c7 c0 c0 1b 00 80 	mov    $0xffffffff80001bc0,%rax
ffffffff80002dc3:	e9 9e fa ff ff       	jmp    ffffffff80002866 <flanterm_fb_init+0x706>
        bump_alloc_ptr = 0;
ffffffff80002dc8:	48 c7 05 35 83 00 00 	movq   $0x0,0x8335(%rip)        # ffffffff8000b108 <bump_alloc_ptr>
ffffffff80002dcf:	00 00 00 00 
        return NULL;
ffffffff80002dd3:	31 db                	xor    %ebx,%ebx
ffffffff80002dd5:	e9 ad fb ff ff       	jmp    ffffffff80002987 <flanterm_fb_init+0x827>
ffffffff80002dda:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80002de0 <flanterm_context_reinit>:
};

#define CHARSET_DEFAULT 0
#define CHARSET_DEC_SPECIAL 1

void flanterm_context_reinit(struct flanterm_context *ctx) {
ffffffff80002de0:	f3 0f 1e fa          	endbr64
    ctx->rrr = false;
    ctx->discard_next = false;
    ctx->bold = false;
    ctx->bg_bold = false;
    ctx->reverse_video = false;
    ctx->dec_private = false;
ffffffff80002de4:	0f b7 05 b5 7b 00 00 	movzwl 0x7bb5(%rip),%eax        # ffffffff8000a9a0 <col256+0x3c0>
    ctx->tab_size = 8;
ffffffff80002deb:	48 c7 07 08 00 00 00 	movq   $0x8,(%rdi)
    ctx->autoflush = true;
ffffffff80002df2:	48 c7 47 08 01 01 01 	movq   $0x10101,0x8(%rdi)
ffffffff80002df9:	00 
    ctx->dec_private = false;
ffffffff80002dfa:	66 89 47 14          	mov    %ax,0x14(%rdi)
    ctx->insert_mode = false;
    ctx->unicode_remaining = 0;
    ctx->g_select = 0;
ffffffff80002dfe:	66 89 47 28          	mov    %ax,0x28(%rdi)
    ctx->saved_cursor_x = 0;
    ctx->saved_cursor_y = 0;
    ctx->current_primary = (size_t)-1;
    ctx->current_bg = (size_t)-1;
    ctx->scroll_top_margin = 0;
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80002e02:	48 8b 87 e0 00 00 00 	mov    0xe0(%rdi),%rax
    ctx->discard_next = false;
ffffffff80002e09:	c7 47 10 00 00 00 00 	movl   $0x0,0x10(%rdi)
    ctx->unicode_remaining = 0;
ffffffff80002e10:	48 c7 47 20 00 00 00 	movq   $0x0,0x20(%rdi)
ffffffff80002e17:	00 
    ctx->charsets[1] = CHARSET_DEC_SPECIAL;
ffffffff80002e18:	c6 47 2a 01          	movb   $0x1,0x2a(%rdi)
    ctx->current_charset = 0;
ffffffff80002e1c:	48 c7 47 30 00 00 00 	movq   $0x0,0x30(%rdi)
ffffffff80002e23:	00 
    ctx->escape_offset = 0;
ffffffff80002e24:	48 c7 47 38 00 00 00 	movq   $0x0,0x38(%rdi)
ffffffff80002e2b:	00 
    ctx->esc_values_i = 0;
ffffffff80002e2c:	48 c7 47 40 00 00 00 	movq   $0x0,0x40(%rdi)
ffffffff80002e33:	00 
    ctx->saved_cursor_x = 0;
ffffffff80002e34:	48 c7 47 48 00 00 00 	movq   $0x0,0x48(%rdi)
ffffffff80002e3b:	00 
    ctx->saved_cursor_y = 0;
ffffffff80002e3c:	48 c7 47 50 00 00 00 	movq   $0x0,0x50(%rdi)
ffffffff80002e43:	00 
    ctx->current_primary = (size_t)-1;
ffffffff80002e44:	48 c7 47 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rdi)
ffffffff80002e4b:	ff 
    ctx->current_bg = (size_t)-1;
ffffffff80002e4c:	48 c7 47 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rdi)
ffffffff80002e53:	ff 
    ctx->scroll_top_margin = 0;
ffffffff80002e54:	48 c7 47 68 00 00 00 	movq   $0x0,0x68(%rdi)
ffffffff80002e5b:	00 
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80002e5c:	48 89 47 70          	mov    %rax,0x70(%rdi)
    ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;
ffffffff80002e60:	48 c7 87 b8 00 00 00 	movq   $0x10,0xb8(%rdi)
ffffffff80002e67:	10 00 00 00 
}
ffffffff80002e6b:	c3                   	ret
ffffffff80002e6c:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80002e70 <mk_wcwidth>:
  }

  return 0;
}

int mk_wcwidth(uint32_t ucs) {
ffffffff80002e70:	f3 0f 1e fa          	endbr64
ffffffff80002e74:	89 fa                	mov    %edi,%edx
    { 0xE0100, 0xE01EF }
  };

  /* test for 8-bit control characters */
  if (ucs == 0)
    return 0;
ffffffff80002e76:	31 c0                	xor    %eax,%eax
  if (ucs == 0)
ffffffff80002e78:	85 ff                	test   %edi,%edi
ffffffff80002e7a:	74 71                	je     ffffffff80002eed <mk_wcwidth+0x7d>
  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
ffffffff80002e7c:	8d 47 81             	lea    -0x7f(%rdi),%eax
ffffffff80002e7f:	83 f8 20             	cmp    $0x20,%eax
    return 1;
ffffffff80002e82:	b8 01 00 00 00       	mov    $0x1,%eax
  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
ffffffff80002e87:	76 67                	jbe    ffffffff80002ef0 <mk_wcwidth+0x80>
ffffffff80002e89:	83 ff 1f             	cmp    $0x1f,%edi
ffffffff80002e8c:	76 62                	jbe    ffffffff80002ef0 <mk_wcwidth+0x80>
  if (ucs < table[0].first || ucs > table[max].last)
ffffffff80002e8e:	81 ff ff 02 00 00    	cmp    $0x2ff,%edi
ffffffff80002e94:	76 57                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
ffffffff80002e96:	81 ff ef 01 0e 00    	cmp    $0xe01ef,%edi
ffffffff80002e9c:	0f 87 be 00 00 00    	ja     ffffffff80002f60 <mk_wcwidth+0xf0>
  int min = 0;
ffffffff80002ea2:	31 f6                	xor    %esi,%esi
ffffffff80002ea4:	bf 8d 00 00 00       	mov    $0x8d,%edi
ffffffff80002ea9:	eb 0c                	jmp    ffffffff80002eb7 <mk_wcwidth+0x47>
ffffffff80002eab:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
      min = mid + 1;
ffffffff80002eb0:	8d 70 01             	lea    0x1(%rax),%esi
  while (max >= min) {
ffffffff80002eb3:	39 f7                	cmp    %esi,%edi
ffffffff80002eb5:	7c 41                	jl     ffffffff80002ef8 <mk_wcwidth+0x88>
    mid = (min + max) / 2;
ffffffff80002eb7:	8d 0c 37             	lea    (%rdi,%rsi,1),%ecx
ffffffff80002eba:	89 c8                	mov    %ecx,%eax
ffffffff80002ebc:	c1 e8 1f             	shr    $0x1f,%eax
ffffffff80002ebf:	01 c8                	add    %ecx,%eax
ffffffff80002ec1:	d1 f8                	sar    $1,%eax
    if (ucs > table[mid].last)
ffffffff80002ec3:	48 63 c8             	movslq %eax,%rcx
ffffffff80002ec6:	39 14 cd 64 a1 00 80 	cmp    %edx,-0x7fff5e9c(,%rcx,8)
ffffffff80002ecd:	72 e1                	jb     ffffffff80002eb0 <mk_wcwidth+0x40>
    else if (ucs < table[mid].first)
ffffffff80002ecf:	3b 14 cd 60 a1 00 80 	cmp    -0x7fff5ea0(,%rcx,8),%edx
ffffffff80002ed6:	0f 83 d4 00 00 00    	jae    ffffffff80002fb0 <mk_wcwidth+0x140>
      max = mid - 1;
ffffffff80002edc:	8d 78 ff             	lea    -0x1(%rax),%edi
ffffffff80002edf:	eb d2                	jmp    ffffffff80002eb3 <mk_wcwidth+0x43>
ffffffff80002ee1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
ffffffff80002ee8:	b8 01 00 00 00       	mov    $0x1,%eax
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
      (ucs >= 0x20000 && ucs <= 0x2fffd) ||
      (ucs >= 0x30000 && ucs <= 0x3fffd)));
}
ffffffff80002eed:	c3                   	ret
ffffffff80002eee:	66 90                	xchg   %ax,%ax
ffffffff80002ef0:	c3                   	ret
ffffffff80002ef1:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    (ucs >= 0x1100 &&
ffffffff80002ef8:	81 fa ff 10 00 00    	cmp    $0x10ff,%edx
ffffffff80002efe:	76 e8                	jbe    ffffffff80002ee8 <mk_wcwidth+0x78>
      ucs == 0x2329 || ucs == 0x232a ||
ffffffff80002f00:	8d 82 d7 dc ff ff    	lea    -0x2329(%rdx),%eax
ffffffff80002f06:	83 f8 01             	cmp    $0x1,%eax
ffffffff80002f09:	76 08                	jbe    ffffffff80002f13 <mk_wcwidth+0xa3>
ffffffff80002f0b:	81 fa 5f 11 00 00    	cmp    $0x115f,%edx
ffffffff80002f11:	77 06                	ja     ffffffff80002f19 <mk_wcwidth+0xa9>
ffffffff80002f13:	b8 02 00 00 00       	mov    $0x2,%eax
ffffffff80002f18:	c3                   	ret
      (ucs >= 0x2e80 && ucs <= 0xa4cf &&
ffffffff80002f19:	8d 82 80 d1 ff ff    	lea    -0x2e80(%rdx),%eax
      ucs == 0x2329 || ucs == 0x232a ||
ffffffff80002f1f:	3d 4f 76 00 00       	cmp    $0x764f,%eax
ffffffff80002f24:	77 08                	ja     ffffffff80002f2e <mk_wcwidth+0xbe>
ffffffff80002f26:	81 fa 3f 30 00 00    	cmp    $0x303f,%edx
ffffffff80002f2c:	75 e5                	jne    ffffffff80002f13 <mk_wcwidth+0xa3>
      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
ffffffff80002f2e:	8d 8a 00 54 ff ff    	lea    -0xac00(%rdx),%ecx
ffffffff80002f34:	b8 02 00 00 00       	mov    $0x2,%eax
       ucs != 0x303f) ||                  /* CJK ... Yi */
ffffffff80002f39:	81 f9 a3 2b 00 00    	cmp    $0x2ba3,%ecx
ffffffff80002f3f:	76 ac                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
ffffffff80002f41:	8d 8a 00 07 ff ff    	lea    -0xf900(%rdx),%ecx
      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
ffffffff80002f47:	81 f9 ff 01 00 00    	cmp    $0x1ff,%ecx
ffffffff80002f4d:	76 9e                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
ffffffff80002f4f:	8d 8a f0 01 ff ff    	lea    -0xfe10(%rdx),%ecx
      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
ffffffff80002f55:	83 f9 09             	cmp    $0x9,%ecx
ffffffff80002f58:	76 93                	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
ffffffff80002f5a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
ffffffff80002f60:	8d 8a d0 01 ff ff    	lea    -0xfe30(%rdx),%ecx
ffffffff80002f66:	b8 02 00 00 00       	mov    $0x2,%eax
      (ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
ffffffff80002f6b:	83 f9 3f             	cmp    $0x3f,%ecx
ffffffff80002f6e:	0f 86 79 ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
ffffffff80002f74:	8d 8a 00 01 ff ff    	lea    -0xff00(%rdx),%ecx
      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
ffffffff80002f7a:	83 f9 60             	cmp    $0x60,%ecx
ffffffff80002f7d:	0f 86 6a ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
ffffffff80002f83:	8d 8a 20 00 ff ff    	lea    -0xffe0(%rdx),%ecx
      (ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
ffffffff80002f89:	83 f9 06             	cmp    $0x6,%ecx
ffffffff80002f8c:	0f 86 5b ff ff ff    	jbe    ffffffff80002eed <mk_wcwidth+0x7d>
      (ucs >= 0xffe0 && ucs <= 0xffe6) ||
ffffffff80002f92:	89 d0                	mov    %edx,%eax
ffffffff80002f94:	25 ff ff fe ff       	and    $0xfffeffff,%eax
ffffffff80002f99:	2d 00 00 02 00       	sub    $0x20000,%eax
ffffffff80002f9e:	3d fd ff 00 00       	cmp    $0xfffd,%eax
ffffffff80002fa3:	0f 96 c0             	setbe  %al
ffffffff80002fa6:	0f b6 c0             	movzbl %al,%eax
  return 1 +
ffffffff80002fa9:	83 c0 01             	add    $0x1,%eax
ffffffff80002fac:	c3                   	ret
ffffffff80002fad:	0f 1f 00             	nopl   (%rax)
    return 0;
ffffffff80002fb0:	31 c0                	xor    %eax,%eax
ffffffff80002fb2:	c3                   	ret
ffffffff80002fb3:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80002fba:	00 00 00 
ffffffff80002fbd:	0f 1f 00             	nopl   (%rax)

ffffffff80002fc0 <flanterm_write>:
void flanterm_write(struct flanterm_context *ctx, const char *buf, size_t count) {
ffffffff80002fc0:	f3 0f 1e fa          	endbr64
ffffffff80002fc4:	41 57                	push   %r15
ffffffff80002fc6:	41 56                	push   %r14
ffffffff80002fc8:	41 55                	push   %r13
ffffffff80002fca:	4c 8d 2c 16          	lea    (%rsi,%rdx,1),%r13
ffffffff80002fce:	41 54                	push   %r12
ffffffff80002fd0:	55                   	push   %rbp
ffffffff80002fd1:	48 89 f5             	mov    %rsi,%rbp
ffffffff80002fd4:	53                   	push   %rbx
ffffffff80002fd5:	48 89 fb             	mov    %rdi,%rbx
ffffffff80002fd8:	48 83 ec 28          	sub    $0x28,%rsp
    for (size_t i = 0; i < count; i++) {
ffffffff80002fdc:	48 85 d2             	test   %rdx,%rdx
ffffffff80002fdf:	0f 84 bf 00 00 00    	je     ffffffff800030a4 <flanterm_write+0xe4>
ffffffff80002fe5:	0f 1f 00             	nopl   (%rax)

    return -1;
}

static void flanterm_putchar(struct flanterm_context *ctx, uint8_t c) {
    if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {
ffffffff80002fe8:	80 7b 10 00          	cmpb   $0x0,0x10(%rbx)
        flanterm_putchar(ctx, buf[i]);
ffffffff80002fec:	44 0f b6 65 00       	movzbl 0x0(%rbp),%r12d
    if (ctx->discard_next || (c == 0x18 || c == 0x1a)) {
ffffffff80002ff1:	0f 85 89 00 00 00    	jne    ffffffff80003080 <flanterm_write+0xc0>
ffffffff80002ff7:	44 89 e0             	mov    %r12d,%eax
ffffffff80002ffa:	83 e0 fd             	and    $0xfffffffd,%eax
ffffffff80002ffd:	3c 18                	cmp    $0x18,%al
ffffffff80002fff:	74 7f                	je     ffffffff80003080 <flanterm_write+0xc0>
        ctx->osc_escape = false;
        ctx->g_select = 0;
        return;
    }

    if (ctx->unicode_remaining != 0) {
ffffffff80003001:	48 8b 43 20          	mov    0x20(%rbx),%rax
ffffffff80003005:	48 85 c0             	test   %rax,%rax
ffffffff80003008:	74 17                	je     ffffffff80003021 <flanterm_write+0x61>
        if ((c & 0xc0) != 0x80) {
ffffffff8000300a:	44 89 e2             	mov    %r12d,%edx
ffffffff8000300d:	83 e2 c0             	and    $0xffffffc0,%edx
ffffffff80003010:	80 fa 80             	cmp    $0x80,%dl
ffffffff80003013:	0f 84 f7 00 00 00    	je     ffffffff80003110 <flanterm_write+0x150>
            ctx->unicode_remaining = 0;
ffffffff80003019:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff80003020:	00 
        }
        return;
    }

unicode_error:
    if (c >= 0xc0 && c <= 0xf7) {
ffffffff80003021:	41 8d 44 24 40       	lea    0x40(%r12),%eax
ffffffff80003026:	3c 37                	cmp    $0x37,%al
ffffffff80003028:	0f 86 a2 00 00 00    	jbe    ffffffff800030d0 <flanterm_write+0x110>
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
        }
        return;
    }

    if (ctx->escape == true) {
ffffffff8000302e:	80 7b 0c 00          	cmpb   $0x0,0xc(%rbx)
ffffffff80003032:	0f 85 c8 01 00 00    	jne    ffffffff80003200 <flanterm_write+0x240>
        escape_parse(ctx, c);
        return;
    }

    if (ctx->g_select) {
ffffffff80003038:	0f b6 43 28          	movzbl 0x28(%rbx),%eax
ffffffff8000303c:	84 c0                	test   %al,%al
ffffffff8000303e:	0f 85 8c 01 00 00    	jne    ffffffff800031d0 <flanterm_write+0x210>
        ctx->g_select = 0;
        return;
    }

    size_t x, y;
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003044:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
ffffffff80003049:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000304e:	48 89 df             	mov    %rbx,%rdi
ffffffff80003051:	ff 93 08 01 00 00    	call   *0x108(%rbx)

    switch (c) {
ffffffff80003057:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff8000305b:	0f 8f 5f 02 00 00    	jg     ffffffff800032c0 <flanterm_write+0x300>
ffffffff80003061:	45 84 e4             	test   %r12b,%r12b
ffffffff80003064:	0f 88 66 02 00 00    	js     ffffffff800032d0 <flanterm_write+0x310>
ffffffff8000306a:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff8000306e:	0f 87 5c 02 00 00    	ja     ffffffff800032d0 <flanterm_write+0x310>
ffffffff80003074:	41 0f b6 c4          	movzbl %r12b,%eax
ffffffff80003078:	3e ff 24 c5 00 80 00 	notrack jmp *-0x7fff8000(,%rax,8)
ffffffff8000307f:	80 
        ctx->discard_next = false;
ffffffff80003080:	c6 43 10 00          	movb   $0x0,0x10(%rbx)
        ctx->unicode_remaining = 0;
ffffffff80003084:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff8000308b:	00 
        ctx->control_sequence = false;
ffffffff8000308c:	c7 43 0b 00 00 00 00 	movl   $0x0,0xb(%rbx)
        ctx->g_select = 0;
ffffffff80003093:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003097:	48 83 c5 01          	add    $0x1,%rbp
ffffffff8000309b:	49 39 ed             	cmp    %rbp,%r13
ffffffff8000309e:	0f 85 44 ff ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
    if (ctx->autoflush) {
ffffffff800030a4:	80 7b 08 00          	cmpb   $0x0,0x8(%rbx)
ffffffff800030a8:	0f 84 da 00 00 00    	je     ffffffff80003188 <flanterm_write+0x1c8>
        ctx->double_buffer_flush(ctx);
ffffffff800030ae:	48 8b 83 90 01 00 00 	mov    0x190(%rbx),%rax
}
ffffffff800030b5:	48 83 c4 28          	add    $0x28,%rsp
        ctx->double_buffer_flush(ctx);
ffffffff800030b9:	48 89 df             	mov    %rbx,%rdi
}
ffffffff800030bc:	5b                   	pop    %rbx
ffffffff800030bd:	5d                   	pop    %rbp
ffffffff800030be:	41 5c                	pop    %r12
ffffffff800030c0:	41 5d                	pop    %r13
ffffffff800030c2:	41 5e                	pop    %r14
ffffffff800030c4:	41 5f                	pop    %r15
        ctx->double_buffer_flush(ctx);
ffffffff800030c6:	ff e0                	jmp    *%rax
ffffffff800030c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800030cf:	00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800030d0:	41 0f b6 d4          	movzbl %r12b,%edx
        if (c >= 0xc0 && c <= 0xdf) {
ffffffff800030d4:	3c 1f                	cmp    $0x1f,%al
ffffffff800030d6:	0f 86 c4 00 00 00    	jbe    ffffffff800031a0 <flanterm_write+0x1e0>
        } else if (c >= 0xe0 && c <= 0xef) {
ffffffff800030dc:	41 83 c4 20          	add    $0x20,%r12d
ffffffff800030e0:	41 80 fc 0f          	cmp    $0xf,%r12b
ffffffff800030e4:	0f 87 66 01 00 00    	ja     ffffffff80003250 <flanterm_write+0x290>
            ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);
ffffffff800030ea:	48 c1 e2 0c          	shl    $0xc,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff800030ee:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 2;
ffffffff800030f2:	48 c7 43 20 02 00 00 	movq   $0x2,0x20(%rbx)
ffffffff800030f9:	00 
            ctx->code_point = (uint64_t)(c & 0x0f) << (6 * 2);
ffffffff800030fa:	81 e2 ff ff 00 00    	and    $0xffff,%edx
ffffffff80003100:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003104:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003107:	0f 85 db fe ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff8000310d:	eb 95                	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff8000310f:	90                   	nop
        ctx->unicode_remaining--;
ffffffff80003110:	48 83 e8 01          	sub    $0x1,%rax
        ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);
ffffffff80003114:	41 83 e4 3f          	and    $0x3f,%r12d
ffffffff80003118:	8d 0c 40             	lea    (%rax,%rax,2),%ecx
        ctx->unicode_remaining--;
ffffffff8000311b:	48 89 43 20          	mov    %rax,0x20(%rbx)
        ctx->code_point |= (uint64_t)(c & 0x3f) << (6 * ctx->unicode_remaining);
ffffffff8000311f:	01 c9                	add    %ecx,%ecx
ffffffff80003121:	49 d3 e4             	shl    %cl,%r12
ffffffff80003124:	4c 0b 63 18          	or     0x18(%rbx),%r12
ffffffff80003128:	4c 89 63 18          	mov    %r12,0x18(%rbx)
        if (ctx->unicode_remaining != 0) {
ffffffff8000312c:	48 85 c0             	test   %rax,%rax
ffffffff8000312f:	0f 85 62 ff ff ff    	jne    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff80003135:	49 81 fc 48 22 00 00 	cmp    $0x2248,%r12
ffffffff8000313c:	0f 87 3e 01 00 00    	ja     ffffffff80003280 <flanterm_write+0x2c0>
ffffffff80003142:	49 81 fc 18 22 00 00 	cmp    $0x2218,%r12
ffffffff80003149:	0f 87 38 0e 00 00    	ja     ffffffff80003f87 <flanterm_write+0xfc7>
ffffffff8000314f:	49 81 fc 92 01 00 00 	cmp    $0x192,%r12
ffffffff80003156:	0f 87 12 03 00 00    	ja     ffffffff8000346e <flanterm_write+0x4ae>
ffffffff8000315c:	49 81 fc a0 00 00 00 	cmp    $0xa0,%r12
ffffffff80003163:	0f 86 57 02 00 00    	jbe    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003169:	49 8d 84 24 5f ff ff 	lea    -0xa1(%r12),%rax
ffffffff80003170:	ff 
ffffffff80003171:	48 3d f1 00 00 00    	cmp    $0xf1,%rax
ffffffff80003177:	0f 87 43 02 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000317d:	3e ff 24 c5 e0 80 00 	notrack jmp *-0x7fff7f20(,%rax,8)
ffffffff80003184:	80 
ffffffff80003185:	0f 1f 00             	nopl   (%rax)
}
ffffffff80003188:	48 83 c4 28          	add    $0x28,%rsp
ffffffff8000318c:	5b                   	pop    %rbx
ffffffff8000318d:	5d                   	pop    %rbp
ffffffff8000318e:	41 5c                	pop    %r12
ffffffff80003190:	41 5d                	pop    %r13
ffffffff80003192:	41 5e                	pop    %r14
ffffffff80003194:	41 5f                	pop    %r15
ffffffff80003196:	c3                   	ret
ffffffff80003197:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000319e:	00 00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800031a0:	48 c1 e2 06          	shl    $0x6,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff800031a4:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 1;
ffffffff800031a8:	48 c7 43 20 01 00 00 	movq   $0x1,0x20(%rbx)
ffffffff800031af:	00 
            ctx->code_point = (uint64_t)(c & 0x1f) << 6;
ffffffff800031b0:	81 e2 c0 07 00 00    	and    $0x7c0,%edx
ffffffff800031b6:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff800031ba:	49 39 ed             	cmp    %rbp,%r13
ffffffff800031bd:	0f 85 25 fe ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff800031c3:	e9 dc fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff800031c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800031cf:	00 
        ctx->g_select--;
ffffffff800031d0:	83 e8 01             	sub    $0x1,%eax
        switch (c) {
ffffffff800031d3:	41 80 fc 30          	cmp    $0x30,%r12b
ffffffff800031d7:	0f 84 8b 03 00 00    	je     ffffffff80003568 <flanterm_write+0x5a8>
ffffffff800031dd:	41 80 fc 42          	cmp    $0x42,%r12b
ffffffff800031e1:	0f 84 59 01 00 00    	je     ffffffff80003340 <flanterm_write+0x380>
        ctx->g_select = 0;
ffffffff800031e7:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff800031eb:	48 83 c5 01          	add    $0x1,%rbp
ffffffff800031ef:	49 39 ed             	cmp    %rbp,%r13
ffffffff800031f2:	0f 85 f0 fd ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff800031f8:	e9 a7 fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff800031fd:	0f 1f 00             	nopl   (%rax)
    ctx->escape_offset++;
ffffffff80003200:	48 8b 43 38          	mov    0x38(%rbx),%rax
ffffffff80003204:	48 83 c0 01          	add    $0x1,%rax
    if (ctx->osc == true) {
ffffffff80003208:	80 7b 0d 00          	cmpb   $0x0,0xd(%rbx)
    ctx->escape_offset++;
ffffffff8000320c:	48 89 43 38          	mov    %rax,0x38(%rbx)
    if (ctx->osc == true) {
ffffffff80003210:	0f 85 6a 03 00 00    	jne    ffffffff80003580 <flanterm_write+0x5c0>
    if (ctx->control_sequence == true) {
ffffffff80003216:	80 7b 0b 00          	cmpb   $0x0,0xb(%rbx)
ffffffff8000321a:	0f 85 87 03 00 00    	jne    ffffffff800035a7 <flanterm_write+0x5e7>
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003220:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
ffffffff80003225:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000322a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000322d:	ff 93 08 01 00 00    	call   *0x108(%rbx)
    switch (c) {
ffffffff80003233:	41 8d 44 24 d8       	lea    -0x28(%r12),%eax
ffffffff80003238:	3c 3b                	cmp    $0x3b,%al
ffffffff8000323a:	0f 87 18 02 00 00    	ja     ffffffff80003458 <flanterm_write+0x498>
ffffffff80003240:	0f b6 c0             	movzbl %al,%eax
ffffffff80003243:	3e ff 24 c5 70 88 00 	notrack jmp *-0x7fff7790(,%rax,8)
ffffffff8000324a:	80 
ffffffff8000324b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
ffffffff80003250:	48 c1 e2 12          	shl    $0x12,%rdx
    for (size_t i = 0; i < count; i++) {
ffffffff80003254:	48 83 c5 01          	add    $0x1,%rbp
            ctx->unicode_remaining = 3;
ffffffff80003258:	48 c7 43 20 03 00 00 	movq   $0x3,0x20(%rbx)
ffffffff8000325f:	00 
            ctx->code_point = (uint64_t)(c & 0x07) << (6 * 3);
ffffffff80003260:	81 e2 00 00 1c 00    	and    $0x1c0000,%edx
ffffffff80003266:	48 89 53 18          	mov    %rdx,0x18(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff8000326a:	49 39 ed             	cmp    %rbp,%r13
ffffffff8000326d:	0f 85 75 fd ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003273:	e9 2c fe ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
ffffffff80003278:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff8000327f:	00 
    switch (code_point) {
ffffffff80003280:	49 81 fc 6b 26 00 00 	cmp    $0x266b,%r12
ffffffff80003287:	0f 87 33 01 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000328d:	49 81 fc ff 24 00 00 	cmp    $0x24ff,%r12
ffffffff80003294:	0f 86 95 03 00 00    	jbe    ffffffff8000362f <flanterm_write+0x66f>
ffffffff8000329a:	49 8d 84 24 00 db ff 	lea    -0x2500(%r12),%rax
ffffffff800032a1:	ff 
ffffffff800032a2:	48 3d 6b 01 00 00    	cmp    $0x16b,%rax
ffffffff800032a8:	0f 87 12 01 00 00    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff800032ae:	3e ff 24 c5 50 8a 00 	notrack jmp *-0x7fff75b0(,%rax,8)
ffffffff800032b5:	80 
ffffffff800032b6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800032bd:	00 00 00 
    switch (c) {
ffffffff800032c0:	41 80 fc 7f          	cmp    $0x7f,%r12b
ffffffff800032c4:	0f 84 cd fd ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
ffffffff800032ca:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
            // Move to G0 set
            ctx->current_charset = 0;
            return;
    }

    if (ctx->insert_mode == true) {
ffffffff800032d0:	80 7b 15 00          	cmpb   $0x0,0x15(%rbx)
ffffffff800032d4:	74 35                	je     ffffffff8000330b <flanterm_write+0x34b>
        for (size_t i = ctx->cols - 1; ; i--) {
ffffffff800032d6:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff800032dd:	4c 8d 70 ff          	lea    -0x1(%rax),%r14
ffffffff800032e1:	eb 09                	jmp    ffffffff800032ec <flanterm_write+0x32c>
ffffffff800032e3:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff800032e8:	49 83 ee 01          	sub    $0x1,%r14
            ctx->move_character(ctx, i + 1, y, i, y);
ffffffff800032ec:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800032f1:	49 8d 76 01          	lea    0x1(%r14),%rsi
ffffffff800032f5:	4c 89 f1             	mov    %r14,%rcx
ffffffff800032f8:	48 89 df             	mov    %rbx,%rdi
ffffffff800032fb:	49 89 d0             	mov    %rdx,%r8
ffffffff800032fe:	ff 93 60 01 00 00    	call   *0x160(%rbx)
            if (i == x) {
ffffffff80003304:	4c 3b 74 24 10       	cmp    0x10(%rsp),%r14
ffffffff80003309:	75 dd                	jne    ffffffff800032e8 <flanterm_write+0x328>
            }
        }
    }

    // Translate character set
    switch (ctx->charsets[ctx->current_charset]) {
ffffffff8000330b:	48 8b 53 30          	mov    0x30(%rbx),%rdx
        case '`': FLANTERM_DEC_SPCL_PRN(0x04)
ffffffff8000330f:	48 8b 83 f0 00 00 00 	mov    0xf0(%rbx),%rax
    switch (ctx->charsets[ctx->current_charset]) {
ffffffff80003316:	80 7c 13 29 01       	cmpb   $0x1,0x29(%rbx,%rdx,1)
ffffffff8000331b:	0f 84 12 0b 00 00    	je     ffffffff80003e33 <flanterm_write+0xe73>
                return;
            }
            break;
    }

    if (c >= 0x20 && c <= 0x7e) {
ffffffff80003321:	41 8d 54 24 e0       	lea    -0x20(%r12),%edx
ffffffff80003326:	80 fa 5e             	cmp    $0x5e,%dl
ffffffff80003329:	0f 86 be 02 00 00    	jbe    ffffffff800035ed <flanterm_write+0x62d>
        ctx->raw_putchar(ctx, c);
    } else {
        ctx->raw_putchar(ctx, 0xfe);
ffffffff8000332f:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff80003334:	48 89 df             	mov    %rbx,%rdi
ffffffff80003337:	ff d0                	call   *%rax
ffffffff80003339:	e9 59 fd ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff8000333e:	66 90                	xchg   %ax,%ax
                ctx->charsets[ctx->g_select] = CHARSET_DEFAULT; break;
ffffffff80003340:	0f b6 c0             	movzbl %al,%eax
ffffffff80003343:	c6 44 03 29 00       	movb   $0x0,0x29(%rbx,%rax,1)
        ctx->g_select = 0;
ffffffff80003348:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
        return;
ffffffff8000334c:	e9 9a fe ff ff       	jmp    ffffffff800031eb <flanterm_write+0x22b>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003351:	48 8b 43 70          	mov    0x70(%rbx),%rax
ffffffff80003355:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000335a:	48 83 e8 01          	sub    $0x1,%rax
ffffffff8000335e:	48 39 d0             	cmp    %rdx,%rax
ffffffff80003361:	0f 84 92 0a 00 00    	je     ffffffff80003df9 <flanterm_write+0xe39>
                ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y + 1);
ffffffff80003367:	48 8b 83 00 01 00 00 	mov    0x100(%rbx),%rax
ffffffff8000336e:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80003372:	31 f6                	xor    %esi,%esi
ffffffff80003374:	f6 83 b8 00 00 00 10 	testb  $0x10,0xb8(%rbx)
ffffffff8000337b:	75 05                	jne    ffffffff80003382 <flanterm_write+0x3c2>
ffffffff8000337d:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff80003382:	48 89 df             	mov    %rbx,%rdi
ffffffff80003385:	ff d0                	call   *%rax
ffffffff80003387:	e9 0b fd ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff8000338c:	49 81 fc 20 23 00 00 	cmp    $0x2320,%r12
ffffffff80003393:	0f 84 59 0e 00 00    	je     ffffffff800041f2 <flanterm_write+0x1232>
ffffffff80003399:	49 81 fc 21 23 00 00 	cmp    $0x2321,%r12
ffffffff800033a0:	0f 84 42 0e 00 00    	je     ffffffff800041e8 <flanterm_write+0x1228>
        case 0x2310: return 169;
ffffffff800033a6:	be a9 00 00 00       	mov    $0xa9,%esi
    switch (code_point) {
ffffffff800033ab:	49 81 fc 10 23 00 00 	cmp    $0x2310,%r12
ffffffff800033b2:	0f 84 b8 02 00 00    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff800033b8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800033bf:	00 
            size_t replacement_width = (size_t)mk_wcwidth(ctx->code_point);
ffffffff800033c0:	44 89 e7             	mov    %r12d,%edi
ffffffff800033c3:	e8 a8 fa ff ff       	call   ffffffff80002e70 <mk_wcwidth>
ffffffff800033c8:	4c 63 f0             	movslq %eax,%r14
            if (replacement_width > 0) {
ffffffff800033cb:	4d 85 f6             	test   %r14,%r14
ffffffff800033ce:	0f 84 c3 fc ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
                ctx->raw_putchar(ctx, 0xfe);
ffffffff800033d4:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff800033d9:	48 89 df             	mov    %rbx,%rdi
ffffffff800033dc:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 1; i < replacement_width; i++) {
ffffffff800033e2:	49 83 fe 01          	cmp    $0x1,%r14
ffffffff800033e6:	0f 84 ab fc ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
ffffffff800033ec:	41 bc 01 00 00 00    	mov    $0x1,%r12d
ffffffff800033f2:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
ffffffff800033f8:	49 83 c4 01          	add    $0x1,%r12
                ctx->raw_putchar(ctx, ' ');
ffffffff800033fc:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80003401:	48 89 df             	mov    %rbx,%rdi
ffffffff80003404:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 1; i < replacement_width; i++) {
ffffffff8000340a:	4d 39 e6             	cmp    %r12,%r14
ffffffff8000340d:	75 e9                	jne    ffffffff800033f8 <flanterm_write+0x438>
ffffffff8000340f:	e9 83 fc ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    ctx->save_state(ctx);
ffffffff80003414:	48 89 df             	mov    %rbx,%rdi
ffffffff80003417:	ff 93 80 01 00 00    	call   *0x180(%rbx)
    ctx->saved_state_bold = ctx->bold;
ffffffff8000341d:	0f b7 43 11          	movzwl 0x11(%rbx),%eax
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003421:	48 8b 53 58          	mov    0x58(%rbx),%rdx
ffffffff80003425:	48 8b 4b 30          	mov    0x30(%rbx),%rcx
    ctx->saved_state_bold = ctx->bold;
ffffffff80003429:	66 89 83 c0 00 00 00 	mov    %ax,0xc0(%rbx)
    ctx->saved_state_reverse_video = ctx->reverse_video;
ffffffff80003430:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003434:	48 89 8b c8 00 00 00 	mov    %rcx,0xc8(%rbx)
    ctx->saved_state_reverse_video = ctx->reverse_video;
ffffffff8000343b:	88 83 c2 00 00 00    	mov    %al,0xc2(%rbx)
    ctx->saved_state_current_charset = ctx->current_charset;
ffffffff80003441:	48 8b 43 60          	mov    0x60(%rbx),%rax
ffffffff80003445:	48 89 93 d0 00 00 00 	mov    %rdx,0xd0(%rbx)
ffffffff8000344c:	48 89 83 d8 00 00 00 	mov    %rax,0xd8(%rbx)
            break;
ffffffff80003453:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
    for (size_t i = 0; i < count; i++) {
ffffffff80003458:	48 83 c5 01          	add    $0x1,%rbp
    ctx->escape = false;
ffffffff8000345c:	c6 43 0c 00          	movb   $0x0,0xc(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff80003460:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003463:	0f 85 7f fb ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003469:	e9 36 fc ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
    switch (code_point) {
ffffffff8000346e:	49 81 fc c6 03 00 00 	cmp    $0x3c6,%r12
ffffffff80003475:	0f 87 80 01 00 00    	ja     ffffffff800035fb <flanterm_write+0x63b>
ffffffff8000347b:	49 81 fc 92 03 00 00 	cmp    $0x392,%r12
ffffffff80003482:	0f 86 38 ff ff ff    	jbe    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003488:	49 8d 84 24 6d fc ff 	lea    -0x393(%r12),%rax
ffffffff8000348f:	ff 
ffffffff80003490:	48 83 f8 33          	cmp    $0x33,%rax
ffffffff80003494:	0f 87 26 ff ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000349a:	3e ff 24 c5 b0 95 00 	notrack jmp *-0x7fff6a50(,%rax,8)
ffffffff800034a1:	80 
            ctx->set_cursor_pos(ctx, 0, y);
ffffffff800034a2:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800034a7:	31 f6                	xor    %esi,%esi
ffffffff800034a9:	48 89 df             	mov    %rbx,%rdi
ffffffff800034ac:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            return;
ffffffff800034b2:	e9 e0 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->set_cursor_pos(ctx, x - 1, y);
ffffffff800034b7:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800034bc:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800034c1:	48 89 df             	mov    %rbx,%rdi
ffffffff800034c4:	48 8d 70 ff          	lea    -0x1(%rax),%rsi
ffffffff800034c8:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            return;
ffffffff800034ce:	e9 c4 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if ((x / ctx->tab_size + 1) >= ctx->cols) {
ffffffff800034d3:	48 8b 33             	mov    (%rbx),%rsi
ffffffff800034d6:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff800034db:	31 d2                	xor    %edx,%edx
                ctx->set_cursor_pos(ctx, ctx->cols - 1, y);
ffffffff800034dd:	48 8b 8b 00 01 00 00 	mov    0x100(%rbx),%rcx
ffffffff800034e4:	48 8b 7c 24 18       	mov    0x18(%rsp),%rdi
            if ((x / ctx->tab_size + 1) >= ctx->cols) {
ffffffff800034e9:	48 f7 f6             	div    %rsi
ffffffff800034ec:	48 8b 93 e8 00 00 00 	mov    0xe8(%rbx),%rdx
ffffffff800034f3:	48 83 c0 01          	add    $0x1,%rax
ffffffff800034f7:	48 39 d0             	cmp    %rdx,%rax
ffffffff800034fa:	0f 83 22 09 00 00    	jae    ffffffff80003e22 <flanterm_write+0xe62>
            ctx->set_cursor_pos(ctx, (x / ctx->tab_size + 1) * ctx->tab_size, y);
ffffffff80003500:	48 89 fa             	mov    %rdi,%rdx
ffffffff80003503:	48 0f af f0          	imul   %rax,%rsi
ffffffff80003507:	48 89 df             	mov    %rbx,%rdi
ffffffff8000350a:	ff d1                	call   *%rcx
            return;
ffffffff8000350c:	e9 86 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if (ctx->callback != NULL) {
ffffffff80003511:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80003518:	48 85 c0             	test   %rax,%rax
ffffffff8000351b:	0f 84 76 fb ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
                ctx->callback(ctx, FLANTERM_CB_BELL, 0, 0, 0);
ffffffff80003521:	45 31 c0             	xor    %r8d,%r8d
ffffffff80003524:	31 c9                	xor    %ecx,%ecx
ffffffff80003526:	31 d2                	xor    %edx,%edx
ffffffff80003528:	be 14 00 00 00       	mov    $0x14,%esi
ffffffff8000352d:	48 89 df             	mov    %rbx,%rdi
ffffffff80003530:	ff d0                	call   *%rax
ffffffff80003532:	e9 60 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->escape_offset = 0;
ffffffff80003537:	48 c7 43 38 00 00 00 	movq   $0x0,0x38(%rbx)
ffffffff8000353e:	00 
            ctx->escape = true;
ffffffff8000353f:	c6 43 0c 01          	movb   $0x1,0xc(%rbx)
            return;
ffffffff80003543:	e9 4f fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->current_charset = 1;
ffffffff80003548:	48 c7 43 30 01 00 00 	movq   $0x1,0x30(%rbx)
ffffffff8000354f:	00 
            return;
ffffffff80003550:	e9 42 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            ctx->current_charset = 0;
ffffffff80003555:	48 c7 43 30 00 00 00 	movq   $0x0,0x30(%rbx)
ffffffff8000355c:	00 
            return;
ffffffff8000355d:	e9 35 fb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff80003562:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
                ctx->charsets[ctx->g_select] = CHARSET_DEC_SPECIAL; break;
ffffffff80003568:	0f b6 c0             	movzbl %al,%eax
ffffffff8000356b:	c6 44 03 29 01       	movb   $0x1,0x29(%rbx,%rax,1)
        ctx->g_select = 0;
ffffffff80003570:	c6 43 28 00          	movb   $0x0,0x28(%rbx)
        return;
ffffffff80003574:	e9 72 fc ff ff       	jmp    ffffffff800031eb <flanterm_write+0x22b>
ffffffff80003579:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
    if (ctx->osc_escape && c == '\\') {
ffffffff80003580:	41 80 fc 5c          	cmp    $0x5c,%r12b
ffffffff80003584:	75 06                	jne    ffffffff8000358c <flanterm_write+0x5cc>
ffffffff80003586:	80 7b 0e 00          	cmpb   $0x0,0xe(%rbx)
ffffffff8000358a:	75 0a                	jne    ffffffff80003596 <flanterm_write+0x5d6>
    switch (c) {
ffffffff8000358c:	41 80 fc 1b          	cmp    $0x1b,%r12b
ffffffff80003590:	0f 84 5a 08 00 00    	je     ffffffff80003df0 <flanterm_write+0xe30>
    ctx->escape = false;
ffffffff80003596:	45 31 c9             	xor    %r9d,%r9d
    ctx->osc_escape = false;
ffffffff80003599:	c6 43 0e 00          	movb   $0x0,0xe(%rbx)
    ctx->escape = false;
ffffffff8000359d:	66 44 89 4b 0c       	mov    %r9w,0xc(%rbx)
ffffffff800035a2:	e9 f0 fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    if (ctx->escape_offset == 2) {
ffffffff800035a7:	48 83 f8 02          	cmp    $0x2,%rax
ffffffff800035ab:	0f 84 bc 09 00 00    	je     ffffffff80003f6d <flanterm_write+0xfad>
    if (c >= '0' && c <= '9') {
ffffffff800035b1:	41 8d 44 24 d0       	lea    -0x30(%r12),%eax
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff800035b6:	48 8b 53 40          	mov    0x40(%rbx),%rdx
    if (c >= '0' && c <= '9') {
ffffffff800035ba:	3c 09                	cmp    $0x9,%al
ffffffff800035bc:	0f 87 8a 08 00 00    	ja     ffffffff80003e4c <flanterm_write+0xe8c>
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff800035c2:	48 83 fa 10          	cmp    $0x10,%rdx
ffffffff800035c6:	0f 84 cb fa ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
        ctx->esc_values[ctx->esc_values_i] += c - '0';
ffffffff800035cc:	48 83 c2 1c          	add    $0x1c,%rdx
ffffffff800035d0:	45 0f be e4          	movsbl %r12b,%r12d
        ctx->rrr = true;
ffffffff800035d4:	c6 43 0f 01          	movb   $0x1,0xf(%rbx)
        ctx->esc_values[ctx->esc_values_i] *= 10;
ffffffff800035d8:	8b 44 93 08          	mov    0x8(%rbx,%rdx,4),%eax
ffffffff800035dc:	8d 04 80             	lea    (%rax,%rax,4),%eax
        ctx->esc_values[ctx->esc_values_i] += c - '0';
ffffffff800035df:	41 8d 44 44 d0       	lea    -0x30(%r12,%rax,2),%eax
ffffffff800035e4:	89 44 93 08          	mov    %eax,0x8(%rbx,%rdx,4)
        return;
ffffffff800035e8:	e9 aa fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        ctx->raw_putchar(ctx, c);
ffffffff800035ed:	41 0f be f4          	movsbl %r12b,%esi
ffffffff800035f1:	48 89 df             	mov    %rbx,%rdi
ffffffff800035f4:	ff d0                	call   *%rax
ffffffff800035f6:	e9 9c fa ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (code_point) {
ffffffff800035fb:	49 81 fc a8 21 00 00 	cmp    $0x21a8,%r12
ffffffff80003602:	0f 87 b8 fd ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003608:	49 81 fc 8f 21 00 00 	cmp    $0x218f,%r12
ffffffff8000360f:	0f 86 8c 09 00 00    	jbe    ffffffff80003fa1 <flanterm_write+0xfe1>
ffffffff80003615:	49 8d 84 24 70 de ff 	lea    -0x2190(%r12),%rax
ffffffff8000361c:	ff 
ffffffff8000361d:	48 83 f8 18          	cmp    $0x18,%rax
ffffffff80003621:	0f 87 99 fd ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003627:	3e ff 24 c5 50 97 00 	notrack jmp *-0x7fff68b0(,%rax,8)
ffffffff8000362e:	80 
ffffffff8000362f:	49 81 fc 02 23 00 00 	cmp    $0x2302,%r12
ffffffff80003636:	0f 84 0e 0b 00 00    	je     ffffffff8000414a <flanterm_write+0x118a>
ffffffff8000363c:	0f 87 4a fd ff ff    	ja     ffffffff8000338c <flanterm_write+0x3cc>
ffffffff80003642:	49 81 fc 64 22 00 00 	cmp    $0x2264,%r12
ffffffff80003649:	0f 84 2d 0b 00 00    	je     ffffffff8000417c <flanterm_write+0x11bc>
ffffffff8000364f:	49 81 fc 65 22 00 00 	cmp    $0x2265,%r12
ffffffff80003656:	0f 84 16 0b 00 00    	je     ffffffff80004172 <flanterm_write+0x11b2>
        case 0x2261: return 240;
ffffffff8000365c:	be f0 00 00 00       	mov    $0xf0,%esi
    switch (code_point) {
ffffffff80003661:	49 81 fc 61 22 00 00 	cmp    $0x2261,%r12
ffffffff80003668:	0f 85 52 fd ff ff    	jne    ffffffff800033c0 <flanterm_write+0x400>
ffffffff8000366e:	66 90                	xchg   %ax,%ax
    for (size_t i = 0; i < count; i++) {
ffffffff80003670:	48 83 c5 01          	add    $0x1,%rbp
            ctx->raw_putchar(ctx, cc);
ffffffff80003674:	48 89 df             	mov    %rbx,%rdi
ffffffff80003677:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
    for (size_t i = 0; i < count; i++) {
ffffffff8000367d:	49 39 ed             	cmp    %rbp,%r13
ffffffff80003680:	0f 85 62 f9 ff ff    	jne    ffffffff80002fe8 <flanterm_write+0x28>
ffffffff80003686:	e9 19 fa ff ff       	jmp    ffffffff800030a4 <flanterm_write+0xe4>
            ctx->g_select = c - '\'';
ffffffff8000368b:	41 83 ec 27          	sub    $0x27,%r12d
ffffffff8000368f:	44 88 63 28          	mov    %r12b,0x28(%rbx)
            break;
ffffffff80003693:	e9 c0 fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003698:	48 8b 4b 70          	mov    0x70(%rbx),%rcx
ffffffff8000369c:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff800036a1:	48 8d 51 ff          	lea    -0x1(%rcx),%rdx
ffffffff800036a5:	48 39 c2             	cmp    %rax,%rdx
ffffffff800036a8:	0f 84 e9 09 00 00    	je     ffffffff80004097 <flanterm_write+0x10d7>
                ctx->set_cursor_pos(ctx, x, y + 1);
ffffffff800036ae:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800036b3:	48 8d 50 01          	lea    0x1(%rax),%rdx
ffffffff800036b7:	48 89 df             	mov    %rbx,%rdi
ffffffff800036ba:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800036c0:	e9 93 fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    ctx->bold = ctx->saved_state_bold;
ffffffff800036c5:	0f b7 83 c0 00 00 00 	movzwl 0xc0(%rbx),%eax
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036cc:	48 8b 93 d0 00 00 00 	mov    0xd0(%rbx),%rdx
    ctx->restore_state(ctx);
ffffffff800036d3:	48 89 df             	mov    %rbx,%rdi
    ctx->bold = ctx->saved_state_bold;
ffffffff800036d6:	66 89 43 11          	mov    %ax,0x11(%rbx)
    ctx->reverse_video = ctx->saved_state_reverse_video;
ffffffff800036da:	0f b6 83 c2 00 00 00 	movzbl 0xc2(%rbx),%eax
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036e1:	48 89 53 58          	mov    %rdx,0x58(%rbx)
    ctx->reverse_video = ctx->saved_state_reverse_video;
ffffffff800036e5:	88 43 13             	mov    %al,0x13(%rbx)
    ctx->current_charset = ctx->saved_state_current_charset;
ffffffff800036e8:	48 8b 83 c8 00 00 00 	mov    0xc8(%rbx),%rax
ffffffff800036ef:	48 89 43 30          	mov    %rax,0x30(%rbx)
    ctx->current_primary = ctx->saved_state_current_primary;
ffffffff800036f3:	48 8b 83 d8 00 00 00 	mov    0xd8(%rbx),%rax
ffffffff800036fa:	48 89 43 60          	mov    %rax,0x60(%rbx)
    ctx->restore_state(ctx);
ffffffff800036fe:	ff 93 88 01 00 00    	call   *0x188(%rbx)
}
ffffffff80003704:	e9 4f fd ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    ctx->tab_size = 8;
ffffffff80003709:	48 c7 03 08 00 00 00 	movq   $0x8,(%rbx)
            ctx->clear(ctx, true);
ffffffff80003710:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80003715:	48 89 df             	mov    %rbx,%rdi
    ctx->dec_private = false;
ffffffff80003718:	0f b7 05 81 72 00 00 	movzwl 0x7281(%rip),%eax        # ffffffff8000a9a0 <col256+0x3c0>
    ctx->autoflush = true;
ffffffff8000371f:	48 c7 43 08 01 01 01 	movq   $0x10101,0x8(%rbx)
ffffffff80003726:	00 
    ctx->dec_private = false;
ffffffff80003727:	66 89 43 14          	mov    %ax,0x14(%rbx)
    ctx->g_select = 0;
ffffffff8000372b:	66 89 43 28          	mov    %ax,0x28(%rbx)
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff8000372f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
    ctx->discard_next = false;
ffffffff80003736:	c7 43 10 00 00 00 00 	movl   $0x0,0x10(%rbx)
    ctx->unicode_remaining = 0;
ffffffff8000373d:	48 c7 43 20 00 00 00 	movq   $0x0,0x20(%rbx)
ffffffff80003744:	00 
    ctx->charsets[1] = CHARSET_DEC_SPECIAL;
ffffffff80003745:	c6 43 2a 01          	movb   $0x1,0x2a(%rbx)
    ctx->current_charset = 0;
ffffffff80003749:	48 c7 43 30 00 00 00 	movq   $0x0,0x30(%rbx)
ffffffff80003750:	00 
    ctx->escape_offset = 0;
ffffffff80003751:	48 c7 43 38 00 00 00 	movq   $0x0,0x38(%rbx)
ffffffff80003758:	00 
    ctx->esc_values_i = 0;
ffffffff80003759:	48 c7 43 40 00 00 00 	movq   $0x0,0x40(%rbx)
ffffffff80003760:	00 
    ctx->saved_cursor_x = 0;
ffffffff80003761:	48 c7 43 48 00 00 00 	movq   $0x0,0x48(%rbx)
ffffffff80003768:	00 
    ctx->saved_cursor_y = 0;
ffffffff80003769:	48 c7 43 50 00 00 00 	movq   $0x0,0x50(%rbx)
ffffffff80003770:	00 
    ctx->current_primary = (size_t)-1;
ffffffff80003771:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80003778:	ff 
    ctx->current_bg = (size_t)-1;
ffffffff80003779:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80003780:	ff 
    ctx->scroll_top_margin = 0;
ffffffff80003781:	48 c7 43 68 00 00 00 	movq   $0x0,0x68(%rbx)
ffffffff80003788:	00 
    ctx->scroll_bottom_margin = ctx->rows;
ffffffff80003789:	48 89 43 70          	mov    %rax,0x70(%rbx)
    ctx->oob_output = FLANTERM_OOB_OUTPUT_ONLCR;
ffffffff8000378d:	48 c7 83 b8 00 00 00 	movq   $0x10,0xb8(%rbx)
ffffffff80003794:	10 00 00 00 
            ctx->clear(ctx, true);
ffffffff80003798:	ff 93 f8 00 00 00    	call   *0xf8(%rbx)
            break;
ffffffff8000379e:	e9 b5 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            ctx->osc = true;
ffffffff800037a3:	b8 01 00 00 00       	mov    $0x1,%eax
ffffffff800037a8:	66 89 43 0d          	mov    %ax,0xd(%rbx)
            return;
ffffffff800037ac:	e9 e6 f8 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
ffffffff800037b1:	48 8d 43 78          	lea    0x78(%rbx),%rax
ffffffff800037b5:	48 8d 93 b8 00 00 00 	lea    0xb8(%rbx),%rdx
                ctx->esc_values[i] = 0;
ffffffff800037bc:	48 c7 00 00 00 00 00 	movq   $0x0,(%rax)
ffffffff800037c3:	48 83 c0 10          	add    $0x10,%rax
ffffffff800037c7:	48 c7 40 f8 00 00 00 	movq   $0x0,-0x8(%rax)
ffffffff800037ce:	00 
            for (size_t i = 0; i < FLANTERM_MAX_ESC_VALUES; i++)
ffffffff800037cf:	48 39 c2             	cmp    %rax,%rdx
ffffffff800037d2:	75 e8                	jne    ffffffff800037bc <flanterm_write+0x7fc>
            ctx->esc_values_i = 0;
ffffffff800037d4:	48 c7 43 40 00 00 00 	movq   $0x0,0x40(%rbx)
ffffffff800037db:	00 
            ctx->rrr = false;
ffffffff800037dc:	c6 43 0f 00          	movb   $0x0,0xf(%rbx)
            ctx->control_sequence = true;
ffffffff800037e0:	c6 43 0b 01          	movb   $0x1,0xb(%rbx)
            return;
ffffffff800037e4:	e9 ae f8 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            if (ctx->callback != NULL) {
ffffffff800037e9:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800037f0:	48 85 c0             	test   %rax,%rax
ffffffff800037f3:	0f 84 5f fc ff ff    	je     ffffffff80003458 <flanterm_write+0x498>
                ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);
ffffffff800037f9:	45 31 c0             	xor    %r8d,%r8d
ffffffff800037fc:	31 c9                	xor    %ecx,%ecx
ffffffff800037fe:	31 d2                	xor    %edx,%edx
ffffffff80003800:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80003805:	48 89 df             	mov    %rbx,%rdi
ffffffff80003808:	ff d0                	call   *%rax
ffffffff8000380a:	e9 49 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_top_margin) {
ffffffff8000380f:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff80003814:	48 39 43 68          	cmp    %rax,0x68(%rbx)
ffffffff80003818:	0f 84 9a 08 00 00    	je     ffffffff800040b8 <flanterm_write+0x10f8>
                ctx->set_cursor_pos(ctx, 0, y - 1);
ffffffff8000381e:	48 8d 50 ff          	lea    -0x1(%rax),%rdx
ffffffff80003822:	31 f6                	xor    %esi,%esi
ffffffff80003824:	48 89 df             	mov    %rbx,%rdi
ffffffff80003827:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff8000382d:	e9 26 fc ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
            if (y == ctx->scroll_bottom_margin - 1) {
ffffffff80003832:	48 8b 4b 70          	mov    0x70(%rbx),%rcx
ffffffff80003836:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
ffffffff8000383b:	48 8d 51 ff          	lea    -0x1(%rcx),%rdx
ffffffff8000383f:	48 39 c2             	cmp    %rax,%rdx
ffffffff80003842:	0f 84 28 08 00 00    	je     ffffffff80004070 <flanterm_write+0x10b0>
                ctx->set_cursor_pos(ctx, 0, y + 1);
ffffffff80003848:	48 8d 50 01          	lea    0x1(%rax),%rdx
ffffffff8000384c:	31 f6                	xor    %esi,%esi
ffffffff8000384e:	48 89 df             	mov    %rbx,%rdi
ffffffff80003851:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff80003857:	e9 fc fb ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
        case 0x00a2: return 155;
ffffffff8000385c:	be 9b 00 00 00       	mov    $0x9b,%esi
ffffffff80003861:	e9 0a fe ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a1: return 173;
ffffffff80003866:	be ad 00 00 00       	mov    $0xad,%esi
ffffffff8000386b:	e9 00 fe ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b1: return 241;
ffffffff80003870:	be f1 00 00 00       	mov    $0xf1,%esi
ffffffff80003875:	e9 f6 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b0: return 248;
ffffffff8000387a:	be f8 00 00 00       	mov    $0xf8,%esi
ffffffff8000387f:	e9 ec fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ac: return 170;
ffffffff80003884:	be aa 00 00 00       	mov    $0xaa,%esi
ffffffff80003889:	e9 e2 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ab: return 174;
ffffffff8000388e:	be ae 00 00 00       	mov    $0xae,%esi
ffffffff80003893:	e9 d8 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00aa: return 166;
ffffffff80003898:	be a6 00 00 00       	mov    $0xa6,%esi
ffffffff8000389d:	e9 ce fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a5: return 157;
ffffffff800038a2:	be 9d 00 00 00       	mov    $0x9d,%esi
ffffffff800038a7:	e9 c4 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a3: return 156;
ffffffff800038ac:	be 9c 00 00 00       	mov    $0x9c,%esi
ffffffff800038b1:	e9 ba fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2663: return 5;
ffffffff800038b6:	be 05 00 00 00       	mov    $0x5,%esi
ffffffff800038bb:	e9 b0 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2660: return 6;
ffffffff800038c0:	be 06 00 00 00       	mov    $0x6,%esi
ffffffff800038c5:	e9 a6 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2642: return 11;
ffffffff800038ca:	be 0b 00 00 00       	mov    $0xb,%esi
ffffffff800038cf:	e9 9c fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2640: return 12;
ffffffff800038d4:	be 0c 00 00 00       	mov    $0xc,%esi
ffffffff800038d9:	e9 92 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x263c: return 15;
ffffffff800038de:	be 0f 00 00 00       	mov    $0xf,%esi
ffffffff800038e3:	e9 88 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x263b: return 2;
ffffffff800038e8:	be 02 00 00 00       	mov    $0x2,%esi
ffffffff800038ed:	e9 7e fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25d9: return 10;
ffffffff800038f2:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff800038f7:	e9 74 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x266b: return 14;
ffffffff800038fc:	be 0e 00 00 00       	mov    $0xe,%esi
ffffffff80003901:	e9 6a fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x266a: return 13;
ffffffff80003906:	be 0d 00 00 00       	mov    $0xd,%esi
ffffffff8000390b:	e9 60 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2524: return 180;
ffffffff80003910:	be b4 00 00 00       	mov    $0xb4,%esi
ffffffff80003915:	e9 56 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x251c: return 195;
ffffffff8000391a:	be c3 00 00 00       	mov    $0xc3,%esi
ffffffff8000391f:	e9 4c fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2518: return 217;
ffffffff80003924:	be d9 00 00 00       	mov    $0xd9,%esi
ffffffff80003929:	e9 42 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2514: return 192;
ffffffff8000392e:	be c0 00 00 00       	mov    $0xc0,%esi
ffffffff80003933:	e9 38 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2510: return 191;
ffffffff80003938:	be bf 00 00 00       	mov    $0xbf,%esi
ffffffff8000393d:	e9 2e fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x250c: return 218;
ffffffff80003942:	be da 00 00 00       	mov    $0xda,%esi
ffffffff80003947:	e9 24 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2502: return 179;
ffffffff8000394c:	be b3 00 00 00       	mov    $0xb3,%esi
ffffffff80003951:	e9 1a fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2500: return 196;
ffffffff80003956:	be c4 00 00 00       	mov    $0xc4,%esi
ffffffff8000395b:	e9 10 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0192: return 159;
ffffffff80003960:	be 9f 00 00 00       	mov    $0x9f,%esi
ffffffff80003965:	e9 06 fd ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ff: return 152;
ffffffff8000396a:	be 98 00 00 00       	mov    $0x98,%esi
ffffffff8000396f:	e9 fc fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fc: return 129;
ffffffff80003974:	be 81 00 00 00       	mov    $0x81,%esi
ffffffff80003979:	e9 f2 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fb: return 150;
ffffffff8000397e:	be 96 00 00 00       	mov    $0x96,%esi
ffffffff80003983:	e9 e8 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00fa: return 163;
ffffffff80003988:	be a3 00 00 00       	mov    $0xa3,%esi
ffffffff8000398d:	e9 de fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f9: return 151;
ffffffff80003992:	be 97 00 00 00       	mov    $0x97,%esi
ffffffff80003997:	e9 d4 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f7: return 246;
ffffffff8000399c:	be f6 00 00 00       	mov    $0xf6,%esi
ffffffff800039a1:	e9 ca fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f6: return 148;
ffffffff800039a6:	be 94 00 00 00       	mov    $0x94,%esi
ffffffff800039ab:	e9 c0 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f4: return 147;
ffffffff800039b0:	be 93 00 00 00       	mov    $0x93,%esi
ffffffff800039b5:	e9 b6 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f3: return 162;
ffffffff800039ba:	be a2 00 00 00       	mov    $0xa2,%esi
ffffffff800039bf:	e9 ac fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f2: return 149;
ffffffff800039c4:	be 95 00 00 00       	mov    $0x95,%esi
ffffffff800039c9:	e9 a2 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00f1: return 164;
ffffffff800039ce:	be a4 00 00 00       	mov    $0xa4,%esi
ffffffff800039d3:	e9 98 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ef: return 139;
ffffffff800039d8:	be 8b 00 00 00       	mov    $0x8b,%esi
ffffffff800039dd:	e9 8e fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2194: return 29;
ffffffff800039e2:	be 1d 00 00 00       	mov    $0x1d,%esi
ffffffff800039e7:	e9 84 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2193: return 25;
ffffffff800039ec:	be 19 00 00 00       	mov    $0x19,%esi
ffffffff800039f1:	e9 7a fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2192: return 26;
ffffffff800039f6:	be 1a 00 00 00       	mov    $0x1a,%esi
ffffffff800039fb:	e9 70 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2191: return 24;
ffffffff80003a00:	be 18 00 00 00       	mov    $0x18,%esi
ffffffff80003a05:	e9 66 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2190: return 27;
ffffffff80003a0a:	be 1b 00 00 00       	mov    $0x1b,%esi
ffffffff80003a0f:	e9 5c fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ee: return 140;
ffffffff80003a14:	be 8c 00 00 00       	mov    $0x8c,%esi
ffffffff80003a19:	e9 52 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ed: return 161;
ffffffff80003a1e:	be a1 00 00 00       	mov    $0xa1,%esi
ffffffff80003a23:	e9 48 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ec: return 141;
ffffffff80003a28:	be 8d 00 00 00       	mov    $0x8d,%esi
ffffffff80003a2d:	e9 3e fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00eb: return 137;
ffffffff80003a32:	be 89 00 00 00       	mov    $0x89,%esi
ffffffff80003a37:	e9 34 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ea: return 136;
ffffffff80003a3c:	be 88 00 00 00       	mov    $0x88,%esi
ffffffff80003a41:	e9 2a fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e9: return 130;
ffffffff80003a46:	be 82 00 00 00       	mov    $0x82,%esi
ffffffff80003a4b:	e9 20 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e8: return 138;
ffffffff80003a50:	be 8a 00 00 00       	mov    $0x8a,%esi
ffffffff80003a55:	e9 16 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e7: return 135;
ffffffff80003a5a:	be 87 00 00 00       	mov    $0x87,%esi
ffffffff80003a5f:	e9 0c fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e6: return 145;
ffffffff80003a64:	be 91 00 00 00       	mov    $0x91,%esi
ffffffff80003a69:	e9 02 fc ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e5: return 134;
ffffffff80003a6e:	be 86 00 00 00       	mov    $0x86,%esi
ffffffff80003a73:	e9 f8 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e4: return 132;
ffffffff80003a78:	be 84 00 00 00       	mov    $0x84,%esi
ffffffff80003a7d:	e9 ee fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e2: return 131;
ffffffff80003a82:	be 83 00 00 00       	mov    $0x83,%esi
ffffffff80003a87:	e9 e4 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e1: return 160;
ffffffff80003a8c:	be a0 00 00 00       	mov    $0xa0,%esi
ffffffff80003a91:	e9 da fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00e0: return 133;
ffffffff80003a96:	be 85 00 00 00       	mov    $0x85,%esi
ffffffff80003a9b:	e9 d0 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00df: return 225;
ffffffff80003aa0:	be e1 00 00 00       	mov    $0xe1,%esi
ffffffff80003aa5:	e9 c6 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00dc: return 154;
ffffffff80003aaa:	be 9a 00 00 00       	mov    $0x9a,%esi
ffffffff80003aaf:	e9 bc fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00d6: return 153;
ffffffff80003ab4:	be 99 00 00 00       	mov    $0x99,%esi
ffffffff80003ab9:	e9 b2 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00d1: return 165;
ffffffff80003abe:	be a5 00 00 00       	mov    $0xa5,%esi
ffffffff80003ac3:	e9 a8 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c9: return 144;
ffffffff80003ac8:	be 90 00 00 00       	mov    $0x90,%esi
ffffffff80003acd:	e9 9e fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c7: return 128;
ffffffff80003ad2:	be 80 00 00 00       	mov    $0x80,%esi
ffffffff80003ad7:	e9 94 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c6: return 146;
ffffffff80003adc:	be 92 00 00 00       	mov    $0x92,%esi
ffffffff80003ae1:	e9 8a fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c5: return 143;
ffffffff80003ae6:	be 8f 00 00 00       	mov    $0x8f,%esi
ffffffff80003aeb:	e9 80 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00c4: return 142;
ffffffff80003af0:	be 8e 00 00 00       	mov    $0x8e,%esi
ffffffff80003af5:	e9 76 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bf: return 168;
ffffffff80003afa:	be a8 00 00 00       	mov    $0xa8,%esi
ffffffff80003aff:	e9 6c fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bd: return 171;
ffffffff80003b04:	be ab 00 00 00       	mov    $0xab,%esi
ffffffff80003b09:	e9 62 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bc: return 172;
ffffffff80003b0e:	be ac 00 00 00       	mov    $0xac,%esi
ffffffff80003b13:	e9 58 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00bb: return 175;
ffffffff80003b18:	be af 00 00 00       	mov    $0xaf,%esi
ffffffff80003b1d:	e9 4e fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00ba: return 167;
ffffffff80003b22:	be a7 00 00 00       	mov    $0xa7,%esi
ffffffff80003b27:	e9 44 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b7: return 250;
ffffffff80003b2c:	be fa 00 00 00       	mov    $0xfa,%esi
ffffffff80003b31:	e9 3a fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b5: return 230;
ffffffff80003b36:	be e6 00 00 00       	mov    $0xe6,%esi
ffffffff80003b3b:	e9 30 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b2: return 253;
ffffffff80003b40:	be fd 00 00 00       	mov    $0xfd,%esi
ffffffff80003b45:	e9 26 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c6: return 237;
ffffffff80003b4a:	be ed 00 00 00       	mov    $0xed,%esi
ffffffff80003b4f:	e9 1c fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c4: return 231;
ffffffff80003b54:	be e7 00 00 00       	mov    $0xe7,%esi
ffffffff80003b59:	e9 12 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c3: return 229;
ffffffff80003b5e:	be e5 00 00 00       	mov    $0xe5,%esi
ffffffff80003b63:	e9 08 fb ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03c0: return 227;
ffffffff80003b68:	be e3 00 00 00       	mov    $0xe3,%esi
ffffffff80003b6d:	e9 fe fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b5: return 238;
ffffffff80003b72:	be ee 00 00 00       	mov    $0xee,%esi
ffffffff80003b77:	e9 f4 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b4: return 235;
ffffffff80003b7c:	be eb 00 00 00       	mov    $0xeb,%esi
ffffffff80003b81:	e9 ea fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a9: return 234;
ffffffff80003b86:	be ea 00 00 00       	mov    $0xea,%esi
ffffffff80003b8b:	e9 e0 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a6: return 232;
ffffffff80003b90:	be e8 00 00 00       	mov    $0xe8,%esi
ffffffff80003b95:	e9 d6 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03a3: return 228;
ffffffff80003b9a:	be e4 00 00 00       	mov    $0xe4,%esi
ffffffff80003b9f:	e9 cc fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0398: return 233;
ffffffff80003ba4:	be e9 00 00 00       	mov    $0xe9,%esi
ffffffff80003ba9:	e9 c2 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255c: return 189;
ffffffff80003bae:	be bd 00 00 00       	mov    $0xbd,%esi
ffffffff80003bb3:	e9 b8 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255b: return 190;
ffffffff80003bb8:	be be 00 00 00       	mov    $0xbe,%esi
ffffffff80003bbd:	e9 ae fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255a: return 200;
ffffffff80003bc2:	be c8 00 00 00       	mov    $0xc8,%esi
ffffffff80003bc7:	e9 a4 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2559: return 211;
ffffffff80003bcc:	be d3 00 00 00       	mov    $0xd3,%esi
ffffffff80003bd1:	e9 9a fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2558: return 212;
ffffffff80003bd6:	be d4 00 00 00       	mov    $0xd4,%esi
ffffffff80003bdb:	e9 90 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2557: return 187;
ffffffff80003be0:	be bb 00 00 00       	mov    $0xbb,%esi
ffffffff80003be5:	e9 86 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2556: return 183;
ffffffff80003bea:	be b7 00 00 00       	mov    $0xb7,%esi
ffffffff80003bef:	e9 7c fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2555: return 184;
ffffffff80003bf4:	be b8 00 00 00       	mov    $0xb8,%esi
ffffffff80003bf9:	e9 72 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2554: return 201;
ffffffff80003bfe:	be c9 00 00 00       	mov    $0xc9,%esi
ffffffff80003c03:	e9 68 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2553: return 214;
ffffffff80003c08:	be d6 00 00 00       	mov    $0xd6,%esi
ffffffff80003c0d:	e9 5e fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2552: return 213;
ffffffff80003c12:	be d5 00 00 00       	mov    $0xd5,%esi
ffffffff80003c17:	e9 54 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2551: return 186;
ffffffff80003c1c:	be ba 00 00 00       	mov    $0xba,%esi
ffffffff80003c21:	e9 4a fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2550: return 205;
ffffffff80003c26:	be cd 00 00 00       	mov    $0xcd,%esi
ffffffff80003c2b:	e9 40 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x253c: return 197;
ffffffff80003c30:	be c5 00 00 00       	mov    $0xc5,%esi
ffffffff80003c35:	e9 36 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2534: return 193;
ffffffff80003c3a:	be c1 00 00 00       	mov    $0xc1,%esi
ffffffff80003c3f:	e9 2c fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x252c: return 194;
ffffffff80003c44:	be c2 00 00 00       	mov    $0xc2,%esi
ffffffff80003c49:	e9 22 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25d8: return 8;
ffffffff80003c4e:	be 08 00 00 00       	mov    $0x8,%esi
ffffffff80003c53:	e9 18 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25cb: return 9;
ffffffff80003c58:	be 09 00 00 00       	mov    $0x9,%esi
ffffffff80003c5d:	e9 0e fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25c4: return 17;
ffffffff80003c62:	be 11 00 00 00       	mov    $0x11,%esi
ffffffff80003c67:	e9 04 fa ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25bc: return 31;
ffffffff80003c6c:	be 1f 00 00 00       	mov    $0x1f,%esi
ffffffff80003c71:	e9 fa f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25ba: return 16;
ffffffff80003c76:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff80003c7b:	e9 f0 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25b2: return 30;
ffffffff80003c80:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80003c85:	e9 e6 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25ac: return 22;
ffffffff80003c8a:	be 16 00 00 00       	mov    $0x16,%esi
ffffffff80003c8f:	e9 dc f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x25a0: return 254;
ffffffff80003c94:	be fe 00 00 00       	mov    $0xfe,%esi
ffffffff80003c99:	e9 d2 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2593: return 178;
ffffffff80003c9e:	be b2 00 00 00       	mov    $0xb2,%esi
ffffffff80003ca3:	e9 c8 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2592: return 177;
ffffffff80003ca8:	be b1 00 00 00       	mov    $0xb1,%esi
ffffffff80003cad:	e9 be f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2591: return 176;
ffffffff80003cb2:	be b0 00 00 00       	mov    $0xb0,%esi
ffffffff80003cb7:	e9 b4 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2590: return 222;
ffffffff80003cbc:	be de 00 00 00       	mov    $0xde,%esi
ffffffff80003cc1:	e9 aa f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x258c: return 221;
ffffffff80003cc6:	be dd 00 00 00       	mov    $0xdd,%esi
ffffffff80003ccb:	e9 a0 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2588: return 219;
ffffffff80003cd0:	be db 00 00 00       	mov    $0xdb,%esi
ffffffff80003cd5:	e9 96 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2584: return 220;
ffffffff80003cda:	be dc 00 00 00       	mov    $0xdc,%esi
ffffffff80003cdf:	e9 8c f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2580: return 223;
ffffffff80003ce4:	be df 00 00 00       	mov    $0xdf,%esi
ffffffff80003ce9:	e9 82 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256c: return 206;
ffffffff80003cee:	be ce 00 00 00       	mov    $0xce,%esi
ffffffff80003cf3:	e9 78 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256b: return 215;
ffffffff80003cf8:	be d7 00 00 00       	mov    $0xd7,%esi
ffffffff80003cfd:	e9 6e f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x256a: return 216;
ffffffff80003d02:	be d8 00 00 00       	mov    $0xd8,%esi
ffffffff80003d07:	e9 64 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2569: return 202;
ffffffff80003d0c:	be ca 00 00 00       	mov    $0xca,%esi
ffffffff80003d11:	e9 5a f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2568: return 208;
ffffffff80003d16:	be d0 00 00 00       	mov    $0xd0,%esi
ffffffff80003d1b:	e9 50 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2567: return 207;
ffffffff80003d20:	be cf 00 00 00       	mov    $0xcf,%esi
ffffffff80003d25:	e9 46 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2566: return 203;
ffffffff80003d2a:	be cb 00 00 00       	mov    $0xcb,%esi
ffffffff80003d2f:	e9 3c f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2565: return 210;
ffffffff80003d34:	be d2 00 00 00       	mov    $0xd2,%esi
ffffffff80003d39:	e9 32 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2564: return 209;
ffffffff80003d3e:	be d1 00 00 00       	mov    $0xd1,%esi
ffffffff80003d43:	e9 28 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2563: return 185;
ffffffff80003d48:	be b9 00 00 00       	mov    $0xb9,%esi
ffffffff80003d4d:	e9 1e f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2562: return 182;
ffffffff80003d52:	be b6 00 00 00       	mov    $0xb6,%esi
ffffffff80003d57:	e9 14 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2561: return 181;
ffffffff80003d5c:	be b5 00 00 00       	mov    $0xb5,%esi
ffffffff80003d61:	e9 0a f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2560: return 204;
ffffffff80003d66:	be cc 00 00 00       	mov    $0xcc,%esi
ffffffff80003d6b:	e9 00 f9 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255f: return 199;
ffffffff80003d70:	be c7 00 00 00       	mov    $0xc7,%esi
ffffffff80003d75:	e9 f6 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255e: return 198;
ffffffff80003d7a:	be c6 00 00 00       	mov    $0xc6,%esi
ffffffff80003d7f:	e9 ec f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x255d: return 188;
ffffffff80003d84:	be bc 00 00 00       	mov    $0xbc,%esi
ffffffff80003d89:	e9 e2 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x03b1: return 224;
ffffffff80003d8e:	be e0 00 00 00       	mov    $0xe0,%esi
ffffffff80003d93:	e9 d8 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x0393: return 226;
ffffffff80003d98:	be e2 00 00 00       	mov    $0xe2,%esi
ffffffff80003d9d:	e9 ce f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00b6: return 20;
ffffffff80003da2:	be 14 00 00 00       	mov    $0x14,%esi
ffffffff80003da7:	e9 c4 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    switch (code_point) {
ffffffff80003dac:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80003db1:	e9 ba f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2666: return 4;
ffffffff80003db6:	be 04 00 00 00       	mov    $0x4,%esi
ffffffff80003dbb:	e9 b0 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    switch (code_point) {
ffffffff80003dc0:	be 03 00 00 00       	mov    $0x3,%esi
ffffffff80003dc5:	e9 a6 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x21a8: return 23;
ffffffff80003dca:	be 17 00 00 00       	mov    $0x17,%esi
ffffffff80003dcf:	e9 9c f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2195: return 18;
ffffffff80003dd4:	be 12 00 00 00       	mov    $0x12,%esi
ffffffff80003dd9:	e9 92 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x00a7: return 21;
ffffffff80003dde:	be 15 00 00 00       	mov    $0x15,%esi
ffffffff80003de3:	e9 88 f8 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
ffffffff80003de8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80003def:	00 
            ctx->osc_escape = true;
ffffffff80003df0:	c6 43 0e 01          	movb   $0x1,0xe(%rbx)
            return;
ffffffff80003df4:	e9 9e f2 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
                ctx->scroll(ctx);
ffffffff80003df9:	48 89 df             	mov    %rbx,%rdi
ffffffff80003dfc:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, (ctx->oob_output & FLANTERM_OOB_OUTPUT_ONLCR) ? 0 : x, y);
ffffffff80003e02:	48 8b 83 00 01 00 00 	mov    0x100(%rbx),%rax
ffffffff80003e09:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80003e0e:	31 f6                	xor    %esi,%esi
ffffffff80003e10:	f6 83 b8 00 00 00 10 	testb  $0x10,0xb8(%rbx)
ffffffff80003e17:	0f 85 65 f5 ff ff    	jne    ffffffff80003382 <flanterm_write+0x3c2>
ffffffff80003e1d:	e9 5b f5 ff ff       	jmp    ffffffff8000337d <flanterm_write+0x3bd>
                ctx->set_cursor_pos(ctx, ctx->cols - 1, y);
ffffffff80003e22:	48 8d 72 ff          	lea    -0x1(%rdx),%rsi
ffffffff80003e26:	48 89 fa             	mov    %rdi,%rdx
ffffffff80003e29:	48 89 df             	mov    %rbx,%rdi
ffffffff80003e2c:	ff d1                	call   *%rcx
                return;
ffffffff80003e2e:	e9 64 f2 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (c) {
ffffffff80003e33:	41 8d 54 24 d5       	lea    -0x2b(%r12),%edx
ffffffff80003e38:	80 fa 53             	cmp    $0x53,%dl
ffffffff80003e3b:	0f 87 e0 f4 ff ff    	ja     ffffffff80003321 <flanterm_write+0x361>
ffffffff80003e41:	0f b6 d2             	movzbl %dl,%edx
ffffffff80003e44:	3e ff 24 d5 18 98 00 	notrack jmp *-0x7fff67e8(,%rdx,8)
ffffffff80003e4b:	80 
    if (ctx->rrr == true) {
ffffffff80003e4c:	80 7b 0f 00          	cmpb   $0x0,0xf(%rbx)
ffffffff80003e50:	0f 84 8a 01 00 00    	je     ffffffff80003fe0 <flanterm_write+0x1020>
        ctx->esc_values_i++;
ffffffff80003e56:	48 83 c2 01          	add    $0x1,%rdx
        ctx->rrr = false;
ffffffff80003e5a:	c6 43 0f 00          	movb   $0x0,0xf(%rbx)
        ctx->esc_values_i++;
ffffffff80003e5e:	48 89 53 40          	mov    %rdx,0x40(%rbx)
        if (c == ';')
ffffffff80003e62:	41 80 fc 3b          	cmp    $0x3b,%r12b
ffffffff80003e66:	0f 84 2b f2 ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
    if (ctx->dec_private == true) {
ffffffff80003e6c:	0f b6 73 14          	movzbl 0x14(%rbx),%esi
    switch (c) {
ffffffff80003e70:	41 80 fc 4b          	cmp    $0x4b,%r12b
ffffffff80003e74:	0f 8f 8f 01 00 00    	jg     ffffffff80004009 <flanterm_write+0x1049>
ffffffff80003e7a:	41 80 fc 49          	cmp    $0x49,%r12b
ffffffff80003e7e:	0f 8f 67 02 00 00    	jg     ffffffff800040eb <flanterm_write+0x112b>
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003e84:	41 b8 01 00 00 00    	mov    $0x1,%r8d
ffffffff80003e8a:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff80003e8e:	0f 87 d2 09 00 00    	ja     ffffffff80004866 <flanterm_write+0x18a6>
ffffffff80003e94:	48 8d bb b8 00 00 00 	lea    0xb8(%rbx),%rdi
ffffffff80003e9b:	48 8d 44 93 78       	lea    0x78(%rbx,%rdx,4),%rax
        ctx->esc_values[i] = esc_default;
ffffffff80003ea0:	44 89 c1             	mov    %r8d,%ecx
ffffffff80003ea3:	49 89 f9             	mov    %rdi,%r9
ffffffff80003ea6:	49 29 c1             	sub    %rax,%r9
ffffffff80003ea9:	41 83 e1 04          	and    $0x4,%r9d
ffffffff80003ead:	74 0c                	je     ffffffff80003ebb <flanterm_write+0xefb>
ffffffff80003eaf:	44 89 00             	mov    %r8d,(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003eb2:	48 83 c0 04          	add    $0x4,%rax
ffffffff80003eb6:	48 39 c7             	cmp    %rax,%rdi
ffffffff80003eb9:	74 0e                	je     ffffffff80003ec9 <flanterm_write+0xf09>
        ctx->esc_values[i] = esc_default;
ffffffff80003ebb:	89 08                	mov    %ecx,(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003ebd:	48 83 c0 08          	add    $0x8,%rax
        ctx->esc_values[i] = esc_default;
ffffffff80003ec1:	89 48 fc             	mov    %ecx,-0x4(%rax)
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80003ec4:	48 39 c7             	cmp    %rax,%rdi
ffffffff80003ec7:	75 f2                	jne    ffffffff80003ebb <flanterm_write+0xefb>
    if (ctx->dec_private == true) {
ffffffff80003ec9:	40 84 f6             	test   %sil,%sil
ffffffff80003ecc:	0f 85 e8 02 00 00    	jne    ffffffff800041ba <flanterm_write+0x11fa>
    bool r = ctx->scroll_enabled;
ffffffff80003ed2:	44 0f b6 73 0a       	movzbl 0xa(%rbx),%r14d
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003ed7:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
    ctx->scroll_enabled = false;
ffffffff80003edc:	c6 43 0a 00          	movb   $0x0,0xa(%rbx)
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80003ee0:	48 89 df             	mov    %rbx,%rdi
ffffffff80003ee3:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff80003ee8:	ff 93 08 01 00 00    	call   *0x108(%rbx)
    switch (c) {
ffffffff80003eee:	41 8d 44 24 c0       	lea    -0x40(%r12),%eax
ffffffff80003ef3:	3c 35                	cmp    $0x35,%al
ffffffff80003ef5:	77 67                	ja     ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff80003ef7:	0f b6 c0             	movzbl %al,%eax
ffffffff80003efa:	3e ff 24 c5 b8 9a 00 	notrack jmp *-0x7fff6548(,%rax,8)
ffffffff80003f01:	80 
            x = 0;
ffffffff80003f02:	31 ff                	xor    %edi,%edi
ffffffff80003f04:	48 89 7c 24 10       	mov    %rdi,0x10(%rsp)
            if (y + ctx->esc_values[0] > ctx->rows - 1)
ffffffff80003f09:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff80003f0e:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80003f15:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80003f18:	48 8d 78 ff          	lea    -0x1(%rax),%rdi
ffffffff80003f1c:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff80003f20:	48 39 f7             	cmp    %rsi,%rdi
ffffffff80003f23:	73 08                	jae    ffffffff80003f2d <flanterm_write+0xf6d>
                ctx->esc_values[0] = (ctx->rows - 1) - y;
ffffffff80003f25:	29 c8                	sub    %ecx,%eax
ffffffff80003f27:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff80003f2a:	89 53 78             	mov    %edx,0x78(%rbx)
            if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)
ffffffff80003f2d:	48 8b 73 68          	mov    0x68(%rbx),%rsi
             || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {
ffffffff80003f31:	48 8b 43 70          	mov    0x70(%rbx),%rax
            size_t dest_y = y + ctx->esc_values[0];
ffffffff80003f35:	48 01 ca             	add    %rcx,%rdx
            if ((ctx->scroll_top_margin >= orig_y && ctx->scroll_top_margin <= dest_y)
ffffffff80003f38:	48 39 ce             	cmp    %rcx,%rsi
ffffffff80003f3b:	72 05                	jb     ffffffff80003f42 <flanterm_write+0xf82>
ffffffff80003f3d:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80003f40:	73 05                	jae    ffffffff80003f47 <flanterm_write+0xf87>
             || (ctx->scroll_bottom_margin >= orig_y && ctx->scroll_bottom_margin <= dest_y)) {
ffffffff80003f42:	48 39 c8             	cmp    %rcx,%rax
ffffffff80003f45:	72 09                	jb     ffffffff80003f50 <flanterm_write+0xf90>
            if (will_be_in_scroll_region && dest_y >= ctx->scroll_bottom_margin) {
ffffffff80003f47:	48 39 c2             	cmp    %rax,%rdx
ffffffff80003f4a:	0f 83 dc 07 00 00    	jae    ffffffff8000472c <flanterm_write+0x176c>
            ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);
ffffffff80003f50:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff80003f55:	48 89 df             	mov    %rbx,%rdi
ffffffff80003f58:	ff 93 00 01 00 00    	call   *0x100(%rbx)
    ctx->scroll_enabled = r;
ffffffff80003f5e:	44 88 73 0a          	mov    %r14b,0xa(%rbx)
    ctx->control_sequence = false;
ffffffff80003f62:	31 d2                	xor    %edx,%edx
ffffffff80003f64:	66 89 53 0b          	mov    %dx,0xb(%rbx)
ffffffff80003f68:	e9 2a f1 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        switch (c) {
ffffffff80003f6d:	41 80 fc 3f          	cmp    $0x3f,%r12b
ffffffff80003f71:	0f 84 17 01 00 00    	je     ffffffff8000408e <flanterm_write+0x10ce>
ffffffff80003f77:	41 80 fc 5b          	cmp    $0x5b,%r12b
ffffffff80003f7b:	0f 85 30 f6 ff ff    	jne    ffffffff800035b1 <flanterm_write+0x5f1>
                ctx->discard_next = true;
ffffffff80003f81:	c6 43 10 01          	movb   $0x1,0x10(%rbx)
                goto cleanup;
ffffffff80003f85:	eb db                	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
    switch (code_point) {
ffffffff80003f87:	49 8d 84 24 e7 dd ff 	lea    -0x2219(%r12),%rax
ffffffff80003f8e:	ff 
ffffffff80003f8f:	48 83 f8 2f          	cmp    $0x2f,%rax
ffffffff80003f93:	0f 87 27 f4 ff ff    	ja     ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003f99:	3e ff 24 c5 68 9c 00 	notrack jmp *-0x7fff6398(,%rax,8)
ffffffff80003fa0:	80 
ffffffff80003fa1:	49 81 fc 7f 20 00 00 	cmp    $0x207f,%r12
ffffffff80003fa8:	0f 84 02 02 00 00    	je     ffffffff800041b0 <flanterm_write+0x11f0>
ffffffff80003fae:	0f 87 dc 01 00 00    	ja     ffffffff80004190 <flanterm_write+0x11d0>
ffffffff80003fb4:	49 81 fc 22 20 00 00 	cmp    $0x2022,%r12
ffffffff80003fbb:	0f 84 c5 01 00 00    	je     ffffffff80004186 <flanterm_write+0x11c6>
        case 0x203c: return 19;
ffffffff80003fc1:	be 13 00 00 00       	mov    $0x13,%esi
    switch (code_point) {
ffffffff80003fc6:	49 81 fc 3c 20 00 00 	cmp    $0x203c,%r12
ffffffff80003fcd:	0f 84 9d f6 ff ff    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff80003fd3:	e9 e8 f3 ff ff       	jmp    ffffffff800033c0 <flanterm_write+0x400>
ffffffff80003fd8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80003fdf:	00 
    } else if (c == ';') {
ffffffff80003fe0:	41 80 fc 3b          	cmp    $0x3b,%r12b
ffffffff80003fe4:	0f 85 82 fe ff ff    	jne    ffffffff80003e6c <flanterm_write+0xeac>
        if (ctx->esc_values_i == FLANTERM_MAX_ESC_VALUES) {
ffffffff80003fea:	48 83 fa 10          	cmp    $0x10,%rdx
ffffffff80003fee:	0f 84 a3 f0 ff ff    	je     ffffffff80003097 <flanterm_write+0xd7>
        ctx->esc_values[ctx->esc_values_i] = 0;
ffffffff80003ff4:	c7 44 93 78 00 00 00 	movl   $0x0,0x78(%rbx,%rdx,4)
ffffffff80003ffb:	00 
        ctx->esc_values_i++;
ffffffff80003ffc:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80004000:	48 89 53 40          	mov    %rdx,0x40(%rbx)
        return;
ffffffff80004004:	e9 8e f0 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
    switch (c) {
ffffffff80004009:	41 80 fc 71          	cmp    $0x71,%r12b
ffffffff8000400d:	0f 85 c3 00 00 00    	jne    ffffffff800040d6 <flanterm_write+0x1116>
            esc_default = 0; break;
ffffffff80004013:	45 31 c0             	xor    %r8d,%r8d
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff80004016:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff8000401a:	0f 86 74 fe ff ff    	jbe    ffffffff80003e94 <flanterm_write+0xed4>
    if (ctx->dec_private == true) {
ffffffff80004020:	40 84 f6             	test   %sil,%sil
ffffffff80004023:	0f 85 46 08 00 00    	jne    ffffffff8000486f <flanterm_write+0x18af>
    bool r = ctx->scroll_enabled;
ffffffff80004029:	44 0f b6 73 0a       	movzbl 0xa(%rbx),%r14d
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff8000402e:	48 8d 54 24 18       	lea    0x18(%rsp),%rdx
    ctx->scroll_enabled = false;
ffffffff80004033:	c6 43 0a 00          	movb   $0x0,0xa(%rbx)
    ctx->get_cursor_pos(ctx, &x, &y);
ffffffff80004037:	48 89 df             	mov    %rbx,%rdi
ffffffff8000403a:	48 8d 74 24 10       	lea    0x10(%rsp),%rsi
ffffffff8000403f:	ff 93 08 01 00 00    	call   *0x108(%rbx)
            if (ctx->callback != NULL) {
ffffffff80004045:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff8000404c:	48 85 c0             	test   %rax,%rax
ffffffff8000404f:	0f 84 09 ff ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                ctx->callback(ctx, FLANTERM_CB_KBD_LEDS, ctx->esc_values[0], 0, 0);
ffffffff80004055:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004058:	45 31 c0             	xor    %r8d,%r8d
ffffffff8000405b:	31 c9                	xor    %ecx,%ecx
ffffffff8000405d:	be 3c 00 00 00       	mov    $0x3c,%esi
ffffffff80004062:	48 89 df             	mov    %rbx,%rdi
ffffffff80004065:	ff d0                	call   *%rax
ffffffff80004067:	e9 f2 fe ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff8000406c:	0f 1f 40 00          	nopl   0x0(%rax)
                ctx->scroll(ctx);
ffffffff80004070:	48 89 df             	mov    %rbx,%rdi
ffffffff80004073:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004079:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000407e:	31 f6                	xor    %esi,%esi
ffffffff80004080:	48 89 df             	mov    %rbx,%rdi
ffffffff80004083:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff80004089:	e9 ca f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
                ctx->dec_private = true;
ffffffff8000408e:	c6 43 14 01          	movb   $0x1,0x14(%rbx)
                return;
ffffffff80004092:	e9 00 f0 ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
                ctx->scroll(ctx);
ffffffff80004097:	48 89 df             	mov    %rbx,%rdi
ffffffff8000409a:	ff 93 68 01 00 00    	call   *0x168(%rbx)
                ctx->set_cursor_pos(ctx, x, y);
ffffffff800040a0:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800040a5:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800040aa:	48 89 df             	mov    %rbx,%rdi
ffffffff800040ad:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800040b3:	e9 a0 f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
                ctx->revscroll(ctx);
ffffffff800040b8:	48 89 df             	mov    %rbx,%rdi
ffffffff800040bb:	ff 93 70 01 00 00    	call   *0x170(%rbx)
                ctx->set_cursor_pos(ctx, 0, y);
ffffffff800040c1:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800040c6:	31 f6                	xor    %esi,%esi
ffffffff800040c8:	48 89 df             	mov    %rbx,%rdi
ffffffff800040cb:	ff 93 00 01 00 00    	call   *0x100(%rbx)
ffffffff800040d1:	e9 82 f3 ff ff       	jmp    ffffffff80003458 <flanterm_write+0x498>
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff800040d6:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff800040da:	0f 87 31 06 00 00    	ja     ffffffff80004711 <flanterm_write+0x1751>
ffffffff800040e0:	41 b8 01 00 00 00    	mov    $0x1,%r8d
ffffffff800040e6:	e9 a9 fd ff ff       	jmp    ffffffff80003e94 <flanterm_write+0xed4>
            esc_default = 0; break;
ffffffff800040eb:	45 31 c0             	xor    %r8d,%r8d
    for (size_t i = ctx->esc_values_i; i < FLANTERM_MAX_ESC_VALUES; i++) {
ffffffff800040ee:	48 83 fa 0f          	cmp    $0xf,%rdx
ffffffff800040f2:	0f 86 9c fd ff ff    	jbe    ffffffff80003e94 <flanterm_write+0xed4>
    if (ctx->dec_private == true) {
ffffffff800040f8:	40 84 f6             	test   %sil,%sil
ffffffff800040fb:	0f 84 d1 fd ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff80004101:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    switch (c) {
ffffffff80004105:	41 80 fc 6c          	cmp    $0x6c,%r12b
ffffffff80004109:	0f 85 53 fe ff ff    	jne    ffffffff80003f62 <flanterm_write+0xfa2>
    switch (ctx->esc_values[0]) {
ffffffff8000410f:	83 7b 78 19          	cmpl   $0x19,0x78(%rbx)
ffffffff80004113:	0f 84 0a 06 00 00    	je     ffffffff80004723 <flanterm_write+0x1763>
    if (ctx->callback != NULL) {
ffffffff80004119:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004120:	48 85 c0             	test   %rax,%rax
ffffffff80004123:	0f 84 39 fe ff ff    	je     ffffffff80003f62 <flanterm_write+0xfa2>
        ctx->callback(ctx, FLANTERM_CB_DEC, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);
ffffffff80004129:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff8000412d:	4d 0f be c4          	movsbq %r12b,%r8
ffffffff80004131:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff80004136:	48 89 df             	mov    %rbx,%rdi
ffffffff80004139:	ff d0                	call   *%rax
ffffffff8000413b:	e9 22 fe ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
        case 0x2248: return 247;
ffffffff80004140:	be f7 00 00 00       	mov    $0xf7,%esi
ffffffff80004145:	e9 26 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2302: return 127;
ffffffff8000414a:	be 7f 00 00 00       	mov    $0x7f,%esi
ffffffff8000414f:	e9 1c f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2229: return 239;
ffffffff80004154:	be ef 00 00 00       	mov    $0xef,%esi
ffffffff80004159:	e9 12 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x221a: return 251;
ffffffff8000415e:	be fb 00 00 00       	mov    $0xfb,%esi
ffffffff80004163:	e9 08 f5 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2219: return 249;
ffffffff80004168:	be f9 00 00 00       	mov    $0xf9,%esi
ffffffff8000416d:	e9 fe f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2265: return 242;
ffffffff80004172:	be f2 00 00 00       	mov    $0xf2,%esi
ffffffff80004177:	e9 f4 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2264: return 243;
ffffffff8000417c:	be f3 00 00 00       	mov    $0xf3,%esi
ffffffff80004181:	e9 ea f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2022: return 7;
ffffffff80004186:	be 07 00 00 00       	mov    $0x7,%esi
ffffffff8000418b:	e9 e0 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x20a7: return 158;
ffffffff80004190:	be 9e 00 00 00       	mov    $0x9e,%esi
    switch (code_point) {
ffffffff80004195:	49 81 fc a7 20 00 00 	cmp    $0x20a7,%r12
ffffffff8000419c:	0f 84 ce f4 ff ff    	je     ffffffff80003670 <flanterm_write+0x6b0>
ffffffff800041a2:	e9 19 f2 ff ff       	jmp    ffffffff800033c0 <flanterm_write+0x400>
ffffffff800041a7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800041ae:	00 00 
        case 0x207f: return 252;
ffffffff800041b0:	be fc 00 00 00       	mov    $0xfc,%esi
ffffffff800041b5:	e9 b6 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    ctx->dec_private = false;
ffffffff800041ba:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    if (ctx->esc_values_i == 0) {
ffffffff800041be:	48 85 d2             	test   %rdx,%rdx
ffffffff800041c1:	0f 84 9b fd ff ff    	je     ffffffff80003f62 <flanterm_write+0xfa2>
    switch (c) {
ffffffff800041c7:	41 80 fc 68          	cmp    $0x68,%r12b
ffffffff800041cb:	0f 85 34 ff ff ff    	jne    ffffffff80004105 <flanterm_write+0x1145>
    switch (ctx->esc_values[0]) {
ffffffff800041d1:	83 7b 78 19          	cmpl   $0x19,0x78(%rbx)
ffffffff800041d5:	0f 85 3e ff ff ff    	jne    ffffffff80004119 <flanterm_write+0x1159>
                ctx->cursor_enabled = true;
ffffffff800041db:	c6 43 09 01          	movb   $0x1,0x9(%rbx)
ffffffff800041df:	e9 7e fd ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
ffffffff800041e4:	0f 1f 40 00          	nopl   0x0(%rax)
        case 0x2321: return 245;
ffffffff800041e8:	be f5 00 00 00       	mov    $0xf5,%esi
ffffffff800041ed:	e9 7e f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case 0x2320: return 244;
ffffffff800041f2:	be f4 00 00 00       	mov    $0xf4,%esi
ffffffff800041f7:	e9 74 f4 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff800041fc:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800041ff:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
ffffffff80004204:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000420b:	49 01 d4             	add    %rdx,%r12
ffffffff8000420e:	49 39 c4             	cmp    %rax,%r12
ffffffff80004211:	73 2d                	jae    ffffffff80004240 <flanterm_write+0x1280>
                ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);
ffffffff80004213:	4c 8b 44 24 18       	mov    0x18(%rsp),%r8
ffffffff80004218:	4c 89 e6             	mov    %r12,%rsi
ffffffff8000421b:	4c 89 e1             	mov    %r12,%rcx
ffffffff8000421e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004221:	48 29 d6             	sub    %rdx,%rsi
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff80004224:	49 83 c4 01          	add    $0x1,%r12
                ctx->move_character(ctx, i - ctx->esc_values[0], y, i, y);
ffffffff80004228:	4c 89 c2             	mov    %r8,%rdx
ffffffff8000422b:	ff 93 60 01 00 00    	call   *0x160(%rbx)
            for (size_t i = x + ctx->esc_values[0]; i < ctx->cols; i++)
ffffffff80004231:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff80004238:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff8000423b:	49 39 c4             	cmp    %rax,%r12
ffffffff8000423e:	72 d3                	jb     ffffffff80004213 <flanterm_write+0x1253>
            ctx->set_cursor_pos(ctx, ctx->cols - ctx->esc_values[0], y);
ffffffff80004240:	48 29 d0             	sub    %rdx,%rax
ffffffff80004243:	48 89 df             	mov    %rbx,%rdi
ffffffff80004246:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000424b:	48 89 c6             	mov    %rax,%rsi
ffffffff8000424e:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            size_t count = ctx->esc_values[0] > ctx->cols ? ctx->cols : ctx->esc_values[0];
ffffffff80004254:	44 8b 63 78          	mov    0x78(%rbx),%r12d
ffffffff80004258:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000425f:	49 39 c4             	cmp    %rax,%r12
ffffffff80004262:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++)
ffffffff80004266:	45 31 ff             	xor    %r15d,%r15d
ffffffff80004269:	4d 85 e4             	test   %r12,%r12
ffffffff8000426c:	74 17                	je     ffffffff80004285 <flanterm_write+0x12c5>
ffffffff8000426e:	49 83 c7 01          	add    $0x1,%r15
                ctx->raw_putchar(ctx, ' ');
ffffffff80004272:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004277:	48 89 df             	mov    %rbx,%rdi
ffffffff8000427a:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
            for (size_t i = 0; i < count; i++)
ffffffff80004280:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004283:	75 e9                	jne    ffffffff8000426e <flanterm_write+0x12ae>
                    ctx->set_cursor_pos(ctx, x, y);
ffffffff80004285:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000428a:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff8000428f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004292:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    break;
ffffffff80004298:	e9 c1 fc ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            x = 0;
ffffffff8000429d:	45 31 c0             	xor    %r8d,%r8d
ffffffff800042a0:	4c 89 44 24 10       	mov    %r8,0x10(%rsp)
            if (ctx->esc_values[0] > y)
ffffffff800042a5:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800042aa:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800042ad:	48 39 d1             	cmp    %rdx,%rcx
ffffffff800042b0:	73 05                	jae    ffffffff800042b7 <flanterm_write+0x12f7>
                ctx->esc_values[0] = y;
ffffffff800042b2:	89 4b 78             	mov    %ecx,0x78(%rbx)
ffffffff800042b5:	89 ca                	mov    %ecx,%edx
            size_t dest_y = y - ctx->esc_values[0];
ffffffff800042b7:	48 89 c8             	mov    %rcx,%rax
ffffffff800042ba:	48 29 d0             	sub    %rdx,%rax
            if ((ctx->scroll_top_margin >= dest_y && ctx->scroll_top_margin <= orig_y)
ffffffff800042bd:	48 8b 53 68          	mov    0x68(%rbx),%rdx
ffffffff800042c1:	48 39 c2             	cmp    %rax,%rdx
ffffffff800042c4:	72 09                	jb     ffffffff800042cf <flanterm_write+0x130f>
ffffffff800042c6:	48 39 d1             	cmp    %rdx,%rcx
ffffffff800042c9:	0f 83 2c 04 00 00    	jae    ffffffff800046fb <flanterm_write+0x173b>
             || (ctx->scroll_bottom_margin >= dest_y && ctx->scroll_bottom_margin <= orig_y)) {
ffffffff800042cf:	48 8b 73 70          	mov    0x70(%rbx),%rsi
ffffffff800042d3:	48 39 c6             	cmp    %rax,%rsi
ffffffff800042d6:	72 09                	jb     ffffffff800042e1 <flanterm_write+0x1321>
ffffffff800042d8:	48 39 f1             	cmp    %rsi,%rcx
ffffffff800042db:	0f 83 1a 04 00 00    	jae    ffffffff800046fb <flanterm_write+0x173b>
            ctx->set_cursor_pos(ctx, x, dest_y);
ffffffff800042e1:	48 8b 74 24 10       	mov    0x10(%rsp),%rsi
ffffffff800042e6:	48 89 c2             	mov    %rax,%rdx
ffffffff800042e9:	48 89 df             	mov    %rbx,%rdi
ffffffff800042ec:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff800042f2:	e9 67 fc ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
        case 0x221f: return 28;
ffffffff800042f7:	be 1c 00 00 00       	mov    $0x1c,%esi
ffffffff800042fc:	e9 6f f3 ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
        case '~': FLANTERM_DEC_SPCL_PRN(0xfa)
ffffffff80004301:	be fa 00 00 00       	mov    $0xfa,%esi
ffffffff80004306:	48 89 df             	mov    %rbx,%rdi
ffffffff80004309:	ff d0                	call   *%rax
ffffffff8000430b:	e9 87 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '}': FLANTERM_DEC_SPCL_PRN(0x9c)
ffffffff80004310:	be 9c 00 00 00       	mov    $0x9c,%esi
ffffffff80004315:	48 89 df             	mov    %rbx,%rdi
ffffffff80004318:	ff d0                	call   *%rax
ffffffff8000431a:	e9 78 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '{': FLANTERM_DEC_SPCL_PRN(0xe3)
ffffffff8000431f:	be e3 00 00 00       	mov    $0xe3,%esi
ffffffff80004324:	48 89 df             	mov    %rbx,%rdi
ffffffff80004327:	ff d0                	call   *%rax
ffffffff80004329:	e9 69 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'z': FLANTERM_DEC_SPCL_PRN(0xf2)
ffffffff8000432e:	be f2 00 00 00       	mov    $0xf2,%esi
ffffffff80004333:	48 89 df             	mov    %rbx,%rdi
ffffffff80004336:	ff d0                	call   *%rax
ffffffff80004338:	e9 5a ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'y': FLANTERM_DEC_SPCL_PRN(0xf3)
ffffffff8000433d:	be f3 00 00 00       	mov    $0xf3,%esi
ffffffff80004342:	48 89 df             	mov    %rbx,%rdi
ffffffff80004345:	ff d0                	call   *%rax
ffffffff80004347:	e9 4b ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'x': FLANTERM_DEC_SPCL_PRN(0xb3)
ffffffff8000434c:	be b3 00 00 00       	mov    $0xb3,%esi
ffffffff80004351:	48 89 df             	mov    %rbx,%rdi
ffffffff80004354:	ff d0                	call   *%rax
ffffffff80004356:	e9 3c ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'w': FLANTERM_DEC_SPCL_PRN(0xc2)
ffffffff8000435b:	be c2 00 00 00       	mov    $0xc2,%esi
ffffffff80004360:	48 89 df             	mov    %rbx,%rdi
ffffffff80004363:	ff d0                	call   *%rax
ffffffff80004365:	e9 2d ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'v': FLANTERM_DEC_SPCL_PRN(0xc1)
ffffffff8000436a:	be c1 00 00 00       	mov    $0xc1,%esi
ffffffff8000436f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004372:	ff d0                	call   *%rax
ffffffff80004374:	e9 1e ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'u': FLANTERM_DEC_SPCL_PRN(0xb4)
ffffffff80004379:	be b4 00 00 00       	mov    $0xb4,%esi
ffffffff8000437e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004381:	ff d0                	call   *%rax
ffffffff80004383:	e9 0f ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 't': FLANTERM_DEC_SPCL_PRN(0xc3)
ffffffff80004388:	be c3 00 00 00       	mov    $0xc3,%esi
ffffffff8000438d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004390:	ff d0                	call   *%rax
ffffffff80004392:	e9 00 ed ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 's': FLANTERM_DEC_SPCL_PRN(0x5f)
ffffffff80004397:	be 5f 00 00 00       	mov    $0x5f,%esi
ffffffff8000439c:	48 89 df             	mov    %rbx,%rdi
ffffffff8000439f:	ff d0                	call   *%rax
ffffffff800043a1:	e9 f1 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'q': FLANTERM_DEC_SPCL_PRN(0xc4)
ffffffff800043a6:	be c4 00 00 00       	mov    $0xc4,%esi
ffffffff800043ab:	48 89 df             	mov    %rbx,%rdi
ffffffff800043ae:	ff d0                	call   *%rax
ffffffff800043b0:	e9 e2 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'n': FLANTERM_DEC_SPCL_PRN(0xc5)
ffffffff800043b5:	be c5 00 00 00       	mov    $0xc5,%esi
ffffffff800043ba:	48 89 df             	mov    %rbx,%rdi
ffffffff800043bd:	ff d0                	call   *%rax
ffffffff800043bf:	e9 d3 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'm': FLANTERM_DEC_SPCL_PRN(0xc0)
ffffffff800043c4:	be c0 00 00 00       	mov    $0xc0,%esi
ffffffff800043c9:	48 89 df             	mov    %rbx,%rdi
ffffffff800043cc:	ff d0                	call   *%rax
ffffffff800043ce:	e9 c4 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'l': FLANTERM_DEC_SPCL_PRN(0xda)
ffffffff800043d3:	be da 00 00 00       	mov    $0xda,%esi
ffffffff800043d8:	48 89 df             	mov    %rbx,%rdi
ffffffff800043db:	ff d0                	call   *%rax
ffffffff800043dd:	e9 b5 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'k': FLANTERM_DEC_SPCL_PRN(0xbf)
ffffffff800043e2:	be bf 00 00 00       	mov    $0xbf,%esi
ffffffff800043e7:	48 89 df             	mov    %rbx,%rdi
ffffffff800043ea:	ff d0                	call   *%rax
ffffffff800043ec:	e9 a6 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'j': FLANTERM_DEC_SPCL_PRN(0xd9)
ffffffff800043f1:	be d9 00 00 00       	mov    $0xd9,%esi
ffffffff800043f6:	48 89 df             	mov    %rbx,%rdi
ffffffff800043f9:	ff d0                	call   *%rax
ffffffff800043fb:	e9 97 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'h': FLANTERM_DEC_SPCL_PRN(0xb0)
ffffffff80004400:	be b0 00 00 00       	mov    $0xb0,%esi
ffffffff80004405:	48 89 df             	mov    %rbx,%rdi
ffffffff80004408:	ff d0                	call   *%rax
ffffffff8000440a:	e9 88 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'g': FLANTERM_DEC_SPCL_PRN(0xf1)
ffffffff8000440f:	be f1 00 00 00       	mov    $0xf1,%esi
ffffffff80004414:	48 89 df             	mov    %rbx,%rdi
ffffffff80004417:	ff d0                	call   *%rax
ffffffff80004419:	e9 79 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'f': FLANTERM_DEC_SPCL_PRN(0xf8)
ffffffff8000441e:	be f8 00 00 00       	mov    $0xf8,%esi
ffffffff80004423:	48 89 df             	mov    %rbx,%rdi
ffffffff80004426:	ff d0                	call   *%rax
ffffffff80004428:	e9 6a ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case 'a': FLANTERM_DEC_SPCL_PRN(0xb1)
ffffffff8000442d:	be b1 00 00 00       	mov    $0xb1,%esi
ffffffff80004432:	48 89 df             	mov    %rbx,%rdi
ffffffff80004435:	ff d0                	call   *%rax
ffffffff80004437:	e9 5b ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '`': FLANTERM_DEC_SPCL_PRN(0x04)
ffffffff8000443c:	be 04 00 00 00       	mov    $0x4,%esi
ffffffff80004441:	48 89 df             	mov    %rbx,%rdi
ffffffff80004444:	ff d0                	call   *%rax
ffffffff80004446:	e9 4c ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '_': FLANTERM_DEC_SPCL_PRN(0xff)
ffffffff8000444b:	be ff 00 00 00       	mov    $0xff,%esi
ffffffff80004450:	48 89 df             	mov    %rbx,%rdi
ffffffff80004453:	ff d0                	call   *%rax
ffffffff80004455:	e9 3d ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '0': FLANTERM_DEC_SPCL_PRN(0xdb)
ffffffff8000445a:	be db 00 00 00       	mov    $0xdb,%esi
ffffffff8000445f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004462:	ff d0                	call   *%rax
ffffffff80004464:	e9 2e ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '.': FLANTERM_DEC_SPCL_PRN(0x19)
ffffffff80004469:	be 19 00 00 00       	mov    $0x19,%esi
ffffffff8000446e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004471:	ff d0                	call   *%rax
ffffffff80004473:	e9 1f ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '-': FLANTERM_DEC_SPCL_PRN(0x18)
ffffffff80004478:	be 18 00 00 00       	mov    $0x18,%esi
ffffffff8000447d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004480:	ff d0                	call   *%rax
ffffffff80004482:	e9 10 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case ',': FLANTERM_DEC_SPCL_PRN(0x1b)
ffffffff80004487:	be 1b 00 00 00       	mov    $0x1b,%esi
ffffffff8000448c:	48 89 df             	mov    %rbx,%rdi
ffffffff8000448f:	ff d0                	call   *%rax
ffffffff80004491:	e9 01 ec ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
        case '+': FLANTERM_DEC_SPCL_PRN(0x1a)
ffffffff80004496:	be 1a 00 00 00       	mov    $0x1a,%esi
ffffffff8000449b:	48 89 df             	mov    %rbx,%rdi
ffffffff8000449e:	ff d0                	call   *%rax
ffffffff800044a0:	e9 f2 eb ff ff       	jmp    ffffffff80003097 <flanterm_write+0xd7>
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044a5:	44 8b 63 78          	mov    0x78(%rbx),%r12d
ffffffff800044a9:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff800044b0:	49 39 c4             	cmp    %rax,%r12
ffffffff800044b3:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++) {
ffffffff800044b7:	4d 85 e4             	test   %r12,%r12
ffffffff800044ba:	0f 84 9e fa ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff800044c0:	45 31 ff             	xor    %r15d,%r15d
ffffffff800044c3:	49 83 c7 01          	add    $0x1,%r15
                ctx->scroll(ctx);
ffffffff800044c7:	48 89 df             	mov    %rbx,%rdi
ffffffff800044ca:	ff 93 68 01 00 00    	call   *0x168(%rbx)
            for (size_t i = 0; i < count; i++) {
ffffffff800044d0:	4d 39 fc             	cmp    %r15,%r12
ffffffff800044d3:	75 ee                	jne    ffffffff800044c3 <flanterm_write+0x1503>
ffffffff800044d5:	e9 84 fa ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->scroll_top_margin = y;
ffffffff800044da:	48 8b 44 24 18       	mov    0x18(%rsp),%rax
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044df:	44 8b 63 78          	mov    0x78(%rbx),%r12d
            size_t old_scroll_top_margin = ctx->scroll_top_margin;
ffffffff800044e3:	48 8b 53 68          	mov    0x68(%rbx),%rdx
            ctx->scroll_top_margin = y;
ffffffff800044e7:	48 89 43 68          	mov    %rax,0x68(%rbx)
            size_t count = ctx->esc_values[0] > ctx->rows ? ctx->rows : ctx->esc_values[0];
ffffffff800044eb:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff800044f2:	49 39 c4             	cmp    %rax,%r12
ffffffff800044f5:	4c 0f 47 e0          	cmova  %rax,%r12
            for (size_t i = 0; i < count; i++) {
ffffffff800044f9:	45 31 ff             	xor    %r15d,%r15d
ffffffff800044fc:	4d 85 e4             	test   %r12,%r12
ffffffff800044ff:	74 1c                	je     ffffffff8000451d <flanterm_write+0x155d>
ffffffff80004501:	49 83 c7 01          	add    $0x1,%r15
ffffffff80004505:	48 89 54 24 08       	mov    %rdx,0x8(%rsp)
                ctx->revscroll(ctx);
ffffffff8000450a:	48 89 df             	mov    %rbx,%rdi
ffffffff8000450d:	ff 93 70 01 00 00    	call   *0x170(%rbx)
            for (size_t i = 0; i < count; i++) {
ffffffff80004513:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004516:	48 8b 54 24 08       	mov    0x8(%rsp),%rdx
ffffffff8000451b:	75 e4                	jne    ffffffff80004501 <flanterm_write+0x1541>
            ctx->scroll_top_margin = old_scroll_top_margin;
ffffffff8000451d:	48 89 53 68          	mov    %rdx,0x68(%rbx)
            break;
ffffffff80004521:	e9 38 fa ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[0]) {
ffffffff80004526:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff80004529:	83 f8 01             	cmp    $0x1,%eax
ffffffff8000452c:	74 69                	je     ffffffff80004597 <flanterm_write+0x15d7>
ffffffff8000452e:	83 f8 02             	cmp    $0x2,%eax
ffffffff80004531:	74 2f                	je     ffffffff80004562 <flanterm_write+0x15a2>
ffffffff80004533:	85 c0                	test   %eax,%eax
ffffffff80004535:	0f 85 23 fa ff ff    	jne    ffffffff80003f5e <flanterm_write+0xf9e>
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff8000453b:	4c 8b 64 24 10       	mov    0x10(%rsp),%r12
ffffffff80004540:	eb 12                	jmp    ffffffff80004554 <flanterm_write+0x1594>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004542:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004547:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff8000454a:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff8000454e:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = x; i < ctx->cols; i++)
ffffffff80004554:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff8000455b:	72 e5                	jb     ffffffff80004542 <flanterm_write+0x1582>
ffffffff8000455d:	e9 23 fd ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004562:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80004567:	31 f6                	xor    %esi,%esi
ffffffff80004569:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff8000456c:	45 31 e4             	xor    %r12d,%r12d
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff8000456f:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff80004575:	eb 12                	jmp    ffffffff80004589 <flanterm_write+0x15c9>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004577:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff8000457c:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff8000457f:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004583:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < ctx->cols; i++)
ffffffff80004589:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff80004590:	72 e5                	jb     ffffffff80004577 <flanterm_write+0x15b7>
ffffffff80004592:	e9 ee fc ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff80004597:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000459c:	31 f6                	xor    %esi,%esi
ffffffff8000459e:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < x; i++)
ffffffff800045a1:	45 31 e4             	xor    %r12d,%r12d
                    ctx->set_cursor_pos(ctx, 0, y);
ffffffff800045a4:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t i = 0; i < x; i++)
ffffffff800045aa:	eb 12                	jmp    ffffffff800045be <flanterm_write+0x15fe>
                        ctx->raw_putchar(ctx, ' ');
ffffffff800045ac:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff800045b1:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < x; i++)
ffffffff800045b4:	49 83 c4 01          	add    $0x1,%r12
                        ctx->raw_putchar(ctx, ' ');
ffffffff800045b8:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < x; i++)
ffffffff800045be:	4c 3b 64 24 10       	cmp    0x10(%rsp),%r12
ffffffff800045c3:	72 e7                	jb     ffffffff800045ac <flanterm_write+0x15ec>
ffffffff800045c5:	e9 94 f9 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[0]) {
ffffffff800045ca:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff800045cd:	83 f8 01             	cmp    $0x1,%eax
ffffffff800045d0:	0f 84 b3 00 00 00    	je     ffffffff80004689 <flanterm_write+0x16c9>
ffffffff800045d6:	0f 87 91 00 00 00    	ja     ffffffff8000466d <flanterm_write+0x16ad>
                    size_t cols_diff = ctx->cols - (x + 1);
ffffffff800045dc:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
                    size_t rows_remaining = ctx->rows - (y + 1);
ffffffff800045e3:	4c 8b a3 e0 00 00 00 	mov    0xe0(%rbx),%r12
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff800045ea:	45 31 ff             	xor    %r15d,%r15d
                    size_t rows_remaining = ctx->rows - (y + 1);
ffffffff800045ed:	4c 2b 64 24 18       	sub    0x18(%rsp),%r12
ffffffff800045f2:	49 83 ec 01          	sub    $0x1,%r12
                    size_t to_clear = rows_remaining * ctx->cols + cols_diff + 1;
ffffffff800045f6:	4c 0f af e0          	imul   %rax,%r12
ffffffff800045fa:	48 2b 44 24 10       	sub    0x10(%rsp),%rax
ffffffff800045ff:	49 01 c4             	add    %rax,%r12
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff80004602:	eb 12                	jmp    ffffffff80004616 <flanterm_write+0x1656>
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004604:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004609:	48 89 df             	mov    %rbx,%rdi
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff8000460c:	49 83 c7 01          	add    $0x1,%r15
                        ctx->raw_putchar(ctx, ' ');
ffffffff80004610:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                    for (size_t i = 0; i < to_clear; i++) {
ffffffff80004616:	4d 39 fc             	cmp    %r15,%r12
ffffffff80004619:	75 e9                	jne    ffffffff80004604 <flanterm_write+0x1644>
ffffffff8000461b:	e9 65 fc ff ff       	jmp    ffffffff80004285 <flanterm_write+0x12c5>
            if (ctx->esc_values[0] != 0) {
ffffffff80004620:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff80004623:	85 c0                	test   %eax,%eax
ffffffff80004625:	74 06                	je     ffffffff8000462d <flanterm_write+0x166d>
                ctx->esc_values[0]--;
ffffffff80004627:	83 e8 01             	sub    $0x1,%eax
ffffffff8000462a:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[1] != 0) {
ffffffff8000462d:	8b 43 7c             	mov    0x7c(%rbx),%eax
ffffffff80004630:	85 c0                	test   %eax,%eax
ffffffff80004632:	74 06                	je     ffffffff8000463a <flanterm_write+0x167a>
                ctx->esc_values[1]--;
ffffffff80004634:	83 e8 01             	sub    $0x1,%eax
ffffffff80004637:	89 43 7c             	mov    %eax,0x7c(%rbx)
            if (ctx->esc_values[1] >= ctx->cols)
ffffffff8000463a:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff80004641:	8b 73 7c             	mov    0x7c(%rbx),%esi
ffffffff80004644:	48 39 c6             	cmp    %rax,%rsi
ffffffff80004647:	72 06                	jb     ffffffff8000464f <flanterm_write+0x168f>
                ctx->esc_values[1] = ctx->cols - 1;
ffffffff80004649:	8d 70 ff             	lea    -0x1(%rax),%esi
ffffffff8000464c:	89 73 7c             	mov    %esi,0x7c(%rbx)
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff8000464f:	48 8b 83 e0 00 00 00 	mov    0xe0(%rbx),%rax
ffffffff80004656:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004659:	48 39 c2             	cmp    %rax,%rdx
ffffffff8000465c:	0f 82 f3 f8 ff ff    	jb     ffffffff80003f55 <flanterm_write+0xf95>
                ctx->esc_values[0] = ctx->rows - 1;
ffffffff80004662:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff80004665:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, ctx->esc_values[1], ctx->esc_values[0]);
ffffffff80004668:	e9 e8 f8 ff ff       	jmp    ffffffff80003f55 <flanterm_write+0xf95>
            switch (ctx->esc_values[0]) {
ffffffff8000466d:	83 e8 02             	sub    $0x2,%eax
ffffffff80004670:	83 f8 01             	cmp    $0x1,%eax
ffffffff80004673:	0f 87 e5 f8 ff ff    	ja     ffffffff80003f5e <flanterm_write+0xf9e>
                    ctx->clear(ctx, false);
ffffffff80004679:	31 f6                	xor    %esi,%esi
ffffffff8000467b:	48 89 df             	mov    %rbx,%rdi
ffffffff8000467e:	ff 93 f8 00 00 00    	call   *0xf8(%rbx)
                    break;
ffffffff80004684:	e9 d5 f8 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    ctx->set_cursor_pos(ctx, 0, 0);
ffffffff80004689:	31 d2                	xor    %edx,%edx
ffffffff8000468b:	31 f6                	xor    %esi,%esi
ffffffff8000468d:	48 89 df             	mov    %rbx,%rdi
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff80004690:	45 31 ff             	xor    %r15d,%r15d
                    ctx->set_cursor_pos(ctx, 0, 0);
ffffffff80004693:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff80004699:	4c 3b bb e0 00 00 00 	cmp    0xe0(%rbx),%r15
ffffffff800046a0:	0f 83 b8 f8 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                        for (size_t xc = 0; xc < ctx->cols; xc++) {
ffffffff800046a6:	45 31 e4             	xor    %r12d,%r12d
ffffffff800046a9:	48 83 bb e8 00 00 00 	cmpq   $0x0,0xe8(%rbx)
ffffffff800046b0:	00 
ffffffff800046b1:	75 12                	jne    ffffffff800046c5 <flanterm_write+0x1705>
ffffffff800046b3:	eb 40                	jmp    ffffffff800046f5 <flanterm_write+0x1735>
ffffffff800046b5:	0f 1f 00             	nopl   (%rax)
ffffffff800046b8:	49 83 c4 01          	add    $0x1,%r12
ffffffff800046bc:	4c 3b a3 e8 00 00 00 	cmp    0xe8(%rbx),%r12
ffffffff800046c3:	73 30                	jae    ffffffff800046f5 <flanterm_write+0x1735>
                            ctx->raw_putchar(ctx, ' ');
ffffffff800046c5:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff800046ca:	48 89 df             	mov    %rbx,%rdi
ffffffff800046cd:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                            if (xc == x && yc == y) {
ffffffff800046d3:	4c 39 64 24 10       	cmp    %r12,0x10(%rsp)
ffffffff800046d8:	75 de                	jne    ffffffff800046b8 <flanterm_write+0x16f8>
ffffffff800046da:	4c 39 7c 24 18       	cmp    %r15,0x18(%rsp)
ffffffff800046df:	75 d7                	jne    ffffffff800046b8 <flanterm_write+0x16f8>
                                ctx->set_cursor_pos(ctx, x, y);
ffffffff800046e1:	4c 89 fa             	mov    %r15,%rdx
ffffffff800046e4:	4c 89 e6             	mov    %r12,%rsi
ffffffff800046e7:	48 89 df             	mov    %rbx,%rdi
ffffffff800046ea:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                        if (b == true)
ffffffff800046f0:	e9 69 f8 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    for (size_t yc = 0; yc < ctx->rows; yc++) {
ffffffff800046f5:	49 83 c7 01          	add    $0x1,%r15
ffffffff800046f9:	eb 9e                	jmp    ffffffff80004699 <flanterm_write+0x16d9>
            if (will_be_in_scroll_region && dest_y < ctx->scroll_top_margin) {
ffffffff800046fb:	48 39 d0             	cmp    %rdx,%rax
ffffffff800046fe:	48 0f 42 c2          	cmovb  %rdx,%rax
ffffffff80004702:	e9 da fb ff ff       	jmp    ffffffff800042e1 <flanterm_write+0x1321>
        case 0x221e: return 236;
ffffffff80004707:	be ec 00 00 00       	mov    $0xec,%esi
ffffffff8000470c:	e9 5f ef ff ff       	jmp    ffffffff80003670 <flanterm_write+0x6b0>
    if (ctx->dec_private == true) {
ffffffff80004711:	40 84 f6             	test   %sil,%sil
ffffffff80004714:	0f 84 b8 f7 ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff8000471a:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
    if (ctx->esc_values_i == 0) {
ffffffff8000471e:	e9 a4 fa ff ff       	jmp    ffffffff800041c7 <flanterm_write+0x1207>
                ctx->cursor_enabled = false;
ffffffff80004723:	c6 43 09 00          	movb   $0x0,0x9(%rbx)
ffffffff80004727:	e9 36 f8 ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
                dest_y = ctx->scroll_bottom_margin - 1;
ffffffff8000472c:	48 8d 50 ff          	lea    -0x1(%rax),%rdx
            ctx->set_cursor_pos(ctx, x, dest_y);
ffffffff80004730:	e9 1b f8 ff ff       	jmp    ffffffff80003f50 <flanterm_write+0xf90>
            for (size_t i = ctx->cols - 1; ; i--) {
ffffffff80004735:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff8000473c:	4c 8d 60 ff          	lea    -0x1(%rax),%r12
ffffffff80004740:	eb 04                	jmp    ffffffff80004746 <flanterm_write+0x1786>
ffffffff80004742:	49 83 ec 01          	sub    $0x1,%r12
                ctx->move_character(ctx, i + ctx->esc_values[0], y, i, y);
ffffffff80004746:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000474b:	8b 73 78             	mov    0x78(%rbx),%esi
ffffffff8000474e:	4c 89 e1             	mov    %r12,%rcx
ffffffff80004751:	48 89 df             	mov    %rbx,%rdi
ffffffff80004754:	4c 01 e6             	add    %r12,%rsi
ffffffff80004757:	49 89 d0             	mov    %rdx,%r8
ffffffff8000475a:	ff 93 60 01 00 00    	call   *0x160(%rbx)
                ctx->set_cursor_pos(ctx, i, y);
ffffffff80004760:	4c 89 e6             	mov    %r12,%rsi
ffffffff80004763:	48 89 df             	mov    %rbx,%rdi
ffffffff80004766:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000476b:	ff 93 00 01 00 00    	call   *0x100(%rbx)
                ctx->raw_putchar(ctx, ' ');
ffffffff80004771:	be 20 00 00 00       	mov    $0x20,%esi
ffffffff80004776:	48 89 df             	mov    %rbx,%rdi
ffffffff80004779:	ff 93 f0 00 00 00    	call   *0xf0(%rbx)
                if (i == x) {
ffffffff8000477f:	4c 3b 64 24 10       	cmp    0x10(%rsp),%r12
ffffffff80004784:	75 bc                	jne    ffffffff80004742 <flanterm_write+0x1782>
            ctx->set_cursor_pos(ctx, x, y);
ffffffff80004786:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000478b:	4c 89 e6             	mov    %r12,%rsi
ffffffff8000478e:	48 89 df             	mov    %rbx,%rdi
ffffffff80004791:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004797:	e9 c2 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->esc_values_i == 0) {
ffffffff8000479c:	48 8b 53 40          	mov    0x40(%rbx),%rdx
ffffffff800047a0:	48 85 d2             	test   %rdx,%rdx
ffffffff800047a3:	0f 84 b5 f7 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->callback != NULL) {
ffffffff800047a9:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800047b0:	48 85 c0             	test   %rax,%rax
ffffffff800047b3:	0f 84 a5 f7 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
        ctx->callback(ctx, FLANTERM_CB_LINUX, ctx->esc_values_i, (uintptr_t)ctx->esc_values, 0);
ffffffff800047b9:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff800047bd:	45 31 c0             	xor    %r8d,%r8d
ffffffff800047c0:	be 50 00 00 00       	mov    $0x50,%esi
ffffffff800047c5:	48 89 df             	mov    %rbx,%rdi
ffffffff800047c8:	ff d0                	call   *%rax
ffffffff800047ca:	e9 8f f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (x + ctx->esc_values[0] > ctx->cols - 1)
ffffffff800047cf:	48 8b 4c 24 10       	mov    0x10(%rsp),%rcx
ffffffff800047d4:	48 8b 83 e8 00 00 00 	mov    0xe8(%rbx),%rax
ffffffff800047db:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff800047de:	48 8d 78 ff          	lea    -0x1(%rax),%rdi
ffffffff800047e2:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff800047e6:	48 39 f7             	cmp    %rsi,%rdi
ffffffff800047e9:	73 08                	jae    ffffffff800047f3 <flanterm_write+0x1833>
                ctx->esc_values[0] = (ctx->cols - 1) - x;
ffffffff800047eb:	29 c8                	sub    %ecx,%eax
ffffffff800047ed:	8d 50 ff             	lea    -0x1(%rax),%edx
ffffffff800047f0:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, x + ctx->esc_values[0], y);
ffffffff800047f3:	48 8d 34 0a          	lea    (%rdx,%rcx,1),%rsi
ffffffff800047f7:	48 89 df             	mov    %rbx,%rdi
ffffffff800047fa:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff800047ff:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004805:	e9 54 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->esc_values[0] -= 1;
ffffffff8000480a:	8b 43 78             	mov    0x78(%rbx),%eax
            if (ctx->esc_values[0] >= ctx->cols)
ffffffff8000480d:	48 8b 93 e8 00 00 00 	mov    0xe8(%rbx),%rdx
            ctx->esc_values[0] -= 1;
ffffffff80004814:	83 e8 01             	sub    $0x1,%eax
ffffffff80004817:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[0] >= ctx->cols)
ffffffff8000481a:	48 39 d0             	cmp    %rdx,%rax
ffffffff8000481d:	72 06                	jb     ffffffff80004825 <flanterm_write+0x1865>
                ctx->esc_values[0] = ctx->cols - 1;
ffffffff8000481f:	83 ea 01             	sub    $0x1,%edx
ffffffff80004822:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, ctx->esc_values[0], y);
ffffffff80004825:	8b 73 78             	mov    0x78(%rbx),%esi
ffffffff80004828:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff8000482d:	48 89 df             	mov    %rbx,%rdi
ffffffff80004830:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004836:	e9 23 f7 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->esc_values[0] > x)
ffffffff8000483b:	48 8b 44 24 10       	mov    0x10(%rsp),%rax
ffffffff80004840:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004843:	48 39 d0             	cmp    %rdx,%rax
ffffffff80004846:	73 05                	jae    ffffffff8000484d <flanterm_write+0x188d>
                ctx->esc_values[0] = x;
ffffffff80004848:	89 43 78             	mov    %eax,0x78(%rbx)
ffffffff8000484b:	89 c2                	mov    %eax,%edx
            ctx->set_cursor_pos(ctx, x - ctx->esc_values[0], y);
ffffffff8000484d:	48 29 d0             	sub    %rdx,%rax
ffffffff80004850:	48 89 df             	mov    %rbx,%rdi
ffffffff80004853:	48 8b 54 24 18       	mov    0x18(%rsp),%rdx
ffffffff80004858:	48 89 c6             	mov    %rax,%rsi
ffffffff8000485b:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff80004861:	e9 f8 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
    if (ctx->dec_private == true) {
ffffffff80004866:	40 84 f6             	test   %sil,%sil
ffffffff80004869:	0f 84 63 f6 ff ff    	je     ffffffff80003ed2 <flanterm_write+0xf12>
    ctx->dec_private = false;
ffffffff8000486f:	c6 43 14 00          	movb   $0x0,0x14(%rbx)
ffffffff80004873:	e9 ea f6 ff ff       	jmp    ffffffff80003f62 <flanterm_write+0xfa2>
            switch (ctx->esc_values[0]) {
ffffffff80004878:	8b 43 78             	mov    0x78(%rbx),%eax
ffffffff8000487b:	83 f8 05             	cmp    $0x5,%eax
ffffffff8000487e:	74 53                	je     ffffffff800048d3 <flanterm_write+0x1913>
ffffffff80004880:	83 f8 06             	cmp    $0x6,%eax
ffffffff80004883:	0f 85 d5 f6 ff ff    	jne    ffffffff80003f5e <flanterm_write+0xf9e>
                    if (ctx->callback != NULL) {
ffffffff80004889:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004890:	48 85 c0             	test   %rax,%rax
ffffffff80004893:	0f 84 c5 f6 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                        ctx->callback(ctx, FLANTERM_CB_POS_REPORT, x + 1, y + 1, 0);
ffffffff80004899:	48 8b 7c 24 10       	mov    0x10(%rsp),%rdi
ffffffff8000489e:	48 8b 4c 24 18       	mov    0x18(%rsp),%rcx
ffffffff800048a3:	45 31 c0             	xor    %r8d,%r8d
ffffffff800048a6:	be 32 00 00 00       	mov    $0x32,%esi
ffffffff800048ab:	48 8d 57 01          	lea    0x1(%rdi),%rdx
ffffffff800048af:	48 83 c1 01          	add    $0x1,%rcx
ffffffff800048b3:	48 89 df             	mov    %rbx,%rdi
ffffffff800048b6:	ff d0                	call   *%rax
ffffffff800048b8:	e9 a1 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->set_cursor_pos(ctx, ctx->saved_cursor_x, ctx->saved_cursor_y);
ffffffff800048bd:	48 8b 53 50          	mov    0x50(%rbx),%rdx
ffffffff800048c1:	48 8b 73 48          	mov    0x48(%rbx),%rsi
ffffffff800048c5:	48 89 df             	mov    %rbx,%rdi
ffffffff800048c8:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff800048ce:	e9 8b f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
                    if (ctx->callback != NULL) {
ffffffff800048d3:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800048da:	48 85 c0             	test   %rax,%rax
ffffffff800048dd:	0f 84 7b f6 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                        ctx->callback(ctx, FLANTERM_CB_STATUS_REPORT, 0, 0, 0);
ffffffff800048e3:	45 31 c0             	xor    %r8d,%r8d
ffffffff800048e6:	31 c9                	xor    %ecx,%ecx
ffffffff800048e8:	31 d2                	xor    %edx,%edx
ffffffff800048ea:	be 28 00 00 00       	mov    $0x28,%esi
ffffffff800048ef:	48 89 df             	mov    %rbx,%rdi
ffffffff800048f2:	ff d0                	call   *%rax
ffffffff800048f4:	e9 65 f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->get_cursor_pos(ctx, &ctx->saved_cursor_x, &ctx->saved_cursor_y);
ffffffff800048f9:	48 8d 53 50          	lea    0x50(%rbx),%rdx
ffffffff800048fd:	48 8d 73 48          	lea    0x48(%rbx),%rsi
ffffffff80004901:	48 89 df             	mov    %rbx,%rdi
ffffffff80004904:	ff 93 08 01 00 00    	call   *0x108(%rbx)
            break;
ffffffff8000490a:	e9 4f f6 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->esc_values[0] == 0) {
ffffffff8000490f:	83 7b 78 00          	cmpl   $0x0,0x78(%rbx)
ffffffff80004913:	75 07                	jne    ffffffff8000491c <flanterm_write+0x195c>
                ctx->esc_values[0] = 1;
ffffffff80004915:	c7 43 78 01 00 00 00 	movl   $0x1,0x78(%rbx)
            if (ctx->esc_values[1] == 0) {
ffffffff8000491c:	83 7b 7c 00          	cmpl   $0x0,0x7c(%rbx)
ffffffff80004920:	75 07                	jne    ffffffff80004929 <flanterm_write+0x1969>
                ctx->esc_values[1] = 1;
ffffffff80004922:	c7 43 7c 01 00 00 00 	movl   $0x1,0x7c(%rbx)
            ctx->scroll_bottom_margin = ctx->rows;
ffffffff80004929:	48 8b 93 e0 00 00 00 	mov    0xe0(%rbx),%rdx
            if (ctx->esc_values_i > 0) {
ffffffff80004930:	48 8b 43 40          	mov    0x40(%rbx),%rax
            ctx->scroll_top_margin = 0;
ffffffff80004934:	31 f6                	xor    %esi,%esi
ffffffff80004936:	48 89 73 68          	mov    %rsi,0x68(%rbx)
            ctx->scroll_bottom_margin = ctx->rows;
ffffffff8000493a:	48 89 53 70          	mov    %rdx,0x70(%rbx)
            if (ctx->esc_values_i > 0) {
ffffffff8000493e:	48 85 c0             	test   %rax,%rax
ffffffff80004941:	74 3d                	je     ffffffff80004980 <flanterm_write+0x19c0>
                ctx->scroll_top_margin = ctx->esc_values[0] - 1;
ffffffff80004943:	8b 4b 78             	mov    0x78(%rbx),%ecx
ffffffff80004946:	83 e9 01             	sub    $0x1,%ecx
            if (ctx->esc_values_i > 1) {
ffffffff80004949:	48 83 e8 01          	sub    $0x1,%rax
                ctx->scroll_top_margin = ctx->esc_values[0] - 1;
ffffffff8000494d:	48 89 4b 68          	mov    %rcx,0x68(%rbx)
            if (ctx->esc_values_i > 1) {
ffffffff80004951:	74 2d                	je     ffffffff80004980 <flanterm_write+0x19c0>
                ctx->scroll_bottom_margin = ctx->esc_values[1];
ffffffff80004953:	8b 43 7c             	mov    0x7c(%rbx),%eax
ffffffff80004956:	48 89 43 70          	mov    %rax,0x70(%rbx)
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff8000495a:	48 39 d1             	cmp    %rdx,%rcx
ffffffff8000495d:	73 05                	jae    ffffffff80004964 <flanterm_write+0x19a4>
             || ctx->scroll_bottom_margin > ctx->rows
ffffffff8000495f:	48 39 c2             	cmp    %rax,%rdx
ffffffff80004962:	73 28                	jae    ffffffff8000498c <flanterm_write+0x19cc>
                ctx->scroll_top_margin = 0;
ffffffff80004964:	31 c9                	xor    %ecx,%ecx
                ctx->scroll_bottom_margin = ctx->rows;
ffffffff80004966:	48 89 53 70          	mov    %rdx,0x70(%rbx)
                ctx->scroll_top_margin = 0;
ffffffff8000496a:	48 89 4b 68          	mov    %rcx,0x68(%rbx)
            ctx->set_cursor_pos(ctx, 0, 0);
ffffffff8000496e:	31 d2                	xor    %edx,%edx
ffffffff80004970:	31 f6                	xor    %esi,%esi
ffffffff80004972:	48 89 df             	mov    %rbx,%rdi
ffffffff80004975:	ff 93 00 01 00 00    	call   *0x100(%rbx)
            break;
ffffffff8000497b:	e9 de f5 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff80004980:	48 8b 4b 68          	mov    0x68(%rbx),%rcx
             || ctx->scroll_bottom_margin > ctx->rows
ffffffff80004984:	48 89 d0             	mov    %rdx,%rax
            if (ctx->scroll_top_margin >= ctx->rows
ffffffff80004987:	48 39 d1             	cmp    %rdx,%rcx
ffffffff8000498a:	73 d8                	jae    ffffffff80004964 <flanterm_write+0x19a4>
             || ctx->scroll_top_margin >= (ctx->scroll_bottom_margin - 1)) {
ffffffff8000498c:	48 83 e8 01          	sub    $0x1,%rax
ffffffff80004990:	48 39 c1             	cmp    %rax,%rcx
ffffffff80004993:	73 cf                	jae    ffffffff80004964 <flanterm_write+0x19a4>
ffffffff80004995:	eb d7                	jmp    ffffffff8000496e <flanterm_write+0x19ae>
    if (!ctx->esc_values_i)
ffffffff80004997:	4c 8b 63 40          	mov    0x40(%rbx),%r12
ffffffff8000499b:	4d 85 e4             	test   %r12,%r12
ffffffff8000499e:	0f 84 c8 00 00 00    	je     ffffffff80004a6c <flanterm_write+0x1aac>
    for (; i < ctx->esc_values_i; i++) {
ffffffff800049a4:	4c 89 e6             	mov    %r12,%rsi
    size_t i = 0;
ffffffff800049a7:	45 31 e4             	xor    %r12d,%r12d
        if (ctx->esc_values[i] == 0) {
ffffffff800049aa:	4a 8d 0c a3          	lea    (%rbx,%r12,4),%rcx
ffffffff800049ae:	8b 51 78             	mov    0x78(%rcx),%edx
ffffffff800049b1:	83 fa 6b             	cmp    $0x6b,%edx
ffffffff800049b4:	77 71                	ja     ffffffff80004a27 <flanterm_write+0x1a67>
ffffffff800049b6:	89 d0                	mov    %edx,%eax
ffffffff800049b8:	3e ff 24 c5 e8 9d 00 	notrack jmp *-0x7fff6218(,%rax,8)
ffffffff800049bf:	80 
    if (ctx->esc_values_i == 0) {
ffffffff800049c0:	48 8b 53 40          	mov    0x40(%rbx),%rdx
ffffffff800049c4:	48 85 d2             	test   %rdx,%rdx
ffffffff800049c7:	0f 84 91 f5 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
    switch (c) {
ffffffff800049cd:	41 80 fc 68          	cmp    $0x68,%r12b
ffffffff800049d1:	0f 94 c0             	sete   %al
    switch (ctx->esc_values[0]) {
ffffffff800049d4:	83 7b 78 04          	cmpl   $0x4,0x78(%rbx)
ffffffff800049d8:	0f 84 86 00 00 00    	je     ffffffff80004a64 <flanterm_write+0x1aa4>
    if (ctx->callback != NULL) {
ffffffff800049de:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff800049e5:	48 85 c0             	test   %rax,%rax
ffffffff800049e8:	0f 84 70 f5 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
        ctx->callback(ctx, FLANTERM_CB_MODE, ctx->esc_values_i, (uintptr_t)ctx->esc_values, c);
ffffffff800049ee:	48 8d 4b 78          	lea    0x78(%rbx),%rcx
ffffffff800049f2:	4d 0f be c4          	movsbq %r12b,%r8
ffffffff800049f6:	be 46 00 00 00       	mov    $0x46,%esi
ffffffff800049fb:	48 89 df             	mov    %rbx,%rdi
ffffffff800049fe:	ff d0                	call   *%rax
ffffffff80004a00:	e9 59 f5 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004a05:	48 8d 50 9c          	lea    -0x64(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004a09:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004a0d:	48 89 53 60          	mov    %rdx,0x60(%rbx)
            offset = 100;
ffffffff80004a11:	ba 64 00 00 00       	mov    $0x64,%edx
            if (ctx->reverse_video) {
ffffffff80004a16:	75 3b                	jne    ffffffff80004a53 <flanterm_write+0x1a93>
            ctx->set_text_bg_bright(ctx, ctx->esc_values[i] - offset);
ffffffff80004a18:	48 29 d0             	sub    %rdx,%rax
ffffffff80004a1b:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a1e:	48 89 c6             	mov    %rax,%rsi
ffffffff80004a21:	ff 93 28 01 00 00    	call   *0x128(%rbx)
            continue;
ffffffff80004a27:	4d 89 e7             	mov    %r12,%r15
    for (; i < ctx->esc_values_i; i++) {
ffffffff80004a2a:	48 8b 73 40          	mov    0x40(%rbx),%rsi
ffffffff80004a2e:	4d 8d 67 01          	lea    0x1(%r15),%r12
ffffffff80004a32:	49 39 f4             	cmp    %rsi,%r12
ffffffff80004a35:	0f 83 23 f5 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
ffffffff80004a3b:	e9 6a ff ff ff       	jmp    ffffffff800049aa <flanterm_write+0x19ea>
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004a40:	48 8d 50 a6          	lea    -0x5a(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004a44:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004a48:	48 89 53 58          	mov    %rdx,0x58(%rbx)
            offset = 90;
ffffffff80004a4c:	ba 5a 00 00 00       	mov    $0x5a,%edx
            if (ctx->reverse_video) {
ffffffff80004a51:	75 c5                	jne    ffffffff80004a18 <flanterm_write+0x1a58>
            ctx->set_text_fg_bright(ctx, ctx->esc_values[i] - offset);
ffffffff80004a53:	48 29 d0             	sub    %rdx,%rax
ffffffff80004a56:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a59:	48 89 c6             	mov    %rax,%rsi
ffffffff80004a5c:	ff 93 20 01 00 00    	call   *0x120(%rbx)
            continue;
ffffffff80004a62:	eb c3                	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            ctx->insert_mode = set; return;
ffffffff80004a64:	88 43 15             	mov    %al,0x15(%rbx)
ffffffff80004a67:	e9 f2 f4 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->reverse_video) {
ffffffff80004a6c:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004a70:	74 0d                	je     ffffffff80004a7f <flanterm_write+0x1abf>
                ctx->reverse_video = false;
ffffffff80004a72:	c6 43 13 00          	movb   $0x0,0x13(%rbx)
                ctx->swap_palette(ctx);
ffffffff80004a76:	48 89 df             	mov    %rbx,%rdi
ffffffff80004a79:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            ctx->set_text_bg_default(ctx);
ffffffff80004a7f:	48 89 df             	mov    %rbx,%rdi
            ctx->bold = false;
ffffffff80004a82:	66 c7 43 11 00 00    	movw   $0x0,0x11(%rbx)
            continue;
ffffffff80004a88:	4d 89 e7             	mov    %r12,%r15
            ctx->current_primary = (size_t)-1;
ffffffff80004a8b:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80004a92:	ff 
            ctx->current_bg = (size_t)-1;
ffffffff80004a93:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80004a9a:	ff 
            ctx->set_text_bg_default(ctx);
ffffffff80004a9b:	ff 93 48 01 00 00    	call   *0x148(%rbx)
            ctx->set_text_fg_default(ctx);
ffffffff80004aa1:	48 89 df             	mov    %rbx,%rdi
ffffffff80004aa4:	ff 93 40 01 00 00    	call   *0x140(%rbx)
            continue;
ffffffff80004aaa:	e9 7b ff ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            ctx->esc_values[0] -= 1;
ffffffff80004aaf:	8b 43 78             	mov    0x78(%rbx),%eax
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff80004ab2:	48 8b 93 e0 00 00 00 	mov    0xe0(%rbx),%rdx
            ctx->esc_values[0] -= 1;
ffffffff80004ab9:	83 e8 01             	sub    $0x1,%eax
ffffffff80004abc:	89 43 78             	mov    %eax,0x78(%rbx)
            if (ctx->esc_values[0] >= ctx->rows)
ffffffff80004abf:	48 39 d0             	cmp    %rdx,%rax
ffffffff80004ac2:	72 06                	jb     ffffffff80004aca <flanterm_write+0x1b0a>
                ctx->esc_values[0] = ctx->rows - 1;
ffffffff80004ac4:	83 ea 01             	sub    $0x1,%edx
ffffffff80004ac7:	89 53 78             	mov    %edx,0x78(%rbx)
            ctx->set_cursor_pos(ctx, x, ctx->esc_values[0]);
ffffffff80004aca:	8b 53 78             	mov    0x78(%rbx),%edx
ffffffff80004acd:	e9 7e f4 ff ff       	jmp    ffffffff80003f50 <flanterm_write+0xf90>
            if (ctx->callback != NULL) {
ffffffff80004ad2:	48 8b 83 a8 01 00 00 	mov    0x1a8(%rbx),%rax
ffffffff80004ad9:	48 85 c0             	test   %rax,%rax
ffffffff80004adc:	0f 84 7c f4 ff ff    	je     ffffffff80003f5e <flanterm_write+0xf9e>
                ctx->callback(ctx, FLANTERM_CB_PRIVATE_ID, 0, 0, 0);
ffffffff80004ae2:	45 31 c0             	xor    %r8d,%r8d
ffffffff80004ae5:	31 c9                	xor    %ecx,%ecx
ffffffff80004ae7:	31 d2                	xor    %edx,%edx
ffffffff80004ae9:	be 1e 00 00 00       	mov    $0x1e,%esi
ffffffff80004aee:	48 89 df             	mov    %rbx,%rdi
ffffffff80004af1:	ff d0                	call   *%rax
ffffffff80004af3:	e9 66 f4 ff ff       	jmp    ffffffff80003f5e <flanterm_write+0xf9e>
            if (ctx->reverse_video) {
ffffffff80004af8:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = (size_t)-1;
ffffffff80004afc:	48 c7 43 60 ff ff ff 	movq   $0xffffffffffffffff,0x60(%rbx)
ffffffff80004b03:	ff 
            if (ctx->reverse_video) {
ffffffff80004b04:	74 09                	je     ffffffff80004b0f <flanterm_write+0x1b4f>
                ctx->swap_palette(ctx);
ffffffff80004b06:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b09:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            if (!ctx->bg_bold) {
ffffffff80004b0f:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
                ctx->set_text_bg_default(ctx);
ffffffff80004b13:	48 89 df             	mov    %rbx,%rdi
            if (!ctx->bg_bold) {
ffffffff80004b16:	75 77                	jne    ffffffff80004b8f <flanterm_write+0x1bcf>
                ctx->set_text_bg_default(ctx);
ffffffff80004b18:	ff 93 48 01 00 00    	call   *0x148(%rbx)
            if (ctx->reverse_video) {
ffffffff80004b1e:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004b22:	0f 84 ff fe ff ff    	je     ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->swap_palette(ctx);
ffffffff80004b28:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b2b:	ff 93 78 01 00 00    	call   *0x178(%rbx)
ffffffff80004b31:	e9 f1 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004b36:	48 8d 50 d8          	lea    -0x28(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004b3a:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_bg = ctx->esc_values[i] - offset;
ffffffff80004b3e:	48 89 53 60          	mov    %rdx,0x60(%rbx)
            if (ctx->reverse_video) {
ffffffff80004b42:	75 53                	jne    ffffffff80004b97 <flanterm_write+0x1bd7>
             || (ctx->bg_bold && !ctx->reverse_video)) {
ffffffff80004b44:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
ffffffff80004b48:	ba 28 00 00 00       	mov    $0x28,%edx
ffffffff80004b4d:	0f 85 c5 fe ff ff    	jne    ffffffff80004a18 <flanterm_write+0x1a58>
                ctx->set_text_bg(ctx, ctx->esc_values[i] - offset);
ffffffff80004b53:	48 29 d0             	sub    %rdx,%rax
ffffffff80004b56:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b59:	48 89 c6             	mov    %rax,%rsi
ffffffff80004b5c:	ff 93 18 01 00 00    	call   *0x118(%rbx)
ffffffff80004b62:	e9 c0 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            if (ctx->reverse_video) {
ffffffff80004b67:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            ctx->current_primary = (size_t)-1;
ffffffff80004b6b:	48 c7 43 58 ff ff ff 	movq   $0xffffffffffffffff,0x58(%rbx)
ffffffff80004b72:	ff 
            if (ctx->reverse_video) {
ffffffff80004b73:	74 09                	je     ffffffff80004b7e <flanterm_write+0x1bbe>
                ctx->swap_palette(ctx);
ffffffff80004b75:	48 89 df             	mov    %rbx,%rdi
ffffffff80004b78:	ff 93 78 01 00 00    	call   *0x178(%rbx)
            if (!ctx->bold) {
ffffffff80004b7e:	80 7b 11 00          	cmpb   $0x0,0x11(%rbx)
                ctx->set_text_fg_default(ctx);
ffffffff80004b82:	48 89 df             	mov    %rbx,%rdi
            if (!ctx->bold) {
ffffffff80004b85:	75 33                	jne    ffffffff80004bba <flanterm_write+0x1bfa>
                ctx->set_text_fg_default(ctx);
ffffffff80004b87:	ff 93 40 01 00 00    	call   *0x140(%rbx)
ffffffff80004b8d:	eb 8f                	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
                ctx->set_text_bg_default_bright(ctx);
ffffffff80004b8f:	ff 93 58 01 00 00    	call   *0x158(%rbx)
ffffffff80004b95:	eb 87                	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
             || (ctx->bg_bold && ctx->reverse_video)) {
ffffffff80004b97:	80 7b 12 00          	cmpb   $0x0,0x12(%rbx)
ffffffff80004b9b:	ba 28 00 00 00       	mov    $0x28,%edx
ffffffff80004ba0:	0f 85 ad fe ff ff    	jne    ffffffff80004a53 <flanterm_write+0x1a93>
                ctx->set_text_fg(ctx, ctx->esc_values[i] - offset);
ffffffff80004ba6:	48 29 d0             	sub    %rdx,%rax
ffffffff80004ba9:	48 89 df             	mov    %rbx,%rdi
ffffffff80004bac:	48 89 c6             	mov    %rax,%rsi
ffffffff80004baf:	ff 93 10 01 00 00    	call   *0x110(%rbx)
ffffffff80004bb5:	e9 6d fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->set_text_fg_default_bright(ctx);
ffffffff80004bba:	ff 93 50 01 00 00    	call   *0x150(%rbx)
            if (ctx->reverse_video) {
ffffffff80004bc0:	e9 59 ff ff ff       	jmp    ffffffff80004b1e <flanterm_write+0x1b5e>
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004bc5:	48 8b 73 58          	mov    0x58(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004bc9:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bold = false;
ffffffff80004bcd:	c6 43 11 00          	movb   $0x0,0x11(%rbx)
                    ctx->set_text_fg(ctx, ctx->current_primary);
ffffffff80004bd1:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004bd4:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004bd8:	74 26                	je     ffffffff80004c00 <flanterm_write+0x1c40>
                if (!ctx->reverse_video) {
ffffffff80004bda:	84 c0                	test   %al,%al
ffffffff80004bdc:	0f 85 7a ff ff ff    	jne    ffffffff80004b5c <flanterm_write+0x1b9c>
ffffffff80004be2:	eb cb                	jmp    ffffffff80004baf <flanterm_write+0x1bef>
            if (!ctx->reverse_video) {
ffffffff80004be4:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004be8:	0f 85 39 fe ff ff    	jne    ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->reverse_video = true;
ffffffff80004bee:	c6 43 13 01          	movb   $0x1,0x13(%rbx)
                ctx->swap_palette(ctx);
ffffffff80004bf2:	48 89 df             	mov    %rbx,%rdi
ffffffff80004bf5:	ff 93 78 01 00 00    	call   *0x178(%rbx)
ffffffff80004bfb:	e9 27 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c00:	84 c0                	test   %al,%al
ffffffff80004c02:	75 53                	jne    ffffffff80004c57 <flanterm_write+0x1c97>
                    ctx->set_text_fg_default(ctx);
ffffffff80004c04:	ff 93 40 01 00 00    	call   *0x140(%rbx)
ffffffff80004c0a:	e9 18 fe ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004c0f:	48 8b 73 60          	mov    0x60(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004c13:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bg_bold = true;
ffffffff80004c17:	c6 43 12 01          	movb   $0x1,0x12(%rbx)
                    ctx->set_text_bg_bright(ctx, ctx->current_bg);
ffffffff80004c1b:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004c1e:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004c22:	74 3e                	je     ffffffff80004c62 <flanterm_write+0x1ca2>
                if (!ctx->reverse_video) {
ffffffff80004c24:	84 c0                	test   %al,%al
ffffffff80004c26:	0f 85 30 fe ff ff    	jne    ffffffff80004a5c <flanterm_write+0x1a9c>
ffffffff80004c2c:	e9 f0 fd ff ff       	jmp    ffffffff80004a21 <flanterm_write+0x1a61>
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004c31:	48 8b 73 58          	mov    0x58(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004c35:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bold = true;
ffffffff80004c39:	c6 43 11 01          	movb   $0x1,0x11(%rbx)
                    ctx->set_text_fg_bright(ctx, ctx->current_primary);
ffffffff80004c3d:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_primary != (size_t)-1) {
ffffffff80004c40:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004c44:	74 2b                	je     ffffffff80004c71 <flanterm_write+0x1cb1>
                if (!ctx->reverse_video) {
ffffffff80004c46:	84 c0                	test   %al,%al
ffffffff80004c48:	0f 85 d3 fd ff ff    	jne    ffffffff80004a21 <flanterm_write+0x1a61>
ffffffff80004c4e:	e9 09 fe ff ff       	jmp    ffffffff80004a5c <flanterm_write+0x1a9c>
                if (!ctx->reverse_video) {
ffffffff80004c53:	84 c0                	test   %al,%al
ffffffff80004c55:	75 ad                	jne    ffffffff80004c04 <flanterm_write+0x1c44>
                    ctx->set_text_bg_default(ctx);
ffffffff80004c57:	ff 93 48 01 00 00    	call   *0x148(%rbx)
ffffffff80004c5d:	e9 c5 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c62:	84 c0                	test   %al,%al
ffffffff80004c64:	75 0f                	jne    ffffffff80004c75 <flanterm_write+0x1cb5>
                    ctx->set_text_bg_default_bright(ctx);
ffffffff80004c66:	ff 93 58 01 00 00    	call   *0x158(%rbx)
ffffffff80004c6c:	e9 b6 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
                if (!ctx->reverse_video) {
ffffffff80004c71:	84 c0                	test   %al,%al
ffffffff80004c73:	75 f1                	jne    ffffffff80004c66 <flanterm_write+0x1ca6>
                    ctx->set_text_fg_default_bright(ctx);
ffffffff80004c75:	ff 93 50 01 00 00    	call   *0x150(%rbx)
ffffffff80004c7b:	e9 a7 fd ff ff       	jmp    ffffffff80004a27 <flanterm_write+0x1a67>
            i++;
ffffffff80004c80:	4d 8d 7c 24 01       	lea    0x1(%r12),%r15
            if (i >= ctx->esc_values_i) {
ffffffff80004c85:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004c88:	0f 83 d0 f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
            switch (ctx->esc_values[i]) {
ffffffff80004c8e:	8b 41 7c             	mov    0x7c(%rcx),%eax
ffffffff80004c91:	83 f8 02             	cmp    $0x2,%eax
ffffffff80004c94:	0f 84 a3 00 00 00    	je     ffffffff80004d3d <flanterm_write+0x1d7d>
ffffffff80004c9a:	83 f8 05             	cmp    $0x5,%eax
ffffffff80004c9d:	0f 85 87 fd ff ff    	jne    ffffffff80004a2a <flanterm_write+0x1a6a>
                    if (i + 1 >= ctx->esc_values_i) {
ffffffff80004ca3:	4d 8d 7c 24 02       	lea    0x2(%r12),%r15
ffffffff80004ca8:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004cab:	0f 83 ad f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                    uint32_t col = ctx->esc_values[i + 1];
ffffffff80004cb1:	8b 81 80 00 00 00    	mov    0x80(%rcx),%eax
                    if (col < 8) {
ffffffff80004cb7:	83 f8 07             	cmp    $0x7,%eax
ffffffff80004cba:	77 46                	ja     ffffffff80004d02 <flanterm_write+0x1d42>
                        (fg ? ctx->set_text_fg : ctx->set_text_bg)(ctx, col);
ffffffff80004cbc:	48 8b 8b 18 01 00 00 	mov    0x118(%rbx),%rcx
ffffffff80004cc3:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004cc6:	89 c6                	mov    %eax,%esi
ffffffff80004cc8:	48 89 df             	mov    %rbx,%rdi
ffffffff80004ccb:	48 0f 44 8b 10 01 00 	cmove  0x110(%rbx),%rcx
ffffffff80004cd2:	00 
ffffffff80004cd3:	ff d1                	call   *%rcx
ffffffff80004cd5:	e9 50 fd ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004cda:	48 8d 50 e2          	lea    -0x1e(%rax),%rdx
            if (ctx->reverse_video) {
ffffffff80004cde:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
            if ((ctx->bold && ctx->reverse_video)
ffffffff80004ce2:	0f b6 4b 11          	movzbl 0x11(%rbx),%ecx
            ctx->current_primary = ctx->esc_values[i] - offset;
ffffffff80004ce6:	48 89 53 58          	mov    %rdx,0x58(%rbx)
            if (ctx->reverse_video) {
ffffffff80004cea:	0f 85 91 00 00 00    	jne    ffffffff80004d81 <flanterm_write+0x1dc1>
            offset = 30;
ffffffff80004cf0:	ba 1e 00 00 00       	mov    $0x1e,%edx
            if ((ctx->bold && !ctx->reverse_video)
ffffffff80004cf5:	84 c9                	test   %cl,%cl
ffffffff80004cf7:	0f 84 a9 fe ff ff    	je     ffffffff80004ba6 <flanterm_write+0x1be6>
ffffffff80004cfd:	e9 51 fd ff ff       	jmp    ffffffff80004a53 <flanterm_write+0x1a93>
                    } else if (col < 16) {
ffffffff80004d02:	83 f8 0f             	cmp    $0xf,%eax
ffffffff80004d05:	0f 87 ae 00 00 00    	ja     ffffffff80004db9 <flanterm_write+0x1df9>
                        (fg ? ctx->set_text_fg_bright : ctx->set_text_bg_bright)(ctx, col - 8);
ffffffff80004d0b:	48 8b 8b 28 01 00 00 	mov    0x128(%rbx),%rcx
ffffffff80004d12:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004d15:	8d 70 f8             	lea    -0x8(%rax),%esi
ffffffff80004d18:	48 89 df             	mov    %rbx,%rdi
ffffffff80004d1b:	48 0f 44 8b 20 01 00 	cmove  0x120(%rbx),%rcx
ffffffff80004d22:	00 
ffffffff80004d23:	ff d1                	call   *%rcx
ffffffff80004d25:	e9 00 fd ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            if (ctx->reverse_video) {
ffffffff80004d2a:	80 7b 13 00          	cmpb   $0x0,0x13(%rbx)
ffffffff80004d2e:	0f 84 f3 fc ff ff    	je     ffffffff80004a27 <flanterm_write+0x1a67>
                ctx->reverse_video = false;
ffffffff80004d34:	c6 43 13 00          	movb   $0x0,0x13(%rbx)
ffffffff80004d38:	e9 eb fd ff ff       	jmp    ffffffff80004b28 <flanterm_write+0x1b68>
                    if (i + 3 >= ctx->esc_values_i) {
ffffffff80004d3d:	4d 8d 7c 24 04       	lea    0x4(%r12),%r15
ffffffff80004d42:	49 39 f7             	cmp    %rsi,%r15
ffffffff80004d45:	0f 83 13 f2 ff ff    	jae    ffffffff80003f5e <flanterm_write+0xf9e>
                    rgb_value |= ctx->esc_values[i + 1] << 16;
ffffffff80004d4b:	8b b1 80 00 00 00    	mov    0x80(%rcx),%esi
                    rgb_value |= ctx->esc_values[i + 2] << 8;
ffffffff80004d51:	8b 81 84 00 00 00    	mov    0x84(%rcx),%eax
                    rgb_value |= ctx->esc_values[i + 1] << 16;
ffffffff80004d57:	c1 e6 10             	shl    $0x10,%esi
                    rgb_value |= ctx->esc_values[i + 2] << 8;
ffffffff80004d5a:	c1 e0 08             	shl    $0x8,%eax
ffffffff80004d5d:	09 c6                	or     %eax,%esi
                    rgb_value |= ctx->esc_values[i + 3];
ffffffff80004d5f:	0b b1 88 00 00 00    	or     0x88(%rcx),%esi
                        (fg ? ctx->set_text_fg_rgb : ctx->set_text_bg_rgb)(ctx, rgb_value);
ffffffff80004d65:	48 8b 83 38 01 00 00 	mov    0x138(%rbx),%rax
ffffffff80004d6c:	83 fa 26             	cmp    $0x26,%edx
ffffffff80004d6f:	48 89 df             	mov    %rbx,%rdi
ffffffff80004d72:	48 0f 44 83 30 01 00 	cmove  0x130(%rbx),%rax
ffffffff80004d79:	00 
ffffffff80004d7a:	ff d0                	call   *%rax
ffffffff80004d7c:	e9 a9 fc ff ff       	jmp    ffffffff80004a2a <flanterm_write+0x1a6a>
            offset = 30;
ffffffff80004d81:	ba 1e 00 00 00       	mov    $0x1e,%edx
            if ((ctx->bold && ctx->reverse_video)
ffffffff80004d86:	84 c9                	test   %cl,%cl
ffffffff80004d88:	0f 85 8a fc ff ff    	jne    ffffffff80004a18 <flanterm_write+0x1a58>
ffffffff80004d8e:	e9 c0 fd ff ff       	jmp    ffffffff80004b53 <flanterm_write+0x1b93>
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004d93:	48 8b 73 60          	mov    0x60(%rbx),%rsi
                if (!ctx->reverse_video) {
ffffffff80004d97:	0f b6 43 13          	movzbl 0x13(%rbx),%eax
            ctx->bg_bold = false;
ffffffff80004d9b:	c6 43 12 00          	movb   $0x0,0x12(%rbx)
                    ctx->set_text_bg(ctx, ctx->current_bg);
ffffffff80004d9f:	48 89 df             	mov    %rbx,%rdi
            if (ctx->current_bg != (size_t)-1) {
ffffffff80004da2:	48 83 fe ff          	cmp    $0xffffffffffffffff,%rsi
ffffffff80004da6:	0f 84 a7 fe ff ff    	je     ffffffff80004c53 <flanterm_write+0x1c93>
                if (!ctx->reverse_video) {
ffffffff80004dac:	84 c0                	test   %al,%al
ffffffff80004dae:	0f 85 fb fd ff ff    	jne    ffffffff80004baf <flanterm_write+0x1bef>
ffffffff80004db4:	e9 a3 fd ff ff       	jmp    ffffffff80004b5c <flanterm_write+0x1b9c>
                    } else if (col < 256) {
ffffffff80004db9:	3d ff 00 00 00       	cmp    $0xff,%eax
ffffffff80004dbe:	0f 87 66 fc ff ff    	ja     ffffffff80004a2a <flanterm_write+0x1a6a>
                        uint32_t rgb_value = col256[col - 16];
ffffffff80004dc4:	83 e8 10             	sub    $0x10,%eax
ffffffff80004dc7:	8b 34 85 e0 a5 00 80 	mov    -0x7fff5a20(,%rax,4),%esi
ffffffff80004dce:	eb 95                	jmp    ffffffff80004d65 <flanterm_write+0x1da5>

ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>:
ffffffff80004dd0:	f3 0f 1e fa          	endbr64
ffffffff80004dd4:	55                   	push   %rbp
ffffffff80004dd5:	48 89 f5             	mov    %rsi,%rbp
ffffffff80004dd8:	53                   	push   %rbx
ffffffff80004dd9:	48 89 fb             	mov    %rdi,%rbx
        #if defined (__x86_64__)
ffffffff80004ddc:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80004de3:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004de7:	e8 94 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004dec:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004def:	e8 8c 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004df4:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff80004dfb:	e8 80 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004e00:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004e04:	48 89 d8             	mov    %rbx,%rax
ffffffff80004e07:	5b                   	pop    %rbx
ffffffff80004e08:	5d                   	pop    %rbp
ffffffff80004e09:	c3                   	ret
ffffffff80004e0a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>:
ffffffff80004e10:	f3 0f 1e fa          	endbr64
ffffffff80004e14:	55                   	push   %rbp
ffffffff80004e15:	48 89 fd             	mov    %rdi,%rbp
        #if defined (__x86_64__)
ffffffff80004e18:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80004e1f:	53                   	push   %rbx
ffffffff80004e20:	89 f3                	mov    %esi,%ebx
ffffffff80004e22:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004e26:	e8 55 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004e2b:	8b 35 c7 62 00 00    	mov    0x62c7(%rip),%esi        # ffffffff8000b0f8 <kout>
ffffffff80004e31:	0f b6 fb             	movzbl %bl,%edi
ffffffff80004e34:	e8 67 1a 00 00       	call   ffffffff800068a0 <_ZN3Lib11int2basestrEim>
ffffffff80004e39:	48 89 c7             	mov    %rax,%rdi
ffffffff80004e3c:	e8 3f 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        #if defined (__x86_64__)
ffffffff80004e41:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff80004e48:	e8 33 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004e4d:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004e51:	48 89 e8             	mov    %rbp,%rax
ffffffff80004e54:	5b                   	pop    %rbx
ffffffff80004e55:	5d                   	pop    %rbp
ffffffff80004e56:	c3                   	ret
ffffffff80004e57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80004e5e:	00 00 

ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>:
ffffffff80004e60:	f3 0f 1e fa          	endbr64
ffffffff80004e64:	55                   	push   %rbp
ffffffff80004e65:	48 89 f5             	mov    %rsi,%rbp
ffffffff80004e68:	53                   	push   %rbx
ffffffff80004e69:	48 89 fb             	mov    %rdi,%rbx
        #if defined (__x86_64__)
ffffffff80004e6c:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80004e73:	48 83 ec 08          	sub    $0x8,%rsp
        #if defined (__x86_64__)
ffffffff80004e77:	e8 04 21 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004e7c:	8b 35 76 62 00 00    	mov    0x6276(%rip),%esi        # ffffffff8000b0f8 <kout>
ffffffff80004e82:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004e85:	e8 26 1b 00 00       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80004e8a:	48 89 c7             	mov    %rax,%rdi
ffffffff80004e8d:	e8 ee 20 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        #if defined (__x86_64__)
ffffffff80004e92:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff80004e99:	e8 e2 20 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004e9e:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80004ea2:	48 89 d8             	mov    %rbx,%rax
ffffffff80004ea5:	5b                   	pop    %rbx
ffffffff80004ea6:	5d                   	pop    %rbp
ffffffff80004ea7:	c3                   	ret
ffffffff80004ea8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80004eaf:	00 

ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>:
void Panic(const char *meditationString, System::PanicFrame* frame) {
ffffffff80004eb0:	f3 0f 1e fa          	endbr64
ffffffff80004eb4:	41 54                	push   %r12
ffffffff80004eb6:	55                   	push   %rbp
ffffffff80004eb7:	48 89 fd             	mov    %rdi,%rbp
    kerr << "\nGuru Meditation" << "\n" << "\n";
ffffffff80004eba:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
void Panic(const char *meditationString, System::PanicFrame* frame) {
ffffffff80004ec1:	53                   	push   %rbx
ffffffff80004ec2:	48 89 f3             	mov    %rsi,%rbx
    kerr << "\nGuru Meditation" << "\n" << "\n";
ffffffff80004ec5:	48 c7 c6 af a9 00 80 	mov    $0xffffffff8000a9af,%rsi
ffffffff80004ecc:	e8 ff fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ed1:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80004ed8:	48 89 c7             	mov    %rax,%rdi
ffffffff80004edb:	e8 f0 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ee0:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80004ee7:	48 89 c7             	mov    %rax,%rdi
ffffffff80004eea:	e8 e1 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
    kerr << "\t" << "MeditationString: " << meditationString << Kt::newline;
ffffffff80004eef:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80004ef6:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80004efd:	e8 ce fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f02:	48 c7 c6 c4 a9 00 80 	mov    $0xffffffff8000a9c4,%rsi
ffffffff80004f09:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f0c:	e8 bf fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f11:	48 89 ee             	mov    %rbp,%rsi
ffffffff80004f14:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f17:	e8 b4 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        base streamBaseType = base::dec;

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char *string)
        {
            Print(string);
ffffffff80004f1c:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80004f23:	e8 58 20 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        }

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char chr)
        {
            Putchar(chr);
ffffffff80004f28:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80004f2d:	e8 1e 20 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
            Print(string);
ffffffff80004f32:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff80004f39:	e8 42 20 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
    if (frame != nullptr) {
ffffffff80004f3e:	48 85 db             	test   %rbx,%rbx
ffffffff80004f41:	0f 84 b9 02 00 00    	je     ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350>
        kerr << "\t" << "InterruptVector: " << "0x" << base::hex << frame->InterruptVector << "\n";
ffffffff80004f47:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80004f4e:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80004f55:	e8 76 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f5a:	48 c7 c6 d7 a9 00 80 	mov    $0xffffffff8000a9d7,%rsi
ffffffff80004f61:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f64:	e8 67 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f69:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff80004f70:	48 89 c7             	mov    %rax,%rdi
ffffffff80004f73:	e8 58 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004f78:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80004f7f:	48 89 c5             	mov    %rax,%rbp
ffffffff80004f82:	e8 f9 1f 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004f87:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, base newBase)
        {
            t.streamBaseType = newBase;
ffffffff80004f8e:	c7 05 60 61 00 00 10 	movl   $0x10,0x6160(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80004f95:	00 00 00 
            Print(string);
ffffffff80004f98:	e8 e3 1f 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80004f9d:	0f b6 73 28          	movzbl 0x28(%rbx),%esi
ffffffff80004fa1:	48 89 ef             	mov    %rbp,%rdi
ffffffff80004fa4:	e8 67 fe ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80004fa9:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80004fb0:	48 89 c7             	mov    %rax,%rdi
ffffffff80004fb3:	e8 18 fe ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        if (frame->InterruptVector == 0xE) { // In case of #PF the CPU pushes an error code to the frame
ffffffff80004fb8:	0f b6 43 28          	movzbl 0x28(%rbx),%eax
ffffffff80004fbc:	3c 0e                	cmp    $0xe,%al
ffffffff80004fbe:	0f 84 40 02 00 00    	je     ffffffff80005204 <_Z5PanicPKcPN6System10PanicFrameE+0x354>
        else if (frame->InterruptVector == 0xD) {
ffffffff80004fc4:	3c 0d                	cmp    $0xd,%al
ffffffff80004fc6:	0f 84 7f 05 00 00    	je     ffffffff8000554b <_Z5PanicPKcPN6System10PanicFrameE+0x69b>
        kerr << "\t" << "InstructionPointer: " << "0x" << base::hex << frame->IP << "\n";
ffffffff80004fcc:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80004fd3:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80004fda:	e8 f1 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004fdf:	48 c7 c6 9d aa 00 80 	mov    $0xffffffff8000aa9d,%rsi
ffffffff80004fe6:	48 89 c7             	mov    %rax,%rdi
ffffffff80004fe9:	e8 e2 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004fee:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff80004ff5:	48 89 c7             	mov    %rax,%rdi
ffffffff80004ff8:	e8 d3 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80004ffd:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005004:	48 89 c5             	mov    %rax,%rbp
ffffffff80005007:	e8 74 1f 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000500c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005013:	c7 05 db 60 00 00 10 	movl   $0x10,0x60db(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000501a:	00 00 00 
            Print(string);
ffffffff8000501d:	e8 5e 1f 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005022:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005025:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005028:	e8 33 fe ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000502d:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005034:	48 89 c7             	mov    %rax,%rdi
ffffffff80005037:	e8 94 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "CodeSegment: " << "0x" << base::hex << frame->CS << "\n";
ffffffff8000503c:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005043:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff8000504a:	e8 81 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000504f:	48 c7 c6 b2 aa 00 80 	mov    $0xffffffff8000aab2,%rsi
ffffffff80005056:	48 89 c7             	mov    %rax,%rdi
ffffffff80005059:	e8 72 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000505e:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff80005065:	48 89 c7             	mov    %rax,%rdi
ffffffff80005068:	e8 63 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000506d:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005074:	48 89 c5             	mov    %rax,%rbp
ffffffff80005077:	e8 04 1f 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000507c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005083:	c7 05 6b 60 00 00 10 	movl   $0x10,0x606b(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000508a:	00 00 00 
            Print(string);
ffffffff8000508d:	e8 ee 1e 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005092:	48 8b 73 08          	mov    0x8(%rbx),%rsi
ffffffff80005096:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005099:	e8 c2 fd ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000509e:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff800050a5:	48 89 c7             	mov    %rax,%rdi
ffffffff800050a8:	e8 23 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "Flags: " << "0x" << base::hex << frame->Flags << "\n";
ffffffff800050ad:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff800050b4:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff800050bb:	e8 10 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050c0:	48 c7 c6 c0 aa 00 80 	mov    $0xffffffff8000aac0,%rsi
ffffffff800050c7:	48 89 c7             	mov    %rax,%rdi
ffffffff800050ca:	e8 01 fd ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050cf:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff800050d6:	48 89 c7             	mov    %rax,%rdi
ffffffff800050d9:	e8 f2 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800050de:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff800050e5:	48 89 c5             	mov    %rax,%rbp
ffffffff800050e8:	e8 93 1e 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800050ed:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800050f4:	c7 05 fa 5f 00 00 10 	movl   $0x10,0x5ffa(%rip)        # ffffffff8000b0f8 <kout>
ffffffff800050fb:	00 00 00 
            Print(string);
ffffffff800050fe:	e8 7d 1e 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005103:	48 8b 73 10          	mov    0x10(%rbx),%rsi
ffffffff80005107:	48 89 ef             	mov    %rbp,%rdi
ffffffff8000510a:	e8 51 fd ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000510f:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005116:	48 89 c7             	mov    %rax,%rdi
ffffffff80005119:	e8 b2 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "StackPointer: " << "0x" << base::hex << frame->SP << "\n";   
ffffffff8000511e:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005125:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff8000512c:	e8 9f fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005131:	48 c7 c6 c8 aa 00 80 	mov    $0xffffffff8000aac8,%rsi
ffffffff80005138:	48 89 c7             	mov    %rax,%rdi
ffffffff8000513b:	e8 90 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005140:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff80005147:	48 89 c7             	mov    %rax,%rdi
ffffffff8000514a:	e8 81 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000514f:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005156:	48 89 c5             	mov    %rax,%rbp
ffffffff80005159:	e8 22 1e 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000515e:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005165:	c7 05 89 5f 00 00 10 	movl   $0x10,0x5f89(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000516c:	00 00 00 
            Print(string);
ffffffff8000516f:	e8 0c 1e 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005174:	48 8b 73 18          	mov    0x18(%rbx),%rsi
ffffffff80005178:	48 89 ef             	mov    %rbp,%rdi
ffffffff8000517b:	e8 e0 fc ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff80005180:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005187:	48 89 c7             	mov    %rax,%rdi
ffffffff8000518a:	e8 41 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        kerr << "\t" << "StackSegment: " << "0x" << base::hex << frame->SS << "\n";   
ffffffff8000518f:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005196:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff8000519d:	e8 2e fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051a2:	48 c7 c6 d7 aa 00 80 	mov    $0xffffffff8000aad7,%rsi
ffffffff800051a9:	48 89 c7             	mov    %rax,%rdi
ffffffff800051ac:	e8 1f fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051b1:	48 c7 c6 04 ad 00 80 	mov    $0xffffffff8000ad04,%rsi
ffffffff800051b8:	48 89 c7             	mov    %rax,%rdi
ffffffff800051bb:	e8 10 fc ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800051c0:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff800051c7:	48 89 c5             	mov    %rax,%rbp
ffffffff800051ca:	e8 b1 1d 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800051cf:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800051d6:	c7 05 18 5f 00 00 10 	movl   $0x10,0x5f18(%rip)        # ffffffff8000b0f8 <kout>
ffffffff800051dd:	00 00 00 
            Print(string);
ffffffff800051e0:	e8 9b 1d 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800051e5:	48 8b 73 20          	mov    0x20(%rbx),%rsi
ffffffff800051e9:	48 89 ef             	mov    %rbp,%rdi
ffffffff800051ec:	e8 6f fc ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff800051f1:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff800051f8:	48 89 c7             	mov    %rax,%rdi
ffffffff800051fb:	e8 d0 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
        asm ("cli");
ffffffff80005200:	fa                   	cli
        asm ("hlt");
ffffffff80005201:	f4                   	hlt
    while (true) {
ffffffff80005202:	eb fc                	jmp    ffffffff80005200 <_Z5PanicPKcPN6System10PanicFrameE+0x350>
            kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n";
ffffffff80005204:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff8000520b:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
            frame = (System::PanicFrame*)&pf_frame->IP;
ffffffff80005212:	48 8d 6b 08          	lea    0x8(%rbx),%rbp
            kerr << "\t" << "PageFaultPresent: " << base::dec << pf_frame->PageFaultError.Present << "\n";
ffffffff80005216:	e8 b5 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000521b:	48 c7 c6 e9 a9 00 80 	mov    $0xffffffff8000a9e9,%rsi
ffffffff80005222:	48 89 c7             	mov    %rax,%rdi
ffffffff80005225:	e8 a6 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000522a:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005231:	49 89 c4             	mov    %rax,%r12
ffffffff80005234:	e8 47 1d 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005239:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005240:	c7 05 ae 5e 00 00 0a 	movl   $0xa,0x5eae(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80005247:	00 00 00 
            Print(string);
ffffffff8000524a:	e8 31 1d 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000524f:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005252:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005255:	83 e6 01             	and    $0x1,%esi
ffffffff80005258:	e8 b3 fb ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff8000525d:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005264:	48 89 c7             	mov    %rax,%rdi
ffffffff80005267:	e8 64 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultWrite: " << base::dec << pf_frame->PageFaultError.Write << "\n";
ffffffff8000526c:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005273:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff8000527a:	e8 51 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000527f:	48 c7 c6 fc a9 00 80 	mov    $0xffffffff8000a9fc,%rsi
ffffffff80005286:	48 89 c7             	mov    %rax,%rdi
ffffffff80005289:	e8 42 fb ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000528e:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005295:	49 89 c4             	mov    %rax,%r12
ffffffff80005298:	e8 e3 1c 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000529d:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800052a4:	c7 05 4a 5e 00 00 0a 	movl   $0xa,0x5e4a(%rip)        # ffffffff8000b0f8 <kout>
ffffffff800052ab:	00 00 00 
            Print(string);
ffffffff800052ae:	e8 cd 1c 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800052b3:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800052b6:	4c 89 e7             	mov    %r12,%rdi
ffffffff800052b9:	40 d0 ee             	shr    $1,%sil
ffffffff800052bc:	83 e6 01             	and    $0x1,%esi
ffffffff800052bf:	e8 4c fb ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800052c4:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff800052cb:	48 89 c7             	mov    %rax,%rdi
ffffffff800052ce:	e8 fd fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultUser: " << base::dec << pf_frame->PageFaultError.User << "\n";
ffffffff800052d3:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff800052da:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff800052e1:	e8 ea fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800052e6:	48 c7 c6 0d aa 00 80 	mov    $0xffffffff8000aa0d,%rsi
ffffffff800052ed:	48 89 c7             	mov    %rax,%rdi
ffffffff800052f0:	e8 db fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800052f5:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff800052fc:	49 89 c4             	mov    %rax,%r12
ffffffff800052ff:	e8 7c 1c 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005304:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff8000530b:	c7 05 e3 5d 00 00 0a 	movl   $0xa,0x5de3(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80005312:	00 00 00 
            Print(string);
ffffffff80005315:	e8 66 1c 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000531a:	0f b6 33             	movzbl (%rbx),%esi
ffffffff8000531d:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005320:	40 c0 ee 02          	shr    $0x2,%sil
ffffffff80005324:	83 e6 01             	and    $0x1,%esi
ffffffff80005327:	e8 e4 fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff8000532c:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005333:	48 89 c7             	mov    %rax,%rdi
ffffffff80005336:	e8 95 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultReservedWrite: " << base::dec << pf_frame->PageFaultError.ReservedWrite << "\n";
ffffffff8000533b:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005342:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80005349:	e8 82 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000534e:	48 c7 c6 1d aa 00 80 	mov    $0xffffffff8000aa1d,%rsi
ffffffff80005355:	48 89 c7             	mov    %rax,%rdi
ffffffff80005358:	e8 73 fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000535d:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005364:	49 89 c4             	mov    %rax,%r12
ffffffff80005367:	e8 14 1c 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000536c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005373:	c7 05 7b 5d 00 00 0a 	movl   $0xa,0x5d7b(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000537a:	00 00 00 
            Print(string);
ffffffff8000537d:	e8 fe 1b 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005382:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005385:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005388:	40 c0 ee 03          	shr    $0x3,%sil
ffffffff8000538c:	83 e6 01             	and    $0x1,%esi
ffffffff8000538f:	e8 7c fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005394:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff8000539b:	48 89 c7             	mov    %rax,%rdi
ffffffff8000539e:	e8 2d fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultInstructionFetch: " << base::dec << pf_frame->PageFaultError.InstructionFetch << "\n";
ffffffff800053a3:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff800053aa:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff800053b1:	e8 1a fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800053b6:	48 c7 c6 36 aa 00 80 	mov    $0xffffffff8000aa36,%rsi
ffffffff800053bd:	48 89 c7             	mov    %rax,%rdi
ffffffff800053c0:	e8 0b fa ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800053c5:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff800053cc:	49 89 c4             	mov    %rax,%r12
ffffffff800053cf:	e8 ac 1b 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800053d4:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800053db:	c7 05 13 5d 00 00 0a 	movl   $0xa,0x5d13(%rip)        # ffffffff8000b0f8 <kout>
ffffffff800053e2:	00 00 00 
            Print(string);
ffffffff800053e5:	e8 96 1b 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800053ea:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800053ed:	4c 89 e7             	mov    %r12,%rdi
ffffffff800053f0:	40 c0 ee 04          	shr    $0x4,%sil
ffffffff800053f4:	83 e6 01             	and    $0x1,%esi
ffffffff800053f7:	e8 14 fa ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800053fc:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff80005403:	48 89 c7             	mov    %rax,%rdi
ffffffff80005406:	e8 c5 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultProtectionKey: " << base::dec << pf_frame->PageFaultError.ProtectionKey << "\n";
ffffffff8000540b:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005412:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80005419:	e8 b2 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000541e:	48 c7 c6 52 aa 00 80 	mov    $0xffffffff8000aa52,%rsi
ffffffff80005425:	48 89 c7             	mov    %rax,%rdi
ffffffff80005428:	e8 a3 f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000542d:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005434:	49 89 c4             	mov    %rax,%r12
ffffffff80005437:	e8 44 1b 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000543c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005443:	c7 05 ab 5c 00 00 0a 	movl   $0xa,0x5cab(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000544a:	00 00 00 
            Print(string);
ffffffff8000544d:	e8 2e 1b 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005452:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005455:	4c 89 e7             	mov    %r12,%rdi
ffffffff80005458:	40 c0 ee 05          	shr    $0x5,%sil
ffffffff8000545c:	83 e6 01             	and    $0x1,%esi
ffffffff8000545f:	e8 ac f9 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005464:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff8000546b:	48 89 c7             	mov    %rax,%rdi
ffffffff8000546e:	e8 5d f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultShadowStack: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff80005473:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff8000547a:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80005481:	e8 4a f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005486:	48 c7 c6 6b aa 00 80 	mov    $0xffffffff8000aa6b,%rsi
ffffffff8000548d:	48 89 c7             	mov    %rax,%rdi
ffffffff80005490:	e8 3b f9 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005495:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff8000549c:	49 89 c4             	mov    %rax,%r12
ffffffff8000549f:	e8 dc 1a 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800054a4:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff800054ab:	c7 05 43 5c 00 00 0a 	movl   $0xa,0x5c43(%rip)        # ffffffff8000b0f8 <kout>
ffffffff800054b2:	00 00 00 
            Print(string);
ffffffff800054b5:	e8 c6 1a 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800054ba:	0f b6 33             	movzbl (%rbx),%esi
ffffffff800054bd:	4c 89 e7             	mov    %r12,%rdi
ffffffff800054c0:	40 c0 ee 06          	shr    $0x6,%sil
ffffffff800054c4:	83 e6 01             	and    $0x1,%esi
ffffffff800054c7:	e8 44 f9 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff800054cc:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff800054d3:	48 89 c7             	mov    %rax,%rdi
ffffffff800054d6:	e8 f5 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
            kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff800054db:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff800054e2:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff800054e9:	e8 e2 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800054ee:	48 c7 c6 82 aa 00 80 	mov    $0xffffffff8000aa82,%rsi
ffffffff800054f5:	48 89 c7             	mov    %rax,%rdi
ffffffff800054f8:	e8 d3 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800054fd:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005504:	49 89 c4             	mov    %rax,%r12
ffffffff80005507:	e8 74 1a 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000550c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005513:	c7 05 db 5b 00 00 0a 	movl   $0xa,0x5bdb(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000551a:	00 00 00 
            Print(string);
ffffffff8000551d:	e8 5e 1a 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005522:	0f b6 33             	movzbl (%rbx),%esi
ffffffff80005525:	4c 89 e7             	mov    %r12,%rdi
            frame = (System::PanicFrame*)&pf_frame->IP;
ffffffff80005528:	48 89 eb             	mov    %rbp,%rbx
            kerr << "\t" << "PageFaultSGX: " << base::dec << pf_frame->PageFaultError.ShadowStack << "\n";
ffffffff8000552b:	40 c0 ee 06          	shr    $0x6,%sil
ffffffff8000552f:	83 e6 01             	and    $0x1,%esi
ffffffff80005532:	e8 d9 f8 ff ff       	call   ffffffff80004e10 <_ZN2KtlsIhEERNS_17KernelErrorStreamES2_T_>
ffffffff80005537:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff8000553e:	48 89 c7             	mov    %rax,%rdi
ffffffff80005541:	e8 8a f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff80005546:	e9 81 fa ff ff       	jmp    ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c>
            kerr << "\t" << "ErrorCode: " << base::dec << gpf_frame->GeneralProtectionFaultError << "\n";
ffffffff8000554b:	48 c7 c6 c2 a9 00 80 	mov    $0xffffffff8000a9c2,%rsi
ffffffff80005552:	48 c7 c7 c0 07 0e 80 	mov    $0xffffffff800e07c0,%rdi
ffffffff80005559:	e8 72 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000555e:	48 c7 c6 91 aa 00 80 	mov    $0xffffffff8000aa91,%rsi
ffffffff80005565:	48 89 c7             	mov    %rax,%rdi
ffffffff80005568:	e8 63 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff8000556d:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff80005574:	48 89 c5             	mov    %rax,%rbp
ffffffff80005577:	e8 04 1a 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000557c:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
            t.streamBaseType = newBase;
ffffffff80005583:	c7 05 6b 5b 00 00 0a 	movl   $0xa,0x5b6b(%rip)        # ffffffff8000b0f8 <kout>
ffffffff8000558a:	00 00 00 
            Print(string);
ffffffff8000558d:	e8 ee 19 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff80005592:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005595:	48 89 ef             	mov    %rbp,%rdi
ffffffff80005598:	e8 c3 f8 ff ff       	call   ffffffff80004e60 <_ZN2KtlsImEERNS_17KernelErrorStreamES2_T_>
ffffffff8000559d:	48 c7 c6 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rsi
ffffffff800055a4:	48 89 c7             	mov    %rax,%rdi
ffffffff800055a7:	e8 24 f8 ff ff       	call   ffffffff80004dd0 <_ZN2KtlsIPKcEERNS_17KernelErrorStreamES4_T_>
ffffffff800055ac:	e9 1b fa ff ff       	jmp    ffffffff80004fcc <_Z5PanicPKcPN6System10PanicFrameE+0x11c>
ffffffff800055b1:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800055b8:	00 00 00 
ffffffff800055bb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff800055c0 <_ZdlPvm>:
{
    Memory::g_heap->Free(block);
}

void operator delete(void* block, long unsigned int)
{
ffffffff800055c0:	f3 0f 1e fa          	endbr64
ffffffff800055c4:	48 89 fe             	mov    %rdi,%rsi
    Memory::g_heap->Free(block);
ffffffff800055c7:	48 8b 3d 02 b2 0d 00 	mov    0xdb202(%rip),%rdi        # ffffffff800e07d0 <_ZN6Memory6g_heapE>
ffffffff800055ce:	e9 cd 16 00 00       	jmp    ffffffff80006ca0 <_ZN6Memory13HeapAllocator4FreeEPv>
ffffffff800055d3:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800055da:	00 00 00 
ffffffff800055dd:	0f 1f 00             	nopl   (%rax)

ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>:
#include "Stream.hpp"
#include <Memory/Heap.hpp>
#include <Terminal/Terminal.hpp>
#include <Libraries/String.hpp>

kcp::cstringstream::cstringstream()
ffffffff800055e0:	f3 0f 1e fa          	endbr64
ffffffff800055e4:	c7 47 10 0a 00 00 00 	movl   $0xa,0x10(%rdi)
{
    this->string = nullptr;
ffffffff800055eb:	48 c7 07 00 00 00 00 	movq   $0x0,(%rdi)
    this->size = 0;
ffffffff800055f2:	48 c7 47 08 00 00 00 	movq   $0x0,0x8(%rdi)
ffffffff800055f9:	00 
}
ffffffff800055fa:	c3                   	ret
ffffffff800055fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>:

kcp::cstringstream::~cstringstream()
ffffffff80005600:	f3 0f 1e fa          	endbr64
{
    delete this->string;
ffffffff80005604:	48 8b 3f             	mov    (%rdi),%rdi
ffffffff80005607:	48 85 ff             	test   %rdi,%rdi
ffffffff8000560a:	74 14                	je     ffffffff80005620 <_ZN3kcp13cstringstreamD1Ev+0x20>
ffffffff8000560c:	be 01 00 00 00       	mov    $0x1,%esi
ffffffff80005611:	e9 aa ff ff ff       	jmp    ffffffff800055c0 <_ZdlPvm>
ffffffff80005616:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000561d:	00 00 00 
}
ffffffff80005620:	c3                   	ret
ffffffff80005621:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80005628:	00 00 00 
ffffffff8000562b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>:
    }

    return *this;
}

kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) {
ffffffff80005630:	f3 0f 1e fa          	endbr64
ffffffff80005634:	41 54                	push   %r12
ffffffff80005636:	55                   	push   %rbp
ffffffff80005637:	53                   	push   %rbx
    while (*str != '\0')
ffffffff80005638:	44 0f b6 26          	movzbl (%rsi),%r12d
kcp::cstringstream& kcp::cstringstream::operator<<(const char* str) {
ffffffff8000563c:	48 89 fb             	mov    %rdi,%rbx
    while (*str != '\0')
ffffffff8000563f:	45 84 e4             	test   %r12b,%r12b
ffffffff80005642:	74 49                	je     ffffffff8000568d <_ZN3kcp13cstringstreamlsEPKc+0x5d>
ffffffff80005644:	48 89 f5             	mov    %rsi,%rbp
ffffffff80005647:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000564e:	00 00 
    this->string = (char *)Memory::g_heap->Realloc((void *)this->string, this->size + 2);
ffffffff80005650:	48 8b 43 08          	mov    0x8(%rbx),%rax
ffffffff80005654:	48 8b 33             	mov    (%rbx),%rsi
ffffffff80005657:	48 8b 3d 72 b1 0d 00 	mov    0xdb172(%rip),%rdi        # ffffffff800e07d0 <_ZN6Memory6g_heapE>
ffffffff8000565e:	48 8d 50 02          	lea    0x2(%rax),%rdx
ffffffff80005662:	e8 a9 15 00 00       	call   ffffffff80006c10 <_ZN6Memory13HeapAllocator7ReallocEPvm>
ffffffff80005667:	48 89 03             	mov    %rax,(%rbx)
    if (!this->string)
ffffffff8000566a:	48 85 c0             	test   %rax,%rax
ffffffff8000566d:	74 29                	je     ffffffff80005698 <_ZN3kcp13cstringstreamlsEPKc+0x68>
    char* ref = (char *)&string[size];
ffffffff8000566f:	48 03 43 08          	add    0x8(%rbx),%rax
    *ref = c;
ffffffff80005673:	44 88 20             	mov    %r12b,(%rax)
    *ref = '\0';
ffffffff80005676:	c6 40 01 00          	movb   $0x0,0x1(%rax)
    this->size++;
ffffffff8000567a:	48 83 43 08 01       	addq   $0x1,0x8(%rbx)
    while (*str != '\0')
ffffffff8000567f:	44 0f b6 65 01       	movzbl 0x1(%rbp),%r12d
        str++;
ffffffff80005684:	48 83 c5 01          	add    $0x1,%rbp
    while (*str != '\0')
ffffffff80005688:	45 84 e4             	test   %r12b,%r12b
ffffffff8000568b:	75 c3                	jne    ffffffff80005650 <_ZN3kcp13cstringstreamlsEPKc+0x20>
    *this << (char*)str;

    return *this;
}
ffffffff8000568d:	48 89 d8             	mov    %rbx,%rax
ffffffff80005690:	5b                   	pop    %rbx
ffffffff80005691:	5d                   	pop    %rbp
ffffffff80005692:	41 5c                	pop    %r12
ffffffff80005694:	c3                   	ret
ffffffff80005695:	0f 1f 00             	nopl   (%rax)
ffffffff80005698:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff8000569f:	e8 dc 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800056a4:	48 c7 c7 10 ad 00 80 	mov    $0xffffffff8000ad10,%rdi
ffffffff800056ab:	e8 d0 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800056b0:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff800056b7:	e8 c4 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff800056bc:	48 c7 c7 a2 a9 00 80 	mov    $0xffffffff8000a9a2,%rdi
ffffffff800056c3:	e8 b8 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800056c8:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800056cd:	e8 7e 18 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
            Print(string);
ffffffff800056d2:	48 c7 c7 aa a9 00 80 	mov    $0xffffffff8000a9aa,%rdi
ffffffff800056d9:	e8 a2 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        return *this;
ffffffff800056de:	eb 9f                	jmp    ffffffff8000567f <_ZN3kcp13cstringstreamlsEPKc+0x4f>

ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>:
    using namespace Kt;

    GDTPointer gdtPointer{};
    BasicGDT kernelGDT{};
    
    void PrepareGDT() {
ffffffff800056e0:	f3 0f 1e fa          	endbr64
ffffffff800056e4:	48 83 ec 08          	sub    $0x8,%rsp
        base streamBaseType = base::dec;

        // C++ streaming operator like cout
        friend KernelOutStream &operator<<(KernelOutStream &t, const char *string)
        {
            Print(string);
ffffffff800056e8:	48 c7 c7 e6 aa 00 80 	mov    $0xffffffff8000aae6,%rdi
ffffffff800056ef:	e8 8c 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, std::uint64_t number)
        {
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff800056f4:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff800056f9:	48 c7 c7 60 03 0e 80 	mov    $0xffffffff800e0360,%rdi
            return t;
        }

        friend KernelOutStream &operator<<(KernelOutStream &t, base newBase)
        {
            t.streamBaseType = newBase;
ffffffff80005700:	c7 05 ee 59 00 00 10 	movl   $0x10,0x59ee(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80005707:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff8000570a:	e8 a1 12 00 00       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff8000570f:	48 89 c7             	mov    %rax,%rdi
ffffffff80005712:	e8 69 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80005717:	48 c7 c7 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rdi
ffffffff8000571e:	e8 5d 18 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        kout << "HardwareAbstraction: GDT at " << base::hex << (uint64_t)&kernelGDT << "\n";
        kernelGDT = {
ffffffff80005723:	48 b8 ff ff 00 00 00 	movabs $0xa092000000ffff,%rax
ffffffff8000572a:	92 a0 00 
ffffffff8000572d:	48 ba ff ff 00 00 00 	movabs $0xa09a000000ffff,%rdx
ffffffff80005734:	9a a0 00 
ffffffff80005737:	48 c7 05 1e ac 0d 00 	movq   $0xffff,0xdac1e(%rip)        # ffffffff800e0360 <_ZN3Hal9kernelGDTE>
ffffffff8000573e:	ff ff 00 00 
ffffffff80005742:	48 89 05 27 ac 0d 00 	mov    %rax,0xdac27(%rip)        # ffffffff800e0370 <_ZN3Hal9kernelGDTE+0x10>
ffffffff80005749:	48 89 05 30 ac 0d 00 	mov    %rax,0xdac30(%rip)        # ffffffff800e0380 <_ZN3Hal9kernelGDTE+0x20>
ffffffff80005750:	48 b8 00 00 00 00 00 	movabs $0xfa0000000000,%rax
ffffffff80005757:	fa 00 00 
ffffffff8000575a:	48 89 05 27 ac 0d 00 	mov    %rax,0xdac27(%rip)        # ffffffff800e0388 <_ZN3Hal9kernelGDTE+0x28>
    
                0x0
            }
        };
    
        gdtPointer = GDTPointer{
ffffffff80005761:	b8 2f 00 00 00       	mov    $0x2f,%eax
        kernelGDT = {
ffffffff80005766:	48 89 15 fb ab 0d 00 	mov    %rdx,0xdabfb(%rip)        # ffffffff800e0368 <_ZN3Hal9kernelGDTE+0x8>
ffffffff8000576d:	48 89 15 04 ac 0d 00 	mov    %rdx,0xdac04(%rip)        # ffffffff800e0378 <_ZN3Hal9kernelGDTE+0x18>
        gdtPointer = GDTPointer{
ffffffff80005774:	66 89 05 15 ac 0d 00 	mov    %ax,0xdac15(%rip)        # ffffffff800e0390 <_ZN3Hal10gdtPointerE>
ffffffff8000577b:	48 c7 05 0c ac 0d 00 	movq   $0xffffffff800e0360,0xdac0c(%rip)        # ffffffff800e0392 <_ZN3Hal10gdtPointerE+0x2>
ffffffff80005782:	60 03 0e 80 
            .Size = sizeof(kernelGDT) - 1,
            .GDTAddress = (uint64_t)&kernelGDT
        };
    }
ffffffff80005786:	48 83 c4 08          	add    $0x8,%rsp
ffffffff8000578a:	c3                   	ret
ffffffff8000578b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>:
    
    // Helpers implemented in gdt.asm
    extern "C" void LoadGDT(GDTPointer *gdtPointer);
    extern "C" void ReloadSegments();
    
    void BridgeLoadGDT() {
ffffffff80005790:	f3 0f 1e fa          	endbr64
ffffffff80005794:	48 83 ec 08          	sub    $0x8,%rsp
ffffffff80005798:	48 c7 c7 40 ad 00 80 	mov    $0xffffffff8000ad40,%rdi
ffffffff8000579f:	e8 dc 17 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800057a4:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800057a9:	e8 a2 17 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
        // Puts the GDT pointer structure into the GDTR
        kout << "HardwareAbstraction: Setting GDTR" << Kt::newline;
        LoadGDT(&gdtPointer);
ffffffff800057ae:	48 c7 c7 90 03 0e 80 	mov    $0xffffffff800e0390,%rdi
ffffffff800057b5:	e8 16 18 00 00       	call   ffffffff80006fd0 <LoadGDT>
            Print(string);
ffffffff800057ba:	48 c7 c7 68 ad 00 80 	mov    $0xffffffff8000ad68,%rdi
ffffffff800057c1:	e8 ba 17 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff800057c6:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff800057cb:	e8 80 17 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
    
        kout << "HardwareAbstraction: Reloading segments" << Kt::newline;
        ReloadSegments();
    }
ffffffff800057d0:	48 83 c4 08          	add    $0x8,%rsp
        ReloadSegments();
ffffffff800057d4:	e9 fb 17 00 00       	jmp    ffffffff80006fd4 <ReloadSegments>
ffffffff800057d9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff800057e0 <_ZN3Hal16ExceptionHandlerILm0EEEvPN6System10PanicFrameE>:
        "Security Exception",
        "Reserved"
    };

    template<size_t i>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800057e0:	f3 0f 1e fa          	endbr64
ffffffff800057e4:	41 53                	push   %r11
ffffffff800057e6:	41 52                	push   %r10
ffffffff800057e8:	41 51                	push   %r9
ffffffff800057ea:	41 50                	push   %r8
ffffffff800057ec:	57                   	push   %rdi
        // kcp::cstringstream stream;
        // stream << "Caught " << base::hex << "0x" << i << " " << ExceptionStrings[i] << " in kernel";

        frame->InterruptVector = i;

        Panic(ExceptionStrings[i], frame);
ffffffff800057ed:	48 8b 3d 0c 58 00 00 	mov    0x580c(%rip),%rdi        # ffffffff8000b000 <_ZN3Hal16ExceptionStringsE>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800057f4:	56                   	push   %rsi
ffffffff800057f5:	51                   	push   %rcx
ffffffff800057f6:	52                   	push   %rdx
ffffffff800057f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800057f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800057fd:	c6 44 24 70 00       	movb   $0x0,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005802:	fc                   	cld
ffffffff80005803:	e8 a8 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005808:	58                   	pop    %rax
ffffffff80005809:	5a                   	pop    %rdx
ffffffff8000580a:	59                   	pop    %rcx
ffffffff8000580b:	5e                   	pop    %rsi
ffffffff8000580c:	5f                   	pop    %rdi
ffffffff8000580d:	41 58                	pop    %r8
ffffffff8000580f:	41 59                	pop    %r9
ffffffff80005811:	41 5a                	pop    %r10
ffffffff80005813:	41 5b                	pop    %r11
ffffffff80005815:	48 cf                	iretq
ffffffff80005817:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000581e:	00 00 

ffffffff80005820 <_ZN3Hal16ExceptionHandlerILm1EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005820:	f3 0f 1e fa          	endbr64
ffffffff80005824:	41 53                	push   %r11
ffffffff80005826:	41 52                	push   %r10
ffffffff80005828:	41 51                	push   %r9
ffffffff8000582a:	41 50                	push   %r8
ffffffff8000582c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000582d:	48 8b 3d d4 57 00 00 	mov    0x57d4(%rip),%rdi        # ffffffff8000b008 <_ZN3Hal16ExceptionStringsE+0x8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005834:	56                   	push   %rsi
ffffffff80005835:	51                   	push   %rcx
ffffffff80005836:	52                   	push   %rdx
ffffffff80005837:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005838:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000583d:	c6 44 24 70 01       	movb   $0x1,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005842:	fc                   	cld
ffffffff80005843:	e8 68 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005848:	58                   	pop    %rax
ffffffff80005849:	5a                   	pop    %rdx
ffffffff8000584a:	59                   	pop    %rcx
ffffffff8000584b:	5e                   	pop    %rsi
ffffffff8000584c:	5f                   	pop    %rdi
ffffffff8000584d:	41 58                	pop    %r8
ffffffff8000584f:	41 59                	pop    %r9
ffffffff80005851:	41 5a                	pop    %r10
ffffffff80005853:	41 5b                	pop    %r11
ffffffff80005855:	48 cf                	iretq
ffffffff80005857:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000585e:	00 00 

ffffffff80005860 <_ZN3Hal16ExceptionHandlerILm2EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005860:	f3 0f 1e fa          	endbr64
ffffffff80005864:	41 53                	push   %r11
ffffffff80005866:	41 52                	push   %r10
ffffffff80005868:	41 51                	push   %r9
ffffffff8000586a:	41 50                	push   %r8
ffffffff8000586c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000586d:	48 8b 3d 9c 57 00 00 	mov    0x579c(%rip),%rdi        # ffffffff8000b010 <_ZN3Hal16ExceptionStringsE+0x10>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005874:	56                   	push   %rsi
ffffffff80005875:	51                   	push   %rcx
ffffffff80005876:	52                   	push   %rdx
ffffffff80005877:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005878:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000587d:	c6 44 24 70 02       	movb   $0x2,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005882:	fc                   	cld
ffffffff80005883:	e8 28 f6 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005888:	58                   	pop    %rax
ffffffff80005889:	5a                   	pop    %rdx
ffffffff8000588a:	59                   	pop    %rcx
ffffffff8000588b:	5e                   	pop    %rsi
ffffffff8000588c:	5f                   	pop    %rdi
ffffffff8000588d:	41 58                	pop    %r8
ffffffff8000588f:	41 59                	pop    %r9
ffffffff80005891:	41 5a                	pop    %r10
ffffffff80005893:	41 5b                	pop    %r11
ffffffff80005895:	48 cf                	iretq
ffffffff80005897:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000589e:	00 00 

ffffffff800058a0 <_ZN3Hal16ExceptionHandlerILm3EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058a0:	f3 0f 1e fa          	endbr64
ffffffff800058a4:	41 53                	push   %r11
ffffffff800058a6:	41 52                	push   %r10
ffffffff800058a8:	41 51                	push   %r9
ffffffff800058aa:	41 50                	push   %r8
ffffffff800058ac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800058ad:	48 8b 3d 64 57 00 00 	mov    0x5764(%rip),%rdi        # ffffffff8000b018 <_ZN3Hal16ExceptionStringsE+0x18>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058b4:	56                   	push   %rsi
ffffffff800058b5:	51                   	push   %rcx
ffffffff800058b6:	52                   	push   %rdx
ffffffff800058b7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800058b8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800058bd:	c6 44 24 70 03       	movb   $0x3,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff800058c2:	fc                   	cld
ffffffff800058c3:	e8 e8 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff800058c8:	58                   	pop    %rax
ffffffff800058c9:	5a                   	pop    %rdx
ffffffff800058ca:	59                   	pop    %rcx
ffffffff800058cb:	5e                   	pop    %rsi
ffffffff800058cc:	5f                   	pop    %rdi
ffffffff800058cd:	41 58                	pop    %r8
ffffffff800058cf:	41 59                	pop    %r9
ffffffff800058d1:	41 5a                	pop    %r10
ffffffff800058d3:	41 5b                	pop    %r11
ffffffff800058d5:	48 cf                	iretq
ffffffff800058d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800058de:	00 00 

ffffffff800058e0 <_ZN3Hal16ExceptionHandlerILm4EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058e0:	f3 0f 1e fa          	endbr64
ffffffff800058e4:	41 53                	push   %r11
ffffffff800058e6:	41 52                	push   %r10
ffffffff800058e8:	41 51                	push   %r9
ffffffff800058ea:	41 50                	push   %r8
ffffffff800058ec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800058ed:	48 8b 3d 2c 57 00 00 	mov    0x572c(%rip),%rdi        # ffffffff8000b020 <_ZN3Hal16ExceptionStringsE+0x20>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800058f4:	56                   	push   %rsi
ffffffff800058f5:	51                   	push   %rcx
ffffffff800058f6:	52                   	push   %rdx
ffffffff800058f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800058f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800058fd:	c6 44 24 70 04       	movb   $0x4,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005902:	fc                   	cld
ffffffff80005903:	e8 a8 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005908:	58                   	pop    %rax
ffffffff80005909:	5a                   	pop    %rdx
ffffffff8000590a:	59                   	pop    %rcx
ffffffff8000590b:	5e                   	pop    %rsi
ffffffff8000590c:	5f                   	pop    %rdi
ffffffff8000590d:	41 58                	pop    %r8
ffffffff8000590f:	41 59                	pop    %r9
ffffffff80005911:	41 5a                	pop    %r10
ffffffff80005913:	41 5b                	pop    %r11
ffffffff80005915:	48 cf                	iretq
ffffffff80005917:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000591e:	00 00 

ffffffff80005920 <_ZN3Hal16ExceptionHandlerILm5EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005920:	f3 0f 1e fa          	endbr64
ffffffff80005924:	41 53                	push   %r11
ffffffff80005926:	41 52                	push   %r10
ffffffff80005928:	41 51                	push   %r9
ffffffff8000592a:	41 50                	push   %r8
ffffffff8000592c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000592d:	48 8b 3d f4 56 00 00 	mov    0x56f4(%rip),%rdi        # ffffffff8000b028 <_ZN3Hal16ExceptionStringsE+0x28>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005934:	56                   	push   %rsi
ffffffff80005935:	51                   	push   %rcx
ffffffff80005936:	52                   	push   %rdx
ffffffff80005937:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005938:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000593d:	c6 44 24 70 05       	movb   $0x5,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005942:	fc                   	cld
ffffffff80005943:	e8 68 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005948:	58                   	pop    %rax
ffffffff80005949:	5a                   	pop    %rdx
ffffffff8000594a:	59                   	pop    %rcx
ffffffff8000594b:	5e                   	pop    %rsi
ffffffff8000594c:	5f                   	pop    %rdi
ffffffff8000594d:	41 58                	pop    %r8
ffffffff8000594f:	41 59                	pop    %r9
ffffffff80005951:	41 5a                	pop    %r10
ffffffff80005953:	41 5b                	pop    %r11
ffffffff80005955:	48 cf                	iretq
ffffffff80005957:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000595e:	00 00 

ffffffff80005960 <_ZN3Hal16ExceptionHandlerILm6EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005960:	f3 0f 1e fa          	endbr64
ffffffff80005964:	41 53                	push   %r11
ffffffff80005966:	41 52                	push   %r10
ffffffff80005968:	41 51                	push   %r9
ffffffff8000596a:	41 50                	push   %r8
ffffffff8000596c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff8000596d:	48 8b 3d bc 56 00 00 	mov    0x56bc(%rip),%rdi        # ffffffff8000b030 <_ZN3Hal16ExceptionStringsE+0x30>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005974:	56                   	push   %rsi
ffffffff80005975:	51                   	push   %rcx
ffffffff80005976:	52                   	push   %rdx
ffffffff80005977:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005978:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff8000597d:	c6 44 24 70 06       	movb   $0x6,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005982:	fc                   	cld
ffffffff80005983:	e8 28 f5 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005988:	58                   	pop    %rax
ffffffff80005989:	5a                   	pop    %rdx
ffffffff8000598a:	59                   	pop    %rcx
ffffffff8000598b:	5e                   	pop    %rsi
ffffffff8000598c:	5f                   	pop    %rdi
ffffffff8000598d:	41 58                	pop    %r8
ffffffff8000598f:	41 59                	pop    %r9
ffffffff80005991:	41 5a                	pop    %r10
ffffffff80005993:	41 5b                	pop    %r11
ffffffff80005995:	48 cf                	iretq
ffffffff80005997:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff8000599e:	00 00 

ffffffff800059a0 <_ZN3Hal16ExceptionHandlerILm7EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059a0:	f3 0f 1e fa          	endbr64
ffffffff800059a4:	41 53                	push   %r11
ffffffff800059a6:	41 52                	push   %r10
ffffffff800059a8:	41 51                	push   %r9
ffffffff800059aa:	41 50                	push   %r8
ffffffff800059ac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800059ad:	48 8b 3d 84 56 00 00 	mov    0x5684(%rip),%rdi        # ffffffff8000b038 <_ZN3Hal16ExceptionStringsE+0x38>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059b4:	56                   	push   %rsi
ffffffff800059b5:	51                   	push   %rcx
ffffffff800059b6:	52                   	push   %rdx
ffffffff800059b7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800059b8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800059bd:	c6 44 24 70 07       	movb   $0x7,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff800059c2:	fc                   	cld
ffffffff800059c3:	e8 e8 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff800059c8:	58                   	pop    %rax
ffffffff800059c9:	5a                   	pop    %rdx
ffffffff800059ca:	59                   	pop    %rcx
ffffffff800059cb:	5e                   	pop    %rsi
ffffffff800059cc:	5f                   	pop    %rdi
ffffffff800059cd:	41 58                	pop    %r8
ffffffff800059cf:	41 59                	pop    %r9
ffffffff800059d1:	41 5a                	pop    %r10
ffffffff800059d3:	41 5b                	pop    %r11
ffffffff800059d5:	48 cf                	iretq
ffffffff800059d7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff800059de:	00 00 

ffffffff800059e0 <_ZN3Hal16ExceptionHandlerILm8EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059e0:	f3 0f 1e fa          	endbr64
ffffffff800059e4:	41 53                	push   %r11
ffffffff800059e6:	41 52                	push   %r10
ffffffff800059e8:	41 51                	push   %r9
ffffffff800059ea:	41 50                	push   %r8
ffffffff800059ec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff800059ed:	48 8b 3d 4c 56 00 00 	mov    0x564c(%rip),%rdi        # ffffffff8000b040 <_ZN3Hal16ExceptionStringsE+0x40>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff800059f4:	56                   	push   %rsi
ffffffff800059f5:	51                   	push   %rcx
ffffffff800059f6:	52                   	push   %rdx
ffffffff800059f7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff800059f8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff800059fd:	c6 44 24 70 08       	movb   $0x8,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a02:	fc                   	cld
ffffffff80005a03:	e8 a8 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a08:	58                   	pop    %rax
ffffffff80005a09:	5a                   	pop    %rdx
ffffffff80005a0a:	59                   	pop    %rcx
ffffffff80005a0b:	5e                   	pop    %rsi
ffffffff80005a0c:	5f                   	pop    %rdi
ffffffff80005a0d:	41 58                	pop    %r8
ffffffff80005a0f:	41 59                	pop    %r9
ffffffff80005a11:	41 5a                	pop    %r10
ffffffff80005a13:	41 5b                	pop    %r11
ffffffff80005a15:	48 cf                	iretq
ffffffff80005a17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a1e:	00 00 

ffffffff80005a20 <_ZN3Hal16ExceptionHandlerILm9EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a20:	f3 0f 1e fa          	endbr64
ffffffff80005a24:	41 53                	push   %r11
ffffffff80005a26:	41 52                	push   %r10
ffffffff80005a28:	41 51                	push   %r9
ffffffff80005a2a:	41 50                	push   %r8
ffffffff80005a2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005a2d:	48 8b 3d 14 56 00 00 	mov    0x5614(%rip),%rdi        # ffffffff8000b048 <_ZN3Hal16ExceptionStringsE+0x48>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a34:	56                   	push   %rsi
ffffffff80005a35:	51                   	push   %rcx
ffffffff80005a36:	52                   	push   %rdx
ffffffff80005a37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005a38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005a3d:	c6 44 24 70 09       	movb   $0x9,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a42:	fc                   	cld
ffffffff80005a43:	e8 68 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a48:	58                   	pop    %rax
ffffffff80005a49:	5a                   	pop    %rdx
ffffffff80005a4a:	59                   	pop    %rcx
ffffffff80005a4b:	5e                   	pop    %rsi
ffffffff80005a4c:	5f                   	pop    %rdi
ffffffff80005a4d:	41 58                	pop    %r8
ffffffff80005a4f:	41 59                	pop    %r9
ffffffff80005a51:	41 5a                	pop    %r10
ffffffff80005a53:	41 5b                	pop    %r11
ffffffff80005a55:	48 cf                	iretq
ffffffff80005a57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a5e:	00 00 

ffffffff80005a60 <_ZN3Hal16ExceptionHandlerILm10EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a60:	f3 0f 1e fa          	endbr64
ffffffff80005a64:	41 53                	push   %r11
ffffffff80005a66:	41 52                	push   %r10
ffffffff80005a68:	41 51                	push   %r9
ffffffff80005a6a:	41 50                	push   %r8
ffffffff80005a6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005a6d:	48 8b 3d dc 55 00 00 	mov    0x55dc(%rip),%rdi        # ffffffff8000b050 <_ZN3Hal16ExceptionStringsE+0x50>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005a74:	56                   	push   %rsi
ffffffff80005a75:	51                   	push   %rcx
ffffffff80005a76:	52                   	push   %rdx
ffffffff80005a77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005a78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005a7d:	c6 44 24 70 0a       	movb   $0xa,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005a82:	fc                   	cld
ffffffff80005a83:	e8 28 f4 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005a88:	58                   	pop    %rax
ffffffff80005a89:	5a                   	pop    %rdx
ffffffff80005a8a:	59                   	pop    %rcx
ffffffff80005a8b:	5e                   	pop    %rsi
ffffffff80005a8c:	5f                   	pop    %rdi
ffffffff80005a8d:	41 58                	pop    %r8
ffffffff80005a8f:	41 59                	pop    %r9
ffffffff80005a91:	41 5a                	pop    %r10
ffffffff80005a93:	41 5b                	pop    %r11
ffffffff80005a95:	48 cf                	iretq
ffffffff80005a97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005a9e:	00 00 

ffffffff80005aa0 <_ZN3Hal16ExceptionHandlerILm11EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005aa0:	f3 0f 1e fa          	endbr64
ffffffff80005aa4:	41 53                	push   %r11
ffffffff80005aa6:	41 52                	push   %r10
ffffffff80005aa8:	41 51                	push   %r9
ffffffff80005aaa:	41 50                	push   %r8
ffffffff80005aac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005aad:	48 8b 3d a4 55 00 00 	mov    0x55a4(%rip),%rdi        # ffffffff8000b058 <_ZN3Hal16ExceptionStringsE+0x58>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ab4:	56                   	push   %rsi
ffffffff80005ab5:	51                   	push   %rcx
ffffffff80005ab6:	52                   	push   %rdx
ffffffff80005ab7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005ab8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005abd:	c6 44 24 70 0b       	movb   $0xb,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005ac2:	fc                   	cld
ffffffff80005ac3:	e8 e8 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005ac8:	58                   	pop    %rax
ffffffff80005ac9:	5a                   	pop    %rdx
ffffffff80005aca:	59                   	pop    %rcx
ffffffff80005acb:	5e                   	pop    %rsi
ffffffff80005acc:	5f                   	pop    %rdi
ffffffff80005acd:	41 58                	pop    %r8
ffffffff80005acf:	41 59                	pop    %r9
ffffffff80005ad1:	41 5a                	pop    %r10
ffffffff80005ad3:	41 5b                	pop    %r11
ffffffff80005ad5:	48 cf                	iretq
ffffffff80005ad7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005ade:	00 00 

ffffffff80005ae0 <_ZN3Hal16ExceptionHandlerILm12EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ae0:	f3 0f 1e fa          	endbr64
ffffffff80005ae4:	41 53                	push   %r11
ffffffff80005ae6:	41 52                	push   %r10
ffffffff80005ae8:	41 51                	push   %r9
ffffffff80005aea:	41 50                	push   %r8
ffffffff80005aec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005aed:	48 8b 3d 6c 55 00 00 	mov    0x556c(%rip),%rdi        # ffffffff8000b060 <_ZN3Hal16ExceptionStringsE+0x60>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005af4:	56                   	push   %rsi
ffffffff80005af5:	51                   	push   %rcx
ffffffff80005af6:	52                   	push   %rdx
ffffffff80005af7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005af8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005afd:	c6 44 24 70 0c       	movb   $0xc,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b02:	fc                   	cld
ffffffff80005b03:	e8 a8 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b08:	58                   	pop    %rax
ffffffff80005b09:	5a                   	pop    %rdx
ffffffff80005b0a:	59                   	pop    %rcx
ffffffff80005b0b:	5e                   	pop    %rsi
ffffffff80005b0c:	5f                   	pop    %rdi
ffffffff80005b0d:	41 58                	pop    %r8
ffffffff80005b0f:	41 59                	pop    %r9
ffffffff80005b11:	41 5a                	pop    %r10
ffffffff80005b13:	41 5b                	pop    %r11
ffffffff80005b15:	48 cf                	iretq
ffffffff80005b17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b1e:	00 00 

ffffffff80005b20 <_ZN3Hal16ExceptionHandlerILm13EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b20:	f3 0f 1e fa          	endbr64
ffffffff80005b24:	41 53                	push   %r11
ffffffff80005b26:	41 52                	push   %r10
ffffffff80005b28:	41 51                	push   %r9
ffffffff80005b2a:	41 50                	push   %r8
ffffffff80005b2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005b2d:	48 8b 3d 34 55 00 00 	mov    0x5534(%rip),%rdi        # ffffffff8000b068 <_ZN3Hal16ExceptionStringsE+0x68>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b34:	56                   	push   %rsi
ffffffff80005b35:	51                   	push   %rcx
ffffffff80005b36:	52                   	push   %rdx
ffffffff80005b37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005b38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005b3d:	c6 44 24 70 0d       	movb   $0xd,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b42:	fc                   	cld
ffffffff80005b43:	e8 68 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b48:	58                   	pop    %rax
ffffffff80005b49:	5a                   	pop    %rdx
ffffffff80005b4a:	59                   	pop    %rcx
ffffffff80005b4b:	5e                   	pop    %rsi
ffffffff80005b4c:	5f                   	pop    %rdi
ffffffff80005b4d:	41 58                	pop    %r8
ffffffff80005b4f:	41 59                	pop    %r9
ffffffff80005b51:	41 5a                	pop    %r10
ffffffff80005b53:	41 5b                	pop    %r11
ffffffff80005b55:	48 cf                	iretq
ffffffff80005b57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b5e:	00 00 

ffffffff80005b60 <_ZN3Hal16ExceptionHandlerILm14EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b60:	f3 0f 1e fa          	endbr64
ffffffff80005b64:	41 53                	push   %r11
ffffffff80005b66:	41 52                	push   %r10
ffffffff80005b68:	41 51                	push   %r9
ffffffff80005b6a:	41 50                	push   %r8
ffffffff80005b6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005b6d:	48 8b 3d fc 54 00 00 	mov    0x54fc(%rip),%rdi        # ffffffff8000b070 <_ZN3Hal16ExceptionStringsE+0x70>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005b74:	56                   	push   %rsi
ffffffff80005b75:	51                   	push   %rcx
ffffffff80005b76:	52                   	push   %rdx
ffffffff80005b77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005b78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005b7d:	c6 44 24 70 0e       	movb   $0xe,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005b82:	fc                   	cld
ffffffff80005b83:	e8 28 f3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005b88:	58                   	pop    %rax
ffffffff80005b89:	5a                   	pop    %rdx
ffffffff80005b8a:	59                   	pop    %rcx
ffffffff80005b8b:	5e                   	pop    %rsi
ffffffff80005b8c:	5f                   	pop    %rdi
ffffffff80005b8d:	41 58                	pop    %r8
ffffffff80005b8f:	41 59                	pop    %r9
ffffffff80005b91:	41 5a                	pop    %r10
ffffffff80005b93:	41 5b                	pop    %r11
ffffffff80005b95:	48 cf                	iretq
ffffffff80005b97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005b9e:	00 00 

ffffffff80005ba0 <_ZN3Hal16ExceptionHandlerILm15EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ba0:	f3 0f 1e fa          	endbr64
ffffffff80005ba4:	41 53                	push   %r11
ffffffff80005ba6:	41 52                	push   %r10
ffffffff80005ba8:	41 51                	push   %r9
ffffffff80005baa:	41 50                	push   %r8
ffffffff80005bac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005bad:	48 8b 3d c4 54 00 00 	mov    0x54c4(%rip),%rdi        # ffffffff8000b078 <_ZN3Hal16ExceptionStringsE+0x78>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005bb4:	56                   	push   %rsi
ffffffff80005bb5:	51                   	push   %rcx
ffffffff80005bb6:	52                   	push   %rdx
ffffffff80005bb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005bb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005bbd:	c6 44 24 70 0f       	movb   $0xf,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005bc2:	fc                   	cld
ffffffff80005bc3:	e8 e8 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005bc8:	58                   	pop    %rax
ffffffff80005bc9:	5a                   	pop    %rdx
ffffffff80005bca:	59                   	pop    %rcx
ffffffff80005bcb:	5e                   	pop    %rsi
ffffffff80005bcc:	5f                   	pop    %rdi
ffffffff80005bcd:	41 58                	pop    %r8
ffffffff80005bcf:	41 59                	pop    %r9
ffffffff80005bd1:	41 5a                	pop    %r10
ffffffff80005bd3:	41 5b                	pop    %r11
ffffffff80005bd5:	48 cf                	iretq
ffffffff80005bd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005bde:	00 00 

ffffffff80005be0 <_ZN3Hal16ExceptionHandlerILm16EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005be0:	f3 0f 1e fa          	endbr64
ffffffff80005be4:	41 53                	push   %r11
ffffffff80005be6:	41 52                	push   %r10
ffffffff80005be8:	41 51                	push   %r9
ffffffff80005bea:	41 50                	push   %r8
ffffffff80005bec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005bed:	48 8b 3d 8c 54 00 00 	mov    0x548c(%rip),%rdi        # ffffffff8000b080 <_ZN3Hal16ExceptionStringsE+0x80>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005bf4:	56                   	push   %rsi
ffffffff80005bf5:	51                   	push   %rcx
ffffffff80005bf6:	52                   	push   %rdx
ffffffff80005bf7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005bf8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005bfd:	c6 44 24 70 10       	movb   $0x10,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c02:	fc                   	cld
ffffffff80005c03:	e8 a8 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c08:	58                   	pop    %rax
ffffffff80005c09:	5a                   	pop    %rdx
ffffffff80005c0a:	59                   	pop    %rcx
ffffffff80005c0b:	5e                   	pop    %rsi
ffffffff80005c0c:	5f                   	pop    %rdi
ffffffff80005c0d:	41 58                	pop    %r8
ffffffff80005c0f:	41 59                	pop    %r9
ffffffff80005c11:	41 5a                	pop    %r10
ffffffff80005c13:	41 5b                	pop    %r11
ffffffff80005c15:	48 cf                	iretq
ffffffff80005c17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c1e:	00 00 

ffffffff80005c20 <_ZN3Hal16ExceptionHandlerILm17EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c20:	f3 0f 1e fa          	endbr64
ffffffff80005c24:	41 53                	push   %r11
ffffffff80005c26:	41 52                	push   %r10
ffffffff80005c28:	41 51                	push   %r9
ffffffff80005c2a:	41 50                	push   %r8
ffffffff80005c2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005c2d:	48 8b 3d 54 54 00 00 	mov    0x5454(%rip),%rdi        # ffffffff8000b088 <_ZN3Hal16ExceptionStringsE+0x88>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c34:	56                   	push   %rsi
ffffffff80005c35:	51                   	push   %rcx
ffffffff80005c36:	52                   	push   %rdx
ffffffff80005c37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005c38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005c3d:	c6 44 24 70 11       	movb   $0x11,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c42:	fc                   	cld
ffffffff80005c43:	e8 68 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c48:	58                   	pop    %rax
ffffffff80005c49:	5a                   	pop    %rdx
ffffffff80005c4a:	59                   	pop    %rcx
ffffffff80005c4b:	5e                   	pop    %rsi
ffffffff80005c4c:	5f                   	pop    %rdi
ffffffff80005c4d:	41 58                	pop    %r8
ffffffff80005c4f:	41 59                	pop    %r9
ffffffff80005c51:	41 5a                	pop    %r10
ffffffff80005c53:	41 5b                	pop    %r11
ffffffff80005c55:	48 cf                	iretq
ffffffff80005c57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c5e:	00 00 

ffffffff80005c60 <_ZN3Hal16ExceptionHandlerILm18EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c60:	f3 0f 1e fa          	endbr64
ffffffff80005c64:	41 53                	push   %r11
ffffffff80005c66:	41 52                	push   %r10
ffffffff80005c68:	41 51                	push   %r9
ffffffff80005c6a:	41 50                	push   %r8
ffffffff80005c6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005c6d:	48 8b 3d 1c 54 00 00 	mov    0x541c(%rip),%rdi        # ffffffff8000b090 <_ZN3Hal16ExceptionStringsE+0x90>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005c74:	56                   	push   %rsi
ffffffff80005c75:	51                   	push   %rcx
ffffffff80005c76:	52                   	push   %rdx
ffffffff80005c77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005c78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005c7d:	c6 44 24 70 12       	movb   $0x12,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005c82:	fc                   	cld
ffffffff80005c83:	e8 28 f2 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005c88:	58                   	pop    %rax
ffffffff80005c89:	5a                   	pop    %rdx
ffffffff80005c8a:	59                   	pop    %rcx
ffffffff80005c8b:	5e                   	pop    %rsi
ffffffff80005c8c:	5f                   	pop    %rdi
ffffffff80005c8d:	41 58                	pop    %r8
ffffffff80005c8f:	41 59                	pop    %r9
ffffffff80005c91:	41 5a                	pop    %r10
ffffffff80005c93:	41 5b                	pop    %r11
ffffffff80005c95:	48 cf                	iretq
ffffffff80005c97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005c9e:	00 00 

ffffffff80005ca0 <_ZN3Hal16ExceptionHandlerILm19EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ca0:	f3 0f 1e fa          	endbr64
ffffffff80005ca4:	41 53                	push   %r11
ffffffff80005ca6:	41 52                	push   %r10
ffffffff80005ca8:	41 51                	push   %r9
ffffffff80005caa:	41 50                	push   %r8
ffffffff80005cac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005cad:	48 8b 3d e4 53 00 00 	mov    0x53e4(%rip),%rdi        # ffffffff8000b098 <_ZN3Hal16ExceptionStringsE+0x98>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005cb4:	56                   	push   %rsi
ffffffff80005cb5:	51                   	push   %rcx
ffffffff80005cb6:	52                   	push   %rdx
ffffffff80005cb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005cb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005cbd:	c6 44 24 70 13       	movb   $0x13,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005cc2:	fc                   	cld
ffffffff80005cc3:	e8 e8 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005cc8:	58                   	pop    %rax
ffffffff80005cc9:	5a                   	pop    %rdx
ffffffff80005cca:	59                   	pop    %rcx
ffffffff80005ccb:	5e                   	pop    %rsi
ffffffff80005ccc:	5f                   	pop    %rdi
ffffffff80005ccd:	41 58                	pop    %r8
ffffffff80005ccf:	41 59                	pop    %r9
ffffffff80005cd1:	41 5a                	pop    %r10
ffffffff80005cd3:	41 5b                	pop    %r11
ffffffff80005cd5:	48 cf                	iretq
ffffffff80005cd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005cde:	00 00 

ffffffff80005ce0 <_ZN3Hal16ExceptionHandlerILm20EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ce0:	f3 0f 1e fa          	endbr64
ffffffff80005ce4:	41 53                	push   %r11
ffffffff80005ce6:	41 52                	push   %r10
ffffffff80005ce8:	41 51                	push   %r9
ffffffff80005cea:	41 50                	push   %r8
ffffffff80005cec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ced:	48 8b 3d ac 53 00 00 	mov    0x53ac(%rip),%rdi        # ffffffff8000b0a0 <_ZN3Hal16ExceptionStringsE+0xa0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005cf4:	56                   	push   %rsi
ffffffff80005cf5:	51                   	push   %rcx
ffffffff80005cf6:	52                   	push   %rdx
ffffffff80005cf7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005cf8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005cfd:	c6 44 24 70 14       	movb   $0x14,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d02:	fc                   	cld
ffffffff80005d03:	e8 a8 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d08:	58                   	pop    %rax
ffffffff80005d09:	5a                   	pop    %rdx
ffffffff80005d0a:	59                   	pop    %rcx
ffffffff80005d0b:	5e                   	pop    %rsi
ffffffff80005d0c:	5f                   	pop    %rdi
ffffffff80005d0d:	41 58                	pop    %r8
ffffffff80005d0f:	41 59                	pop    %r9
ffffffff80005d11:	41 5a                	pop    %r10
ffffffff80005d13:	41 5b                	pop    %r11
ffffffff80005d15:	48 cf                	iretq
ffffffff80005d17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d1e:	00 00 

ffffffff80005d20 <_ZN3Hal16ExceptionHandlerILm21EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d20:	f3 0f 1e fa          	endbr64
ffffffff80005d24:	41 53                	push   %r11
ffffffff80005d26:	41 52                	push   %r10
ffffffff80005d28:	41 51                	push   %r9
ffffffff80005d2a:	41 50                	push   %r8
ffffffff80005d2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005d2d:	48 8b 3d 74 53 00 00 	mov    0x5374(%rip),%rdi        # ffffffff8000b0a8 <_ZN3Hal16ExceptionStringsE+0xa8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d34:	56                   	push   %rsi
ffffffff80005d35:	51                   	push   %rcx
ffffffff80005d36:	52                   	push   %rdx
ffffffff80005d37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005d38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005d3d:	c6 44 24 70 15       	movb   $0x15,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d42:	fc                   	cld
ffffffff80005d43:	e8 68 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d48:	58                   	pop    %rax
ffffffff80005d49:	5a                   	pop    %rdx
ffffffff80005d4a:	59                   	pop    %rcx
ffffffff80005d4b:	5e                   	pop    %rsi
ffffffff80005d4c:	5f                   	pop    %rdi
ffffffff80005d4d:	41 58                	pop    %r8
ffffffff80005d4f:	41 59                	pop    %r9
ffffffff80005d51:	41 5a                	pop    %r10
ffffffff80005d53:	41 5b                	pop    %r11
ffffffff80005d55:	48 cf                	iretq
ffffffff80005d57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d5e:	00 00 

ffffffff80005d60 <_ZN3Hal16ExceptionHandlerILm22EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d60:	f3 0f 1e fa          	endbr64
ffffffff80005d64:	41 53                	push   %r11
ffffffff80005d66:	41 52                	push   %r10
ffffffff80005d68:	41 51                	push   %r9
ffffffff80005d6a:	41 50                	push   %r8
ffffffff80005d6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005d6d:	48 8b 3d 3c 53 00 00 	mov    0x533c(%rip),%rdi        # ffffffff8000b0b0 <_ZN3Hal16ExceptionStringsE+0xb0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005d74:	56                   	push   %rsi
ffffffff80005d75:	51                   	push   %rcx
ffffffff80005d76:	52                   	push   %rdx
ffffffff80005d77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005d78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005d7d:	c6 44 24 70 16       	movb   $0x16,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005d82:	fc                   	cld
ffffffff80005d83:	e8 28 f1 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005d88:	58                   	pop    %rax
ffffffff80005d89:	5a                   	pop    %rdx
ffffffff80005d8a:	59                   	pop    %rcx
ffffffff80005d8b:	5e                   	pop    %rsi
ffffffff80005d8c:	5f                   	pop    %rdi
ffffffff80005d8d:	41 58                	pop    %r8
ffffffff80005d8f:	41 59                	pop    %r9
ffffffff80005d91:	41 5a                	pop    %r10
ffffffff80005d93:	41 5b                	pop    %r11
ffffffff80005d95:	48 cf                	iretq
ffffffff80005d97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005d9e:	00 00 

ffffffff80005da0 <_ZN3Hal16ExceptionHandlerILm23EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005da0:	f3 0f 1e fa          	endbr64
ffffffff80005da4:	41 53                	push   %r11
ffffffff80005da6:	41 52                	push   %r10
ffffffff80005da8:	41 51                	push   %r9
ffffffff80005daa:	41 50                	push   %r8
ffffffff80005dac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005dad:	48 8b 3d 04 53 00 00 	mov    0x5304(%rip),%rdi        # ffffffff8000b0b8 <_ZN3Hal16ExceptionStringsE+0xb8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005db4:	56                   	push   %rsi
ffffffff80005db5:	51                   	push   %rcx
ffffffff80005db6:	52                   	push   %rdx
ffffffff80005db7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005db8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005dbd:	c6 44 24 70 17       	movb   $0x17,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005dc2:	fc                   	cld
ffffffff80005dc3:	e8 e8 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005dc8:	58                   	pop    %rax
ffffffff80005dc9:	5a                   	pop    %rdx
ffffffff80005dca:	59                   	pop    %rcx
ffffffff80005dcb:	5e                   	pop    %rsi
ffffffff80005dcc:	5f                   	pop    %rdi
ffffffff80005dcd:	41 58                	pop    %r8
ffffffff80005dcf:	41 59                	pop    %r9
ffffffff80005dd1:	41 5a                	pop    %r10
ffffffff80005dd3:	41 5b                	pop    %r11
ffffffff80005dd5:	48 cf                	iretq
ffffffff80005dd7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005dde:	00 00 

ffffffff80005de0 <_ZN3Hal16ExceptionHandlerILm24EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005de0:	f3 0f 1e fa          	endbr64
ffffffff80005de4:	41 53                	push   %r11
ffffffff80005de6:	41 52                	push   %r10
ffffffff80005de8:	41 51                	push   %r9
ffffffff80005dea:	41 50                	push   %r8
ffffffff80005dec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ded:	48 8b 3d cc 52 00 00 	mov    0x52cc(%rip),%rdi        # ffffffff8000b0c0 <_ZN3Hal16ExceptionStringsE+0xc0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005df4:	56                   	push   %rsi
ffffffff80005df5:	51                   	push   %rcx
ffffffff80005df6:	52                   	push   %rdx
ffffffff80005df7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005df8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005dfd:	c6 44 24 70 18       	movb   $0x18,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e02:	fc                   	cld
ffffffff80005e03:	e8 a8 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e08:	58                   	pop    %rax
ffffffff80005e09:	5a                   	pop    %rdx
ffffffff80005e0a:	59                   	pop    %rcx
ffffffff80005e0b:	5e                   	pop    %rsi
ffffffff80005e0c:	5f                   	pop    %rdi
ffffffff80005e0d:	41 58                	pop    %r8
ffffffff80005e0f:	41 59                	pop    %r9
ffffffff80005e11:	41 5a                	pop    %r10
ffffffff80005e13:	41 5b                	pop    %r11
ffffffff80005e15:	48 cf                	iretq
ffffffff80005e17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e1e:	00 00 

ffffffff80005e20 <_ZN3Hal16ExceptionHandlerILm25EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e20:	f3 0f 1e fa          	endbr64
ffffffff80005e24:	41 53                	push   %r11
ffffffff80005e26:	41 52                	push   %r10
ffffffff80005e28:	41 51                	push   %r9
ffffffff80005e2a:	41 50                	push   %r8
ffffffff80005e2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005e2d:	48 8b 3d 94 52 00 00 	mov    0x5294(%rip),%rdi        # ffffffff8000b0c8 <_ZN3Hal16ExceptionStringsE+0xc8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e34:	56                   	push   %rsi
ffffffff80005e35:	51                   	push   %rcx
ffffffff80005e36:	52                   	push   %rdx
ffffffff80005e37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005e38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005e3d:	c6 44 24 70 19       	movb   $0x19,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e42:	fc                   	cld
ffffffff80005e43:	e8 68 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e48:	58                   	pop    %rax
ffffffff80005e49:	5a                   	pop    %rdx
ffffffff80005e4a:	59                   	pop    %rcx
ffffffff80005e4b:	5e                   	pop    %rsi
ffffffff80005e4c:	5f                   	pop    %rdi
ffffffff80005e4d:	41 58                	pop    %r8
ffffffff80005e4f:	41 59                	pop    %r9
ffffffff80005e51:	41 5a                	pop    %r10
ffffffff80005e53:	41 5b                	pop    %r11
ffffffff80005e55:	48 cf                	iretq
ffffffff80005e57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e5e:	00 00 

ffffffff80005e60 <_ZN3Hal16ExceptionHandlerILm26EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e60:	f3 0f 1e fa          	endbr64
ffffffff80005e64:	41 53                	push   %r11
ffffffff80005e66:	41 52                	push   %r10
ffffffff80005e68:	41 51                	push   %r9
ffffffff80005e6a:	41 50                	push   %r8
ffffffff80005e6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005e6d:	48 8b 3d 5c 52 00 00 	mov    0x525c(%rip),%rdi        # ffffffff8000b0d0 <_ZN3Hal16ExceptionStringsE+0xd0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005e74:	56                   	push   %rsi
ffffffff80005e75:	51                   	push   %rcx
ffffffff80005e76:	52                   	push   %rdx
ffffffff80005e77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005e78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005e7d:	c6 44 24 70 1a       	movb   $0x1a,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005e82:	fc                   	cld
ffffffff80005e83:	e8 28 f0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005e88:	58                   	pop    %rax
ffffffff80005e89:	5a                   	pop    %rdx
ffffffff80005e8a:	59                   	pop    %rcx
ffffffff80005e8b:	5e                   	pop    %rsi
ffffffff80005e8c:	5f                   	pop    %rdi
ffffffff80005e8d:	41 58                	pop    %r8
ffffffff80005e8f:	41 59                	pop    %r9
ffffffff80005e91:	41 5a                	pop    %r10
ffffffff80005e93:	41 5b                	pop    %r11
ffffffff80005e95:	48 cf                	iretq
ffffffff80005e97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005e9e:	00 00 

ffffffff80005ea0 <_ZN3Hal16ExceptionHandlerILm27EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ea0:	f3 0f 1e fa          	endbr64
ffffffff80005ea4:	41 53                	push   %r11
ffffffff80005ea6:	41 52                	push   %r10
ffffffff80005ea8:	41 51                	push   %r9
ffffffff80005eaa:	41 50                	push   %r8
ffffffff80005eac:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005ead:	48 8b 3d 24 52 00 00 	mov    0x5224(%rip),%rdi        # ffffffff8000b0d8 <_ZN3Hal16ExceptionStringsE+0xd8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005eb4:	56                   	push   %rsi
ffffffff80005eb5:	51                   	push   %rcx
ffffffff80005eb6:	52                   	push   %rdx
ffffffff80005eb7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005eb8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005ebd:	c6 44 24 70 1b       	movb   $0x1b,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005ec2:	fc                   	cld
ffffffff80005ec3:	e8 e8 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005ec8:	58                   	pop    %rax
ffffffff80005ec9:	5a                   	pop    %rdx
ffffffff80005eca:	59                   	pop    %rcx
ffffffff80005ecb:	5e                   	pop    %rsi
ffffffff80005ecc:	5f                   	pop    %rdi
ffffffff80005ecd:	41 58                	pop    %r8
ffffffff80005ecf:	41 59                	pop    %r9
ffffffff80005ed1:	41 5a                	pop    %r10
ffffffff80005ed3:	41 5b                	pop    %r11
ffffffff80005ed5:	48 cf                	iretq
ffffffff80005ed7:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005ede:	00 00 

ffffffff80005ee0 <_ZN3Hal16ExceptionHandlerILm28EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ee0:	f3 0f 1e fa          	endbr64
ffffffff80005ee4:	41 53                	push   %r11
ffffffff80005ee6:	41 52                	push   %r10
ffffffff80005ee8:	41 51                	push   %r9
ffffffff80005eea:	41 50                	push   %r8
ffffffff80005eec:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005eed:	48 8b 3d ec 51 00 00 	mov    0x51ec(%rip),%rdi        # ffffffff8000b0e0 <_ZN3Hal16ExceptionStringsE+0xe0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005ef4:	56                   	push   %rsi
ffffffff80005ef5:	51                   	push   %rcx
ffffffff80005ef6:	52                   	push   %rdx
ffffffff80005ef7:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005ef8:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005efd:	c6 44 24 70 1c       	movb   $0x1c,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f02:	fc                   	cld
ffffffff80005f03:	e8 a8 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f08:	58                   	pop    %rax
ffffffff80005f09:	5a                   	pop    %rdx
ffffffff80005f0a:	59                   	pop    %rcx
ffffffff80005f0b:	5e                   	pop    %rsi
ffffffff80005f0c:	5f                   	pop    %rdi
ffffffff80005f0d:	41 58                	pop    %r8
ffffffff80005f0f:	41 59                	pop    %r9
ffffffff80005f11:	41 5a                	pop    %r10
ffffffff80005f13:	41 5b                	pop    %r11
ffffffff80005f15:	48 cf                	iretq
ffffffff80005f17:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f1e:	00 00 

ffffffff80005f20 <_ZN3Hal16ExceptionHandlerILm29EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f20:	f3 0f 1e fa          	endbr64
ffffffff80005f24:	41 53                	push   %r11
ffffffff80005f26:	41 52                	push   %r10
ffffffff80005f28:	41 51                	push   %r9
ffffffff80005f2a:	41 50                	push   %r8
ffffffff80005f2c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005f2d:	48 8b 3d b4 51 00 00 	mov    0x51b4(%rip),%rdi        # ffffffff8000b0e8 <_ZN3Hal16ExceptionStringsE+0xe8>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f34:	56                   	push   %rsi
ffffffff80005f35:	51                   	push   %rcx
ffffffff80005f36:	52                   	push   %rdx
ffffffff80005f37:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005f38:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005f3d:	c6 44 24 70 1d       	movb   $0x1d,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f42:	fc                   	cld
ffffffff80005f43:	e8 68 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f48:	58                   	pop    %rax
ffffffff80005f49:	5a                   	pop    %rdx
ffffffff80005f4a:	59                   	pop    %rcx
ffffffff80005f4b:	5e                   	pop    %rsi
ffffffff80005f4c:	5f                   	pop    %rdi
ffffffff80005f4d:	41 58                	pop    %r8
ffffffff80005f4f:	41 59                	pop    %r9
ffffffff80005f51:	41 5a                	pop    %r10
ffffffff80005f53:	41 5b                	pop    %r11
ffffffff80005f55:	48 cf                	iretq
ffffffff80005f57:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f5e:	00 00 

ffffffff80005f60 <_ZN3Hal16ExceptionHandlerILm30EEEvPN6System10PanicFrameE>:
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f60:	f3 0f 1e fa          	endbr64
ffffffff80005f64:	41 53                	push   %r11
ffffffff80005f66:	41 52                	push   %r10
ffffffff80005f68:	41 51                	push   %r9
ffffffff80005f6a:	41 50                	push   %r8
ffffffff80005f6c:	57                   	push   %rdi
        Panic(ExceptionStrings[i], frame);
ffffffff80005f6d:	48 8b 3d 7c 51 00 00 	mov    0x517c(%rip),%rdi        # ffffffff8000b0f0 <_ZN3Hal16ExceptionStringsE+0xf0>
    __attribute__((interrupt)) void ExceptionHandler(System::PanicFrame* frame)
ffffffff80005f74:	56                   	push   %rsi
ffffffff80005f75:	51                   	push   %rcx
ffffffff80005f76:	52                   	push   %rdx
ffffffff80005f77:	50                   	push   %rax
        Panic(ExceptionStrings[i], frame);
ffffffff80005f78:	48 8d 74 24 48       	lea    0x48(%rsp),%rsi
        frame->InterruptVector = i;
ffffffff80005f7d:	c6 44 24 70 1e       	movb   $0x1e,0x70(%rsp)
        Panic(ExceptionStrings[i], frame);
ffffffff80005f82:	fc                   	cld
ffffffff80005f83:	e8 28 ef ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80005f88:	58                   	pop    %rax
ffffffff80005f89:	5a                   	pop    %rdx
ffffffff80005f8a:	59                   	pop    %rcx
ffffffff80005f8b:	5e                   	pop    %rsi
ffffffff80005f8c:	5f                   	pop    %rdi
ffffffff80005f8d:	41 58                	pop    %r8
ffffffff80005f8f:	41 59                	pop    %r9
ffffffff80005f91:	41 5a                	pop    %r10
ffffffff80005f93:	41 5b                	pop    %r11
ffffffff80005f95:	48 cf                	iretq
ffffffff80005f97:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80005f9e:	00 00 

ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>:
        };
    }

    template<int I, int N>
    struct SetHandler {
        static void run() {
ffffffff80005fa0:	f3 0f 1e fa          	endbr64
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80005fa4:	48 8b 05 f7 a3 0d 00 	mov    0xda3f7(%rip),%rax        # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2>
        uint64_t offset = (uint64_t)handler;
ffffffff80005fab:	48 c7 c2 a0 5d 00 80 	mov    $0xffffffff80005da0,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fb2:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005fb5:	66 89 90 70 01 00 00 	mov    %dx,0x170(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80005fbc:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fc0:	48 c1 ee 10          	shr    $0x10,%rsi
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80005fc4:	48 8d 88 e0 01 00 00 	lea    0x1e0(%rax),%rcx
        *ptr = InterruptDescriptor {
ffffffff80005fcb:	89 90 78 01 00 00    	mov    %edx,0x178(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80005fd1:	48 c7 c2 e0 5d 00 80 	mov    $0xffffffff80005de0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80005fd8:	66 89 b0 76 01 00 00 	mov    %si,0x176(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fdf:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005fe2:	66 89 90 80 01 00 00 	mov    %dx,0x180(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80005fe9:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80005fed:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80005ff1:	89 90 88 01 00 00    	mov    %edx,0x188(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80005ff7:	48 c7 c2 20 5e 00 80 	mov    $0xffffffff80005e20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80005ffe:	66 89 b0 86 01 00 00 	mov    %si,0x186(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006005:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006008:	66 89 90 90 01 00 00 	mov    %dx,0x190(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000600f:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006013:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006017:	89 90 98 01 00 00    	mov    %edx,0x198(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000601d:	48 c7 c2 60 5e 00 80 	mov    $0xffffffff80005e60,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006024:	66 89 b0 96 01 00 00 	mov    %si,0x196(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000602b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000602e:	66 89 90 a0 01 00 00 	mov    %dx,0x1a0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006035:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006039:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000603d:	89 90 a8 01 00 00    	mov    %edx,0x1a8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006043:	48 c7 c2 a0 5e 00 80 	mov    $0xffffffff80005ea0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000604a:	66 89 b0 a6 01 00 00 	mov    %si,0x1a6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006051:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006054:	66 89 90 b0 01 00 00 	mov    %dx,0x1b0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000605b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000605f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006063:	89 90 b8 01 00 00    	mov    %edx,0x1b8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006069:	48 c7 c2 e0 5e 00 80 	mov    $0xffffffff80005ee0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006070:	66 89 b0 b6 01 00 00 	mov    %si,0x1b6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006077:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000607a:	66 89 90 c0 01 00 00 	mov    %dx,0x1c0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006081:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006085:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006089:	89 90 c8 01 00 00    	mov    %edx,0x1c8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000608f:	48 c7 c2 20 5f 00 80 	mov    $0xffffffff80005f20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006096:	66 89 b0 c6 01 00 00 	mov    %si,0x1c6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000609d:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800060a0:	66 89 90 d0 01 00 00 	mov    %dx,0x1d0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800060a7:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800060ab:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800060af:	c7 80 72 01 00 00 08 	movl   $0x8f000008,0x172(%rax)
ffffffff800060b6:	00 00 8f 
ffffffff800060b9:	c7 80 7c 01 00 00 00 	movl   $0x0,0x17c(%rax)
ffffffff800060c0:	00 00 00 
ffffffff800060c3:	c7 80 82 01 00 00 08 	movl   $0x8f000008,0x182(%rax)
ffffffff800060ca:	00 00 8f 
ffffffff800060cd:	c7 80 8c 01 00 00 00 	movl   $0x0,0x18c(%rax)
ffffffff800060d4:	00 00 00 
ffffffff800060d7:	c7 80 92 01 00 00 08 	movl   $0x8f000008,0x192(%rax)
ffffffff800060de:	00 00 8f 
ffffffff800060e1:	c7 80 9c 01 00 00 00 	movl   $0x0,0x19c(%rax)
ffffffff800060e8:	00 00 00 
ffffffff800060eb:	c7 80 a2 01 00 00 08 	movl   $0x8f000008,0x1a2(%rax)
ffffffff800060f2:	00 00 8f 
ffffffff800060f5:	c7 80 ac 01 00 00 00 	movl   $0x0,0x1ac(%rax)
ffffffff800060fc:	00 00 00 
ffffffff800060ff:	c7 80 b2 01 00 00 08 	movl   $0x8f000008,0x1b2(%rax)
ffffffff80006106:	00 00 8f 
ffffffff80006109:	c7 80 bc 01 00 00 00 	movl   $0x0,0x1bc(%rax)
ffffffff80006110:	00 00 00 
ffffffff80006113:	c7 80 c2 01 00 00 08 	movl   $0x8f000008,0x1c2(%rax)
ffffffff8000611a:	00 00 8f 
ffffffff8000611d:	c7 80 cc 01 00 00 00 	movl   $0x0,0x1cc(%rax)
ffffffff80006124:	00 00 00 
ffffffff80006127:	c7 80 d2 01 00 00 08 	movl   $0x8f000008,0x1d2(%rax)
ffffffff8000612e:	00 00 8f 
ffffffff80006131:	89 90 d8 01 00 00    	mov    %edx,0x1d8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006137:	48 c7 c2 60 5f 00 80 	mov    $0xffffffff80005f60,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000613e:	66 89 90 e0 01 00 00 	mov    %dx,0x1e0(%rax)
ffffffff80006145:	66 89 b0 d6 01 00 00 	mov    %si,0x1d6(%rax)
ffffffff8000614c:	c7 80 dc 01 00 00 00 	movl   $0x0,0x1dc(%rax)
ffffffff80006153:	00 00 00 
ffffffff80006156:	c7 80 e2 01 00 00 08 	movl   $0x8f000008,0x1e2(%rax)
ffffffff8000615d:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006160:	48 89 d0             	mov    %rdx,%rax
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006163:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006167:	48 c1 e8 10          	shr    $0x10,%rax
        *ptr = InterruptDescriptor {
ffffffff8000616b:	89 51 08             	mov    %edx,0x8(%rcx)
ffffffff8000616e:	66 89 41 06          	mov    %ax,0x6(%rcx)
ffffffff80006172:	c7 41 0c 00 00 00 00 	movl   $0x0,0xc(%rcx)
            IDTEncodeInterrupt(I, (void*)&ExceptionHandler<I>, TrapGate);
            SetHandler<I+1,N>::run();
        }
ffffffff80006179:	c3                   	ret
ffffffff8000617a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)

ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>:
        static void run() {
ffffffff80006180:	f3 0f 1e fa          	endbr64
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff80006184:	48 8b 05 17 a2 0d 00 	mov    0xda217(%rip),%rax        # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2>
        uint64_t offset = (uint64_t)handler;
ffffffff8000618b:	48 c7 c2 a0 5a 00 80 	mov    $0xffffffff80005aa0,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006192:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006195:	66 89 90 b0 00 00 00 	mov    %dx,0xb0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000619c:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061a0:	48 c1 ee 10          	shr    $0x10,%rsi
        InterruptDescriptor* descriptor = (InterruptDescriptor*)(IDTR.Base + index * sizeof(InterruptDescriptor));
ffffffff800061a4:	48 8d 88 60 01 00 00 	lea    0x160(%rax),%rcx
        *ptr = InterruptDescriptor {
ffffffff800061ab:	89 90 b8 00 00 00    	mov    %edx,0xb8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061b1:	48 c7 c2 e0 5a 00 80 	mov    $0xffffffff80005ae0,%rdx
        *ptr = InterruptDescriptor {
ffffffff800061b8:	66 89 b0 b6 00 00 00 	mov    %si,0xb6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061bf:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061c2:	66 89 90 c0 00 00 00 	mov    %dx,0xc0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800061c9:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061cd:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061d1:	89 90 c8 00 00 00    	mov    %edx,0xc8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061d7:	48 c7 c2 20 5b 00 80 	mov    $0xffffffff80005b20,%rdx
        *ptr = InterruptDescriptor {
ffffffff800061de:	66 89 b0 c6 00 00 00 	mov    %si,0xc6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061e5:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061e8:	66 89 90 d0 00 00 00 	mov    %dx,0xd0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800061ef:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800061f3:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800061f7:	89 90 d8 00 00 00    	mov    %edx,0xd8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800061fd:	48 c7 c2 60 5b 00 80 	mov    $0xffffffff80005b60,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006204:	66 89 b0 d6 00 00 00 	mov    %si,0xd6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000620b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000620e:	66 89 90 e0 00 00 00 	mov    %dx,0xe0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006215:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006219:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000621d:	89 90 e8 00 00 00    	mov    %edx,0xe8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006223:	48 c7 c2 a0 5b 00 80 	mov    $0xffffffff80005ba0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000622a:	66 89 b0 e6 00 00 00 	mov    %si,0xe6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006231:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006234:	66 89 90 f0 00 00 00 	mov    %dx,0xf0(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000623b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000623f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006243:	89 90 f8 00 00 00    	mov    %edx,0xf8(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006249:	48 c7 c2 e0 5b 00 80 	mov    $0xffffffff80005be0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006250:	66 89 b0 f6 00 00 00 	mov    %si,0xf6(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006257:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000625a:	66 89 90 00 01 00 00 	mov    %dx,0x100(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006261:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006265:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006269:	89 90 08 01 00 00    	mov    %edx,0x108(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000626f:	48 c7 c2 20 5c 00 80 	mov    $0xffffffff80005c20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006276:	66 89 b0 06 01 00 00 	mov    %si,0x106(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000627d:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006280:	66 89 90 10 01 00 00 	mov    %dx,0x110(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006287:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000628b:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000628f:	c7 80 b2 00 00 00 08 	movl   $0x8f000008,0xb2(%rax)
ffffffff80006296:	00 00 8f 
ffffffff80006299:	c7 80 bc 00 00 00 00 	movl   $0x0,0xbc(%rax)
ffffffff800062a0:	00 00 00 
ffffffff800062a3:	c7 80 c2 00 00 00 08 	movl   $0x8f000008,0xc2(%rax)
ffffffff800062aa:	00 00 8f 
ffffffff800062ad:	c7 80 cc 00 00 00 00 	movl   $0x0,0xcc(%rax)
ffffffff800062b4:	00 00 00 
ffffffff800062b7:	c7 80 d2 00 00 00 08 	movl   $0x8f000008,0xd2(%rax)
ffffffff800062be:	00 00 8f 
ffffffff800062c1:	c7 80 dc 00 00 00 00 	movl   $0x0,0xdc(%rax)
ffffffff800062c8:	00 00 00 
ffffffff800062cb:	c7 80 e2 00 00 00 08 	movl   $0x8f000008,0xe2(%rax)
ffffffff800062d2:	00 00 8f 
ffffffff800062d5:	c7 80 ec 00 00 00 00 	movl   $0x0,0xec(%rax)
ffffffff800062dc:	00 00 00 
ffffffff800062df:	c7 80 f2 00 00 00 08 	movl   $0x8f000008,0xf2(%rax)
ffffffff800062e6:	00 00 8f 
ffffffff800062e9:	c7 80 fc 00 00 00 00 	movl   $0x0,0xfc(%rax)
ffffffff800062f0:	00 00 00 
ffffffff800062f3:	c7 80 02 01 00 00 08 	movl   $0x8f000008,0x102(%rax)
ffffffff800062fa:	00 00 8f 
ffffffff800062fd:	c7 80 0c 01 00 00 00 	movl   $0x0,0x10c(%rax)
ffffffff80006304:	00 00 00 
ffffffff80006307:	c7 80 12 01 00 00 08 	movl   $0x8f000008,0x112(%rax)
ffffffff8000630e:	00 00 8f 
ffffffff80006311:	89 90 18 01 00 00    	mov    %edx,0x118(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006317:	48 c7 c2 60 5c 00 80 	mov    $0xffffffff80005c60,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000631e:	66 89 b0 16 01 00 00 	mov    %si,0x116(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006325:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006328:	66 89 90 20 01 00 00 	mov    %dx,0x120(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000632f:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006333:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006337:	89 90 28 01 00 00    	mov    %edx,0x128(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff8000633d:	48 c7 c2 a0 5c 00 80 	mov    $0xffffffff80005ca0,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006344:	66 89 b0 26 01 00 00 	mov    %si,0x126(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000634b:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000634e:	66 89 90 30 01 00 00 	mov    %dx,0x130(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006355:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006359:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000635d:	89 90 38 01 00 00    	mov    %edx,0x138(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006363:	48 c7 c2 e0 5c 00 80 	mov    $0xffffffff80005ce0,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000636a:	66 89 b0 36 01 00 00 	mov    %si,0x136(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006371:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006374:	66 89 90 40 01 00 00 	mov    %dx,0x140(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000637b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000637f:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff80006383:	89 90 48 01 00 00    	mov    %edx,0x148(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff80006389:	48 c7 c2 20 5d 00 80 	mov    $0xffffffff80005d20,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006390:	66 89 b0 46 01 00 00 	mov    %si,0x146(%rax)
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006397:	48 89 d6             	mov    %rdx,%rsi
        *ptr = InterruptDescriptor {
ffffffff8000639a:	66 89 90 50 01 00 00 	mov    %dx,0x150(%rax)
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800063a1:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800063a5:	48 c1 ee 10          	shr    $0x10,%rsi
        *ptr = InterruptDescriptor {
ffffffff800063a9:	89 90 58 01 00 00    	mov    %edx,0x158(%rax)
        uint64_t offset = (uint64_t)handler;
ffffffff800063af:	48 c7 c2 60 5d 00 80 	mov    $0xffffffff80005d60,%rdx
        *ptr = InterruptDescriptor {
ffffffff800063b6:	66 89 90 60 01 00 00 	mov    %dx,0x160(%rax)
ffffffff800063bd:	c7 80 1c 01 00 00 00 	movl   $0x0,0x11c(%rax)
ffffffff800063c4:	00 00 00 
ffffffff800063c7:	c7 80 22 01 00 00 08 	movl   $0x8f000008,0x122(%rax)
ffffffff800063ce:	00 00 8f 
ffffffff800063d1:	c7 80 2c 01 00 00 00 	movl   $0x0,0x12c(%rax)
ffffffff800063d8:	00 00 00 
ffffffff800063db:	c7 80 32 01 00 00 08 	movl   $0x8f000008,0x132(%rax)
ffffffff800063e2:	00 00 8f 
ffffffff800063e5:	c7 80 3c 01 00 00 00 	movl   $0x0,0x13c(%rax)
ffffffff800063ec:	00 00 00 
ffffffff800063ef:	c7 80 42 01 00 00 08 	movl   $0x8f000008,0x142(%rax)
ffffffff800063f6:	00 00 8f 
ffffffff800063f9:	c7 80 4c 01 00 00 00 	movl   $0x0,0x14c(%rax)
ffffffff80006400:	00 00 00 
ffffffff80006403:	c7 80 52 01 00 00 08 	movl   $0x8f000008,0x152(%rax)
ffffffff8000640a:	00 00 8f 
ffffffff8000640d:	66 89 b0 56 01 00 00 	mov    %si,0x156(%rax)
ffffffff80006414:	c7 80 5c 01 00 00 00 	movl   $0x0,0x15c(%rax)
ffffffff8000641b:	00 00 00 
ffffffff8000641e:	c7 80 62 01 00 00 08 	movl   $0x8f000008,0x162(%rax)
ffffffff80006425:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006428:	48 89 d0             	mov    %rdx,%rax
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000642b:	48 c1 ea 20          	shr    $0x20,%rdx
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000642f:	48 c1 e8 10          	shr    $0x10,%rax
        *ptr = InterruptDescriptor {
ffffffff80006433:	89 51 08             	mov    %edx,0x8(%rcx)
ffffffff80006436:	66 89 41 06          	mov    %ax,0x6(%rcx)
ffffffff8000643a:	c7 41 0c 00 00 00 00 	movl   $0x0,0xc(%rcx)
            SetHandler<I+1,N>::run();
ffffffff80006441:	e9 5a fb ff ff       	jmp    ffffffff80005fa0 <_ZN3Hal10SetHandlerILi23ELi31EE3runEv>
ffffffff80006446:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000644d:	00 00 00 

ffffffff80006450 <_ZN3Hal13IDTInitializeEv>:
    };

    template<int N>
    struct SetHandler<N,N> {static void run() {}};

    void IDTInitialize() {
ffffffff80006450:	f3 0f 1e fa          	endbr64
ffffffff80006454:	48 83 ec 08          	sub    $0x8,%rsp
        IDT = (InterruptDescriptor*)Memory::g_heap->Request(4096);
ffffffff80006458:	48 8b 3d 71 a3 0d 00 	mov    0xda371(%rip),%rdi        # ffffffff800e07d0 <_ZN6Memory6g_heapE>
ffffffff8000645f:	be 00 10 00 00       	mov    $0x1000,%esi
ffffffff80006464:	e8 57 07 00 00       	call   ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>
        IDTR.Limit = 0x0FF;
ffffffff80006469:	b8 ff 00 00 00       	mov    $0xff,%eax
        IDTR.Base = (uint64_t)&IDT;
ffffffff8000646e:	48 c7 05 29 9f 0d 00 	movq   $0xffffffff800e03b0,0xd9f29(%rip)        # ffffffff800e03a2 <_ZN3Hal4IDTRE+0x2>
ffffffff80006475:	b0 03 0e 80 
        IDTR.Limit = 0x0FF;
ffffffff80006479:	66 89 05 20 9f 0d 00 	mov    %ax,0xd9f20(%rip)        # ffffffff800e03a0 <_ZN3Hal4IDTRE>
        uint64_t offset = (uint64_t)handler;
ffffffff80006480:	48 c7 c0 e0 57 00 80 	mov    $0xffffffff800057e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006487:	66 89 05 22 9f 0d 00 	mov    %ax,0xd9f22(%rip)        # ffffffff800e03b0 <_ZN3Hal3IDTE>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000648e:	48 89 c2             	mov    %rax,%rdx
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006491:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006495:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006499:	89 05 19 9f 0d 00    	mov    %eax,0xd9f19(%rip)        # ffffffff800e03b8 <_ZN3Hal3IDTE+0x8>
        uint64_t offset = (uint64_t)handler;
ffffffff8000649f:	48 c7 c0 20 58 00 80 	mov    $0xffffffff80005820,%rax
        *ptr = InterruptDescriptor {
ffffffff800064a6:	66 89 15 09 9f 0d 00 	mov    %dx,0xd9f09(%rip)        # ffffffff800e03b6 <_ZN3Hal3IDTE+0x6>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064ad:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064b0:	66 89 05 09 9f 0d 00 	mov    %ax,0xd9f09(%rip)        # ffffffff800e03c0 <_ZN3Lib6outputE>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800064b7:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064bb:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064bf:	89 05 03 9f 0d 00    	mov    %eax,0xd9f03(%rip)        # ffffffff800e03c8 <_ZN3Lib6outputE+0x8>
        uint64_t offset = (uint64_t)handler;
ffffffff800064c5:	48 c7 c0 60 58 00 80 	mov    $0xffffffff80005860,%rax
        *ptr = InterruptDescriptor {
ffffffff800064cc:	66 89 15 f3 9e 0d 00 	mov    %dx,0xd9ef3(%rip)        # ffffffff800e03c6 <_ZN3Lib6outputE+0x6>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064d3:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064d6:	66 89 05 f3 9e 0d 00 	mov    %ax,0xd9ef3(%rip)        # ffffffff800e03d0 <_ZN3Lib6outputE+0x10>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800064dd:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064e1:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064e5:	89 05 ed 9e 0d 00    	mov    %eax,0xd9eed(%rip)        # ffffffff800e03d8 <_ZN3Lib6outputE+0x18>
        uint64_t offset = (uint64_t)handler;
ffffffff800064eb:	48 c7 c0 a0 58 00 80 	mov    $0xffffffff800058a0,%rax
        *ptr = InterruptDescriptor {
ffffffff800064f2:	66 89 15 dd 9e 0d 00 	mov    %dx,0xd9edd(%rip)        # ffffffff800e03d6 <_ZN3Lib6outputE+0x16>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff800064f9:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff800064fc:	66 89 05 dd 9e 0d 00 	mov    %ax,0xd9edd(%rip)        # ffffffff800e03e0 <_ZN3Lib6outputE+0x20>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006503:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006507:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000650b:	89 05 d7 9e 0d 00    	mov    %eax,0xd9ed7(%rip)        # ffffffff800e03e8 <_ZN3Lib6outputE+0x28>
        uint64_t offset = (uint64_t)handler;
ffffffff80006511:	48 c7 c0 e0 58 00 80 	mov    $0xffffffff800058e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006518:	66 89 15 c7 9e 0d 00 	mov    %dx,0xd9ec7(%rip)        # ffffffff800e03e6 <_ZN3Lib6outputE+0x26>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000651f:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006522:	66 89 05 c7 9e 0d 00 	mov    %ax,0xd9ec7(%rip)        # ffffffff800e03f0 <_ZN3Lib6outputE+0x30>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006529:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000652d:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006531:	89 05 c1 9e 0d 00    	mov    %eax,0xd9ec1(%rip)        # ffffffff800e03f8 <_ZN3Lib6outputE+0x38>
        uint64_t offset = (uint64_t)handler;
ffffffff80006537:	48 c7 c0 20 59 00 80 	mov    $0xffffffff80005920,%rax
        *ptr = InterruptDescriptor {
ffffffff8000653e:	66 89 15 b1 9e 0d 00 	mov    %dx,0xd9eb1(%rip)        # ffffffff800e03f6 <_ZN3Lib6outputE+0x36>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006545:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006548:	66 89 05 b1 9e 0d 00 	mov    %ax,0xd9eb1(%rip)        # ffffffff800e0400 <_ZN3Lib6outputE+0x40>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000654f:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006553:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006557:	89 05 ab 9e 0d 00    	mov    %eax,0xd9eab(%rip)        # ffffffff800e0408 <_ZN3Lib6outputE+0x48>
        uint64_t offset = (uint64_t)handler;
ffffffff8000655d:	48 c7 c0 60 59 00 80 	mov    $0xffffffff80005960,%rax
        *ptr = InterruptDescriptor {
ffffffff80006564:	66 89 15 9b 9e 0d 00 	mov    %dx,0xd9e9b(%rip)        # ffffffff800e0406 <_ZN3Lib6outputE+0x46>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000656b:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000656e:	c7 05 3a 9e 0d 00 08 	movl   $0x8f000008,0xd9e3a(%rip)        # ffffffff800e03b2 <_ZN3Hal3IDTE+0x2>
ffffffff80006575:	00 00 8f 
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006578:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000657c:	c7 05 36 9e 0d 00 00 	movl   $0x0,0xd9e36(%rip)        # ffffffff800e03bc <_ZN3Hal3IDTE+0xc>
ffffffff80006583:	00 00 00 
ffffffff80006586:	c7 05 32 9e 0d 00 08 	movl   $0x8f000008,0xd9e32(%rip)        # ffffffff800e03c2 <_ZN3Lib6outputE+0x2>
ffffffff8000658d:	00 00 8f 
ffffffff80006590:	c7 05 32 9e 0d 00 00 	movl   $0x0,0xd9e32(%rip)        # ffffffff800e03cc <_ZN3Lib6outputE+0xc>
ffffffff80006597:	00 00 00 
ffffffff8000659a:	c7 05 2e 9e 0d 00 08 	movl   $0x8f000008,0xd9e2e(%rip)        # ffffffff800e03d2 <_ZN3Lib6outputE+0x12>
ffffffff800065a1:	00 00 8f 
ffffffff800065a4:	c7 05 2e 9e 0d 00 00 	movl   $0x0,0xd9e2e(%rip)        # ffffffff800e03dc <_ZN3Lib6outputE+0x1c>
ffffffff800065ab:	00 00 00 
ffffffff800065ae:	c7 05 2a 9e 0d 00 08 	movl   $0x8f000008,0xd9e2a(%rip)        # ffffffff800e03e2 <_ZN3Lib6outputE+0x22>
ffffffff800065b5:	00 00 8f 
ffffffff800065b8:	c7 05 2a 9e 0d 00 00 	movl   $0x0,0xd9e2a(%rip)        # ffffffff800e03ec <_ZN3Lib6outputE+0x2c>
ffffffff800065bf:	00 00 00 
ffffffff800065c2:	c7 05 26 9e 0d 00 08 	movl   $0x8f000008,0xd9e26(%rip)        # ffffffff800e03f2 <_ZN3Lib6outputE+0x32>
ffffffff800065c9:	00 00 8f 
ffffffff800065cc:	c7 05 26 9e 0d 00 00 	movl   $0x0,0xd9e26(%rip)        # ffffffff800e03fc <_ZN3Lib6outputE+0x3c>
ffffffff800065d3:	00 00 00 
ffffffff800065d6:	c7 05 22 9e 0d 00 08 	movl   $0x8f000008,0xd9e22(%rip)        # ffffffff800e0402 <_ZN3Lib6outputE+0x42>
ffffffff800065dd:	00 00 8f 
ffffffff800065e0:	c7 05 22 9e 0d 00 00 	movl   $0x0,0xd9e22(%rip)        # ffffffff800e040c <_ZN3Lib6outputE+0x4c>
ffffffff800065e7:	00 00 00 
ffffffff800065ea:	66 89 05 1f 9e 0d 00 	mov    %ax,0xd9e1f(%rip)        # ffffffff800e0410 <_ZN3Lib6outputE+0x50>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff800065f1:	48 c1 e8 20          	shr    $0x20,%rax
        *ptr = InterruptDescriptor {
ffffffff800065f5:	89 05 1d 9e 0d 00    	mov    %eax,0xd9e1d(%rip)        # ffffffff800e0418 <_ZN3Lib6outputE+0x58>
        uint64_t offset = (uint64_t)handler;
ffffffff800065fb:	48 c7 c0 a0 59 00 80 	mov    $0xffffffff800059a0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006602:	66 89 15 0d 9e 0d 00 	mov    %dx,0xd9e0d(%rip)        # ffffffff800e0416 <_ZN3Lib6outputE+0x56>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006609:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000660c:	66 89 05 0d 9e 0d 00 	mov    %ax,0xd9e0d(%rip)        # ffffffff800e0420 <_ZN3Lib6outputE+0x60>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006613:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006617:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff8000661b:	89 05 07 9e 0d 00    	mov    %eax,0xd9e07(%rip)        # ffffffff800e0428 <_ZN3Lib6outputE+0x68>
        uint64_t offset = (uint64_t)handler;
ffffffff80006621:	48 c7 c0 e0 59 00 80 	mov    $0xffffffff800059e0,%rax
        *ptr = InterruptDescriptor {
ffffffff80006628:	66 89 15 f7 9d 0d 00 	mov    %dx,0xd9df7(%rip)        # ffffffff800e0426 <_ZN3Lib6outputE+0x66>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000662f:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006632:	66 89 05 f7 9d 0d 00 	mov    %ax,0xd9df7(%rip)        # ffffffff800e0430 <_ZN3Lib6outputE+0x70>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006639:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000663d:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006641:	89 05 f1 9d 0d 00    	mov    %eax,0xd9df1(%rip)        # ffffffff800e0438 <_ZN3Lib6outputE+0x78>
        uint64_t offset = (uint64_t)handler;
ffffffff80006647:	48 c7 c0 20 5a 00 80 	mov    $0xffffffff80005a20,%rax
        *ptr = InterruptDescriptor {
ffffffff8000664e:	66 89 15 e1 9d 0d 00 	mov    %dx,0xd9de1(%rip)        # ffffffff800e0436 <_ZN3Lib6outputE+0x76>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006655:	48 89 c2             	mov    %rax,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006658:	66 89 05 e1 9d 0d 00 	mov    %ax,0xd9de1(%rip)        # ffffffff800e0440 <_ZN3Lib6outputE+0x80>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff8000665f:	48 c1 e8 20          	shr    $0x20,%rax
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff80006663:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006667:	89 05 db 9d 0d 00    	mov    %eax,0xd9ddb(%rip)        # ffffffff800e0448 <_ZN3Lib6outputE+0x88>
        uint64_t offset = (uint64_t)handler;
ffffffff8000666d:	48 c7 c0 60 5a 00 80 	mov    $0xffffffff80005a60,%rax
        *ptr = InterruptDescriptor {
ffffffff80006674:	66 89 15 cb 9d 0d 00 	mov    %dx,0xd9dcb(%rip)        # ffffffff800e0446 <_ZN3Lib6outputE+0x86>
            .Offset2 = (uint16_t)((offset & 0x00000000ffff0000) >> 16),
ffffffff8000667b:	48 89 c2             	mov    %rax,%rdx
ffffffff8000667e:	48 c1 ea 10          	shr    $0x10,%rdx
        *ptr = InterruptDescriptor {
ffffffff80006682:	66 89 05 c7 9d 0d 00 	mov    %ax,0xd9dc7(%rip)        # ffffffff800e0450 <_ZN3Lib6outputE+0x90>
            .Offset3 = (uint32_t)((offset & 0xffffffff00000000) >> 32),
ffffffff80006689:	48 c1 e8 20          	shr    $0x20,%rax
        *ptr = InterruptDescriptor {
ffffffff8000668d:	66 89 15 c2 9d 0d 00 	mov    %dx,0xd9dc2(%rip)        # ffffffff800e0456 <_ZN3Lib6outputE+0x96>
ffffffff80006694:	89 05 be 9d 0d 00    	mov    %eax,0xd9dbe(%rip)        # ffffffff800e0458 <_ZN3Lib6outputE+0x98>
ffffffff8000669a:	c7 05 6e 9d 0d 00 08 	movl   $0x8f000008,0xd9d6e(%rip)        # ffffffff800e0412 <_ZN3Lib6outputE+0x52>
ffffffff800066a1:	00 00 8f 
ffffffff800066a4:	c7 05 6e 9d 0d 00 00 	movl   $0x0,0xd9d6e(%rip)        # ffffffff800e041c <_ZN3Lib6outputE+0x5c>
ffffffff800066ab:	00 00 00 
ffffffff800066ae:	c7 05 6a 9d 0d 00 08 	movl   $0x8f000008,0xd9d6a(%rip)        # ffffffff800e0422 <_ZN3Lib6outputE+0x62>
ffffffff800066b5:	00 00 8f 
ffffffff800066b8:	c7 05 6a 9d 0d 00 00 	movl   $0x0,0xd9d6a(%rip)        # ffffffff800e042c <_ZN3Lib6outputE+0x6c>
ffffffff800066bf:	00 00 00 
ffffffff800066c2:	c7 05 66 9d 0d 00 08 	movl   $0x8f000008,0xd9d66(%rip)        # ffffffff800e0432 <_ZN3Lib6outputE+0x72>
ffffffff800066c9:	00 00 8f 
ffffffff800066cc:	c7 05 66 9d 0d 00 00 	movl   $0x0,0xd9d66(%rip)        # ffffffff800e043c <_ZN3Lib6outputE+0x7c>
ffffffff800066d3:	00 00 00 
ffffffff800066d6:	c7 05 62 9d 0d 00 08 	movl   $0x8f000008,0xd9d62(%rip)        # ffffffff800e0442 <_ZN3Lib6outputE+0x82>
ffffffff800066dd:	00 00 8f 
ffffffff800066e0:	c7 05 62 9d 0d 00 00 	movl   $0x0,0xd9d62(%rip)        # ffffffff800e044c <_ZN3Lib6outputE+0x8c>
ffffffff800066e7:	00 00 00 
ffffffff800066ea:	c7 05 5e 9d 0d 00 08 	movl   $0x8f000008,0xd9d5e(%rip)        # ffffffff800e0452 <_ZN3Lib6outputE+0x92>
ffffffff800066f1:	00 00 8f 
ffffffff800066f4:	c7 05 5e 9d 0d 00 00 	movl   $0x0,0xd9d5e(%rip)        # ffffffff800e045c <_ZN3Lib6outputE+0x9c>
ffffffff800066fb:	00 00 00 
            SetHandler<I+1,N>::run();
ffffffff800066fe:	e8 7d fa ff ff       	call   ffffffff80006180 <_ZN3Hal10SetHandlerILi11ELi31EE3runEv>
ffffffff80006703:	48 c7 c7 90 ad 00 80 	mov    $0xffffffff8000ad90,%rdi
ffffffff8000670a:	e8 71 08 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000670f:	48 c7 c7 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rdi
ffffffff80006716:	e8 65 08 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
        asm("lidt %0" : : "m"(idtr));
ffffffff8000671b:	0f 01 1d 7e 9c 0d 00 	lidt   0xd9c7e(%rip)        # ffffffff800e03a0 <_ZN3Hal4IDTRE>
ffffffff80006722:	48 c7 c7 d0 ad 00 80 	mov    $0xffffffff8000add0,%rdi
ffffffff80006729:	e8 52 08 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000672e:	48 c7 c7 c0 a9 00 80 	mov    $0xffffffff8000a9c0,%rdi
        kout << "HardwareAbstraction: Created exception interrupt vectors" << "\n";

        LoadIDT(IDTR);

        kout << "HardwareAbstraction: Loaded new IDT" << "\n";
    }
ffffffff80006735:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006739:	e9 42 08 00 00       	jmp    ffffffff80006f80 <_ZN2Kt5PrintEPKc>
ffffffff8000673e:	66 90                	xchg   %ax,%ax

ffffffff80006740 <memcpy>:
// They CAN be moved to a different .cpp file.
#include <cstdint>

extern "C" {

    void *memcpy(void *dest, const void *src, std::size_t n) {
ffffffff80006740:	f3 0f 1e fa          	endbr64
ffffffff80006744:	48 89 f8             	mov    %rdi,%rax
        std::uint8_t *pdest = static_cast<std::uint8_t *>(dest);
        const std::uint8_t *psrc = static_cast<const std::uint8_t *>(src);
    
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006747:	48 85 d2             	test   %rdx,%rdx
ffffffff8000674a:	74 16                	je     ffffffff80006762 <memcpy+0x22>
ffffffff8000674c:	31 c9                	xor    %ecx,%ecx
ffffffff8000674e:	66 90                	xchg   %ax,%ax
            pdest[i] = psrc[i];
ffffffff80006750:	44 0f b6 04 0e       	movzbl (%rsi,%rcx,1),%r8d
ffffffff80006755:	44 88 04 08          	mov    %r8b,(%rax,%rcx,1)
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006759:	48 83 c1 01          	add    $0x1,%rcx
ffffffff8000675d:	48 39 ca             	cmp    %rcx,%rdx
ffffffff80006760:	75 ee                	jne    ffffffff80006750 <memcpy+0x10>
        }
    
        return dest;
    }
ffffffff80006762:	c3                   	ret
ffffffff80006763:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000676a:	00 00 00 
ffffffff8000676d:	0f 1f 00             	nopl   (%rax)

ffffffff80006770 <memset>:
    
    void *memset(void *s, int c, std::size_t n) {
ffffffff80006770:	f3 0f 1e fa          	endbr64
ffffffff80006774:	48 89 f8             	mov    %rdi,%rax
ffffffff80006777:	48 89 f9             	mov    %rdi,%rcx
ffffffff8000677a:	48 8d 3c 3a          	lea    (%rdx,%rdi,1),%rdi
        std::uint8_t *p = static_cast<std::uint8_t *>(s);
    
        for (std::size_t i = 0; i < n; i++) {
            p[i] = static_cast<uint8_t>(c);
ffffffff8000677e:	41 89 f0             	mov    %esi,%r8d
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006781:	48 85 d2             	test   %rdx,%rdx
ffffffff80006784:	74 2a                	je     ffffffff800067b0 <memset+0x40>
ffffffff80006786:	48 89 fa             	mov    %rdi,%rdx
ffffffff80006789:	48 29 c2             	sub    %rax,%rdx
ffffffff8000678c:	83 e2 01             	and    $0x1,%edx
ffffffff8000678f:	74 0f                	je     ffffffff800067a0 <memset+0x30>
ffffffff80006791:	48 8d 48 01          	lea    0x1(%rax),%rcx
            p[i] = static_cast<uint8_t>(c);
ffffffff80006795:	40 88 30             	mov    %sil,(%rax)
        for (std::size_t i = 0; i < n; i++) {
ffffffff80006798:	48 39 f9             	cmp    %rdi,%rcx
ffffffff8000679b:	74 14                	je     ffffffff800067b1 <memset+0x41>
ffffffff8000679d:	0f 1f 00             	nopl   (%rax)
            p[i] = static_cast<uint8_t>(c);
ffffffff800067a0:	44 88 01             	mov    %r8b,(%rcx)
        for (std::size_t i = 0; i < n; i++) {
ffffffff800067a3:	48 83 c1 02          	add    $0x2,%rcx
            p[i] = static_cast<uint8_t>(c);
ffffffff800067a7:	44 88 41 ff          	mov    %r8b,-0x1(%rcx)
        for (std::size_t i = 0; i < n; i++) {
ffffffff800067ab:	48 39 f9             	cmp    %rdi,%rcx
ffffffff800067ae:	75 f0                	jne    ffffffff800067a0 <memset+0x30>
        }
    
        return s;
    }
ffffffff800067b0:	c3                   	ret
ffffffff800067b1:	c3                   	ret
ffffffff800067b2:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800067b9:	00 00 00 
ffffffff800067bc:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>:
            str[si++] = tmp[rdi--];
        str[si] = '\0';
        return str;
    }

    char *u64_2_basestr(uint64_t num, size_t radix)
ffffffff800067c0:	48 81 ec 20 01 00 00 	sub    $0x120,%rsp

        if (!num) {
            return (char *)"0";
        }

        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800067c7:	48 b8 30 31 32 33 34 	movabs $0x3736353433323130,%rax
ffffffff800067ce:	35 36 37 
ffffffff800067d1:	48 89 44 24 0d       	mov    %rax,0xd(%rsp)
ffffffff800067d6:	48 b8 38 39 41 42 43 	movabs $0x4645444342413938,%rax
ffffffff800067dd:	44 45 46 
ffffffff800067e0:	48 89 44 24 15       	mov    %rax,0x15(%rsp)

        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800067e5:	48 8d 46 fe          	lea    -0x2(%rsi),%rax
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800067e9:	c7 44 24 1c 46 47 48 	movl   $0x484746,0x1c(%rsp)
ffffffff800067f0:	00 
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800067f1:	48 83 f8 10          	cmp    $0x10,%rax
ffffffff800067f5:	0f 87 8d 00 00 00    	ja     ffffffff80006888 <_ZN3Lib13u64_2_basestrEmm.part.0+0xc8>

        int si = 0;

        char tmp[256];
        int rdi = -1;
        while (num)
ffffffff800067fb:	45 31 c0             	xor    %r8d,%r8d
ffffffff800067fe:	48 c7 c1 c0 03 0e 80 	mov    $0xffffffff800e03c0,%rcx
ffffffff80006805:	48 85 ff             	test   %rdi,%rdi
ffffffff80006808:	74 65                	je     ffffffff8000686f <_ZN3Lib13u64_2_basestrEmm.part.0+0xaf>
ffffffff8000680a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        {
            tmp[++rdi] = base[num % radix];
ffffffff80006810:	48 89 f8             	mov    %rdi,%rax
ffffffff80006813:	31 d2                	xor    %edx,%edx
ffffffff80006815:	4c 89 c1             	mov    %r8,%rcx
ffffffff80006818:	48 f7 f6             	div    %rsi
ffffffff8000681b:	0f b6 54 14 0d       	movzbl 0xd(%rsp,%rdx,1),%edx
ffffffff80006820:	42 88 54 04 20       	mov    %dl,0x20(%rsp,%r8,1)
            num /= radix;
ffffffff80006825:	48 89 fa             	mov    %rdi,%rdx
        while (num)
ffffffff80006828:	4d 8d 40 01          	lea    0x1(%r8),%r8
            num /= radix;
ffffffff8000682c:	48 89 c7             	mov    %rax,%rdi
        while (num)
ffffffff8000682f:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006832:	73 dc                	jae    ffffffff80006810 <_ZN3Lib13u64_2_basestrEmm.part.0+0x50>
ffffffff80006834:	48 63 c1             	movslq %ecx,%rax
ffffffff80006837:	48 8d 7c 24 20       	lea    0x20(%rsp),%rdi
            tmp[++rdi] = base[num % radix];
ffffffff8000683c:	31 d2                	xor    %edx,%edx
ffffffff8000683e:	48 01 f8             	add    %rdi,%rax
ffffffff80006841:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        }
        while (rdi >= 0)
            str[si++] = tmp[rdi--];
ffffffff80006848:	0f b6 30             	movzbl (%rax),%esi
        while (rdi >= 0)
ffffffff8000684b:	48 83 e8 01          	sub    $0x1,%rax
            str[si++] = tmp[rdi--];
ffffffff8000684f:	40 88 b2 c0 03 0e 80 	mov    %sil,-0x7ff1fc40(%rdx)
        while (rdi >= 0)
ffffffff80006856:	48 89 d6             	mov    %rdx,%rsi
ffffffff80006859:	48 83 c2 01          	add    $0x1,%rdx
ffffffff8000685d:	48 39 ce             	cmp    %rcx,%rsi
ffffffff80006860:	75 e6                	jne    ffffffff80006848 <_ZN3Lib13u64_2_basestrEmm.part.0+0x88>
        str[si] = '\0';
ffffffff80006862:	83 c1 01             	add    $0x1,%ecx
ffffffff80006865:	48 63 c9             	movslq %ecx,%rcx
ffffffff80006868:	48 81 c1 c0 03 0e 80 	add    $0xffffffff800e03c0,%rcx
ffffffff8000686f:	c6 01 00             	movb   $0x0,(%rcx)
        return str;
    }
ffffffff80006872:	48 c7 c0 c0 03 0e 80 	mov    $0xffffffff800e03c0,%rax
ffffffff80006879:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff80006880:	c3                   	ret
ffffffff80006881:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            str[0] = '\0';
ffffffff80006888:	c6 05 31 9b 0d 00 00 	movb   $0x0,0xd9b31(%rip)        # ffffffff800e03c0 <_ZN3Lib6outputE>
    }
ffffffff8000688f:	48 c7 c0 c0 03 0e 80 	mov    $0xffffffff800e03c0,%rax
ffffffff80006896:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff8000689d:	c3                   	ret
ffffffff8000689e:	66 90                	xchg   %ax,%ax

ffffffff800068a0 <_ZN3Lib11int2basestrEim>:
    {
ffffffff800068a0:	f3 0f 1e fa          	endbr64
        if (!num) {
ffffffff800068a4:	85 ff                	test   %edi,%edi
ffffffff800068a6:	0f 84 d4 00 00 00    	je     ffffffff80006980 <_ZN3Lib11int2basestrEim+0xe0>
    {
ffffffff800068ac:	48 81 ec 20 01 00 00 	sub    $0x120,%rsp
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800068b3:	48 b8 30 31 32 33 34 	movabs $0x3736353433323130,%rax
ffffffff800068ba:	35 36 37 
ffffffff800068bd:	48 89 44 24 0d       	mov    %rax,0xd(%rsp)
ffffffff800068c2:	48 b8 38 39 41 42 43 	movabs $0x4645444342413938,%rax
ffffffff800068c9:	44 45 46 
ffffffff800068cc:	48 89 44 24 15       	mov    %rax,0x15(%rsp)
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800068d1:	48 8d 46 fe          	lea    -0x2(%rsi),%rax
        char base[] = "0123456789ABCDEFGH"; // IJKLMN ....
ffffffff800068d5:	c7 44 24 1c 46 47 48 	movl   $0x484746,0x1c(%rsp)
ffffffff800068dc:	00 
        if (radix < 2 || radix > (sizeof(base) - 1))
ffffffff800068dd:	48 83 f8 10          	cmp    $0x10,%rax
ffffffff800068e1:	77 7d                	ja     ffffffff80006960 <_ZN3Lib11int2basestrEim+0xc0>
        if (num < 0)
ffffffff800068e3:	45 31 c9             	xor    %r9d,%r9d
ffffffff800068e6:	85 ff                	test   %edi,%edi
ffffffff800068e8:	0f 88 a2 00 00 00    	js     ffffffff80006990 <_ZN3Lib11int2basestrEim+0xf0>
            str[si++] = '-';
ffffffff800068ee:	31 c9                	xor    %ecx,%ecx
            tmp[++rdi] = base[num % radix];
ffffffff800068f0:	48 63 c7             	movslq %edi,%rax
ffffffff800068f3:	31 d2                	xor    %edx,%edx
ffffffff800068f5:	49 89 c8             	mov    %rcx,%r8
ffffffff800068f8:	48 f7 f6             	div    %rsi
ffffffff800068fb:	0f b6 54 14 0d       	movzbl 0xd(%rsp,%rdx,1),%edx
            num /= radix;
ffffffff80006900:	89 c7                	mov    %eax,%edi
            tmp[++rdi] = base[num % radix];
ffffffff80006902:	88 54 0c 20          	mov    %dl,0x20(%rsp,%rcx,1)
        while (num)
ffffffff80006906:	48 8d 49 01          	lea    0x1(%rcx),%rcx
ffffffff8000690a:	85 c0                	test   %eax,%eax
ffffffff8000690c:	75 e2                	jne    ffffffff800068f0 <_ZN3Lib11int2basestrEim+0x50>
ffffffff8000690e:	48 8d 74 24 20       	lea    0x20(%rsp),%rsi
ffffffff80006913:	49 63 c9             	movslq %r9d,%rcx
ffffffff80006916:	49 63 c0             	movslq %r8d,%rax
ffffffff80006919:	48 01 f0             	add    %rsi,%rax
ffffffff8000691c:	48 8d 91 c0 03 0e 80 	lea    -0x7ff1fc40(%rcx),%rdx
ffffffff80006923:	4a 8d b4 01 c1 03 0e 	lea    -0x7ff1fc3f(%rcx,%r8,1),%rsi
ffffffff8000692a:	80 
ffffffff8000692b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            str[si++] = tmp[rdi--];
ffffffff80006930:	0f b6 08             	movzbl (%rax),%ecx
        while (rdi >= 0)
ffffffff80006933:	48 83 c2 01          	add    $0x1,%rdx
ffffffff80006937:	48 83 e8 01          	sub    $0x1,%rax
            str[si++] = tmp[rdi--];
ffffffff8000693b:	88 4a ff             	mov    %cl,-0x1(%rdx)
        while (rdi >= 0)
ffffffff8000693e:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006941:	75 ed                	jne    ffffffff80006930 <_ZN3Lib11int2basestrEim+0x90>
        str[si] = '\0';
ffffffff80006943:	43 8d 44 01 01       	lea    0x1(%r9,%r8,1),%eax
ffffffff80006948:	48 98                	cltq
ffffffff8000694a:	c6 80 c0 03 0e 80 00 	movb   $0x0,-0x7ff1fc40(%rax)
            return str;
ffffffff80006951:	48 c7 c0 c0 03 0e 80 	mov    $0xffffffff800e03c0,%rax
    }
ffffffff80006958:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff8000695f:	c3                   	ret
            str[0] = '\0';
ffffffff80006960:	c6 05 59 9a 0d 00 00 	movb   $0x0,0xd9a59(%rip)        # ffffffff800e03c0 <_ZN3Lib6outputE>
            return str;
ffffffff80006967:	48 c7 c0 c0 03 0e 80 	mov    $0xffffffff800e03c0,%rax
    }
ffffffff8000696e:	48 81 c4 20 01 00 00 	add    $0x120,%rsp
ffffffff80006975:	c3                   	ret
ffffffff80006976:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff8000697d:	00 00 00 
ffffffff80006980:	48 c7 c0 c3 ac 00 80 	mov    $0xffffffff8000acc3,%rax
ffffffff80006987:	c3                   	ret
ffffffff80006988:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff8000698f:	00 
            str[si++] = '-';
ffffffff80006990:	c6 05 29 9a 0d 00 2d 	movb   $0x2d,0xd9a29(%rip)        # ffffffff800e03c0 <_ZN3Lib6outputE>
            num = -num;
ffffffff80006997:	f7 df                	neg    %edi
            str[si++] = '-';
ffffffff80006999:	41 b9 01 00 00 00    	mov    $0x1,%r9d
ffffffff8000699f:	e9 4a ff ff ff       	jmp    ffffffff800068ee <_ZN3Lib11int2basestrEim+0x4e>
ffffffff800069a4:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff800069ab:	00 00 00 
ffffffff800069ae:	66 90                	xchg   %ax,%ax

ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>:
    {
ffffffff800069b0:	f3 0f 1e fa          	endbr64
        if (!num) {
ffffffff800069b4:	48 85 ff             	test   %rdi,%rdi
ffffffff800069b7:	74 07                	je     ffffffff800069c0 <_ZN3Lib13u64_2_basestrEmm+0x10>
ffffffff800069b9:	e9 02 fe ff ff       	jmp    ffffffff800067c0 <_ZN3Lib13u64_2_basestrEmm.part.0>
ffffffff800069be:	66 90                	xchg   %ax,%ax
    }
ffffffff800069c0:	48 c7 c0 c3 ac 00 80 	mov    $0xffffffff8000acc3,%rax
ffffffff800069c7:	c3                   	ret
ffffffff800069c8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff800069cf:	00 

ffffffff800069d0 <kmain>:

// Extern declarations for global constructors array.
extern void (*__init_array[])();
extern void (*__init_array_end[])();

extern "C" void kmain() {
ffffffff800069d0:	f3 0f 1e fa          	endbr64
ffffffff800069d4:	53                   	push   %rbx
ffffffff800069d5:	48 83 ec 20          	sub    $0x20,%rsp
    if (LIMINE_BASE_REVISION_SUPPORTED == false) {
ffffffff800069d9:	48 8b 05 40 97 ff ff 	mov    -0x68c0(%rip),%rax        # ffffffff80000120 <_ZN12_GLOBAL__N_120limine_base_revisionE+0x10>
ffffffff800069e0:	48 85 c0             	test   %rax,%rax
ffffffff800069e3:	0f 85 47 01 00 00    	jne    ffffffff80006b30 <kmain+0x160>
        hcf();
    }

    // Call global constructors.
    for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) {
ffffffff800069e9:	48 c7 c0 0f af 00 80 	mov    $0xffffffff8000af0f,%rax
ffffffff800069f0:	48 3d 0f af 00 80    	cmp    $0xffffffff8000af0f,%rax
ffffffff800069f6:	74 17                	je     ffffffff80006a0f <kmain+0x3f>
ffffffff800069f8:	48 89 c3             	mov    %rax,%rbx
ffffffff800069fb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
        __init_array[i]();
ffffffff80006a00:	ff 13                	call   *(%rbx)
    for (std::size_t i = 0; &__init_array[i] != __init_array_end; i++) {
ffffffff80006a02:	48 83 c3 08          	add    $0x8,%rbx
ffffffff80006a06:	48 81 fb 0f af 00 80 	cmp    $0xffffffff8000af0f,%rbx
ffffffff80006a0d:	75 f1                	jne    ffffffff80006a00 <kmain+0x30>
    }

    if (framebuffer_request.response == nullptr
ffffffff80006a0f:	48 8b 05 f2 96 ff ff 	mov    -0x690e(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
     || framebuffer_request.response->framebuffer_count < 1) {
ffffffff80006a16:	48 85 c0             	test   %rax,%rax
ffffffff80006a19:	0f 84 01 01 00 00    	je     ffffffff80006b20 <kmain+0x150>
ffffffff80006a1f:	48 8b 05 e2 96 ff ff 	mov    -0x691e(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
ffffffff80006a26:	48 83 78 08 00       	cmpq   $0x0,0x8(%rax)
ffffffff80006a2b:	0f 84 ef 00 00 00    	je     ffffffff80006b20 <kmain+0x150>
        hcf();
    }
    
    limine_framebuffer *framebuffer{framebuffer_request.response->framebuffers[0]};
ffffffff80006a31:	48 8b 05 d0 96 ff ff 	mov    -0x6930(%rip),%rax        # ffffffff80000108 <_ZN12_GLOBAL__N_119framebuffer_requestE+0x28>
ffffffff80006a38:	48 8b 40 10          	mov    0x10(%rax),%rax
ffffffff80006a3c:	48 8b 00             	mov    (%rax),%rax

    Kt::Initialize(
ffffffff80006a3f:	44 0f b6 50 28       	movzbl 0x28(%rax),%r10d
ffffffff80006a44:	44 0f b6 48 24       	movzbl 0x24(%rax),%r9d
ffffffff80006a49:	44 0f b6 40 23       	movzbl 0x23(%rax),%r8d
ffffffff80006a4e:	48 8b 48 18          	mov    0x18(%rax),%rcx
ffffffff80006a52:	48 8b 50 10          	mov    0x10(%rax),%rdx
ffffffff80006a56:	48 8b 70 08          	mov    0x8(%rax),%rsi
ffffffff80006a5a:	48 8b 38             	mov    (%rax),%rdi
ffffffff80006a5d:	41 52                	push   %r10
ffffffff80006a5f:	44 0f b6 50 27       	movzbl 0x27(%rax),%r10d
ffffffff80006a64:	41 52                	push   %r10
ffffffff80006a66:	44 0f b6 50 26       	movzbl 0x26(%rax),%r10d
ffffffff80006a6b:	41 52                	push   %r10
ffffffff80006a6d:	0f b6 40 25          	movzbl 0x25(%rax),%eax
ffffffff80006a71:	50                   	push   %rax
ffffffff80006a72:	e8 59 04 00 00       	call   ffffffff80006ed0 <_ZN2Kt10InitializeEPjmmmhhhhhh>
        framebuffer->blue_mask_size,
        framebuffer->blue_mask_shift
    );

#if defined (__x86_64__)
    Hal::PrepareGDT();
ffffffff80006a77:	48 83 c4 20          	add    $0x20,%rsp
ffffffff80006a7b:	e8 60 ec ff ff       	call   ffffffff800056e0 <_ZN3Hal10PrepareGDTEv>
    Hal::BridgeLoadGDT();
ffffffff80006a80:	e8 0b ed ff ff       	call   ffffffff80005790 <_ZN3Hal13BridgeLoadGDTEv>
#endif

    uint64_t hhdm_offset = hhdm_request.response->offset;
ffffffff80006a85:	48 8b 05 fc 95 ff ff 	mov    -0x6a04(%rip),%rax        # ffffffff80000088 <_ZN12_GLOBAL__N_112hhdm_requestE+0x28>
    Memory::HHDMBase = hhdm_offset;
ffffffff80006a8c:	48 8b 40 08          	mov    0x8(%rax),%rax
ffffffff80006a90:	48 89 05 31 9d 0d 00 	mov    %rax,0xd9d31(%rip)        # ffffffff800e07c8 <_ZN6Memory8HHDMBaseE>

    if (memmap_request.response != nullptr) {
ffffffff80006a97:	48 8b 05 aa 95 ff ff 	mov    -0x6a56(%rip),%rax        # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28>
ffffffff80006a9e:	48 85 c0             	test   %rax,%rax
ffffffff80006aa1:	0f 84 99 00 00 00    	je     ffffffff80006b40 <kmain+0x170>
ffffffff80006aa7:	48 c7 c7 18 ae 00 80 	mov    $0xffffffff8000ae18,%rdi
        kout << "MemoryManagement: Creating global HeapAllocator" << newline;

        auto result = Memory::Scan(memmap_request.response);
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006aae:	48 89 e3             	mov    %rsp,%rbx
ffffffff80006ab1:	e8 ca 04 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006ab6:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006abb:	e8 90 04 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
        auto result = Memory::Scan(memmap_request.response);
ffffffff80006ac0:	48 8b 3d 81 95 ff ff 	mov    -0x6a7f(%rip),%rdi        # ffffffff80000048 <_ZN12_GLOBAL__N_114memmap_requestE+0x28>
ffffffff80006ac7:	e8 c4 02 00 00       	call   ffffffff80006d90 <_ZN6Memory4ScanEP22limine_memmap_response>
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006acc:	48 89 df             	mov    %rbx,%rdi
        auto result = Memory::Scan(memmap_request.response);
ffffffff80006acf:	48 89 c6             	mov    %rax,%rsi
        auto allocator = Memory::HeapAllocator(result);
ffffffff80006ad2:	e8 89 00 00 00       	call   ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>

        Memory::g_heap = &allocator;
ffffffff80006ad7:	48 89 1d f2 9c 0d 00 	mov    %rbx,0xd9cf2(%rip)        # ffffffff800e07d0 <_ZN6Memory6g_heapE>
    } else {
        Panic("Guru Meditation Error: System memory map missing!", nullptr);
    }

#if defined (__x86_64__)
    Hal::IDTInitialize();
ffffffff80006ade:	e8 6d f9 ff ff       	call   ffffffff80006450 <_ZN3Hal13IDTInitializeEv>
#endif

    kcp::cstringstream stream;
ffffffff80006ae3:	48 89 df             	mov    %rbx,%rdi
ffffffff80006ae6:	e8 f5 ea ff ff       	call   ffffffff800055e0 <_ZN3kcp13cstringstreamC1Ev>
    stream<<"Hello, World";
ffffffff80006aeb:	48 c7 c6 c5 ac 00 80 	mov    $0xffffffff8000acc5,%rsi
ffffffff80006af2:	48 89 df             	mov    %rbx,%rdi
ffffffff80006af5:	e8 36 eb ff ff       	call   ffffffff80005630 <_ZN3kcp13cstringstreamlsEPKc>

    Memory::g_heap->Walk();
ffffffff80006afa:	48 8b 3d cf 9c 0d 00 	mov    0xd9ccf(%rip),%rdi        # ffffffff800e07d0 <_ZN6Memory6g_heapE>
ffffffff80006b01:	e8 ba 01 00 00       	call   ffffffff80006cc0 <_ZN6Memory13HeapAllocator4WalkEv>

    hcf();
ffffffff80006b06:	e8 b5 03 00 00       	call   ffffffff80006ec0 <_Z3hcfv>
}
ffffffff80006b0b:	48 89 df             	mov    %rbx,%rdi
ffffffff80006b0e:	e8 ed ea ff ff       	call   ffffffff80005600 <_ZN3kcp13cstringstreamD1Ev>
ffffffff80006b13:	48 83 c4 20          	add    $0x20,%rsp
ffffffff80006b17:	5b                   	pop    %rbx
ffffffff80006b18:	c3                   	ret
ffffffff80006b19:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
        hcf();
ffffffff80006b20:	e8 9b 03 00 00       	call   ffffffff80006ec0 <_Z3hcfv>
ffffffff80006b25:	e9 07 ff ff ff       	jmp    ffffffff80006a31 <kmain+0x61>
ffffffff80006b2a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        hcf();
ffffffff80006b30:	e8 8b 03 00 00       	call   ffffffff80006ec0 <_Z3hcfv>
ffffffff80006b35:	e9 af fe ff ff       	jmp    ffffffff800069e9 <kmain+0x19>
ffffffff80006b3a:	66 0f 1f 44 00 00    	nopw   0x0(%rax,%rax,1)
        Panic("Guru Meditation Error: System memory map missing!", nullptr);
ffffffff80006b40:	31 f6                	xor    %esi,%esi
ffffffff80006b42:	48 c7 c7 48 ae 00 80 	mov    $0xffffffff8000ae48,%rdi
ffffffff80006b49:	48 89 e3             	mov    %rsp,%rbx
ffffffff80006b4c:	e8 5f e3 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
ffffffff80006b51:	eb 8b                	jmp    ffffffff80006ade <kmain+0x10e>
ffffffff80006b53:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006b5a:	00 00 00 
ffffffff80006b5d:	0f 1f 00             	nopl   (%rax)

ffffffff80006b60 <_ZN6Memory13HeapAllocatorC1ENS_14LargestSectionE>:

namespace Memory
{
    constexpr size_t metadata_size = 8; // 8 bytes
    
    HeapAllocator::HeapAllocator(LargestSection section)
ffffffff80006b60:	f3 0f 1e fa          	endbr64
ffffffff80006b64:	41 54                	push   %r12
ffffffff80006b66:	49 89 d4             	mov    %rdx,%r12
ffffffff80006b69:	55                   	push   %rbp
ffffffff80006b6a:	48 89 f5             	mov    %rsi,%rbp
ffffffff80006b6d:	53                   	push   %rbx
ffffffff80006b6e:	48 89 fb             	mov    %rdi,%rbx
ffffffff80006b71:	48 c7 47 10 00 00 00 	movq   $0x0,0x10(%rdi)
ffffffff80006b78:	00 
ffffffff80006b79:	48 c7 47 18 00 00 00 	movq   $0x0,0x18(%rdi)
ffffffff80006b80:	00 
            Print(string);
ffffffff80006b81:	48 c7 c7 80 ae 00 80 	mov    $0xffffffff8000ae80,%rdi
ffffffff80006b88:	e8 f3 03 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006b8d:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006b92:	e8 b9 03 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>

namespace Memory {
    extern std::uint64_t HHDMBase;

    inline uint64_t HHDM(uint64_t address) {
        return HHDMBase + address;
ffffffff80006b97:	48 8b 35 2a 9c 0d 00 	mov    0xd9c2a(%rip),%rsi        # ffffffff800e07c8 <_ZN6Memory8HHDMBaseE>
    {
        kout << "HeapAllocator: constructor called" << Kt::newline;
        
        // section contains the physical address, we need the virtual address, so we call the helper
        g_section = LargestSection {
ffffffff80006b9e:	4c 89 63 08          	mov    %r12,0x8(%rbx)
            .address = HHDM(section.address),
            .size = section.size
        };

        head = Node {
ffffffff80006ba2:	48 c7 43 10 00 00 00 	movq   $0x0,0x10(%rbx)
ffffffff80006ba9:	00 
ffffffff80006baa:	48 01 ee             	add    %rbp,%rsi
        g_section = LargestSection {
ffffffff80006bad:	48 89 33             	mov    %rsi,(%rbx)
        head = Node {
ffffffff80006bb0:	48 89 73 18          	mov    %rsi,0x18(%rbx)
            .size = 0,
            .next = (Node*)g_section.address
        };

        head.next->size = g_section.size;
ffffffff80006bb4:	4c 89 26             	mov    %r12,(%rsi)
        head.size = 0;//!!!!!!
    }
ffffffff80006bb7:	5b                   	pop    %rbx
ffffffff80006bb8:	5d                   	pop    %rbp
ffffffff80006bb9:	41 5c                	pop    %r12
ffffffff80006bbb:	c3                   	ret
ffffffff80006bbc:	0f 1f 40 00          	nopl   0x0(%rax)

ffffffff80006bc0 <_ZN6Memory13HeapAllocator7RequestEm>:

    void* HeapAllocator::Request(size_t size) {
ffffffff80006bc0:	f3 0f 1e fa          	endbr64
        Node* current = &head;
ffffffff80006bc4:	48 83 c7 10          	add    $0x10,%rdi
        Node* prev = nullptr;
ffffffff80006bc8:	31 c9                	xor    %ecx,%ecx
ffffffff80006bca:	eb 0f                	jmp    ffffffff80006bdb <_ZN6Memory13HeapAllocator7RequestEm+0x1b>
ffffffff80006bcc:	0f 1f 40 00          	nopl   0x0(%rax)

        while (current != nullptr) {
ffffffff80006bd0:	48 89 f9             	mov    %rdi,%rcx
ffffffff80006bd3:	48 85 c0             	test   %rax,%rax
ffffffff80006bd6:	74 30                	je     ffffffff80006c08 <_ZN6Memory13HeapAllocator7RequestEm+0x48>
ffffffff80006bd8:	48 89 c7             	mov    %rax,%rdi
            if (current->size >= size) {
ffffffff80006bdb:	48 8b 17             	mov    (%rdi),%rdx
                Node copy = *current;
ffffffff80006bde:	48 8b 47 08          	mov    0x8(%rdi),%rax
            if (current->size >= size) {
ffffffff80006be2:	48 39 f2             	cmp    %rsi,%rdx
ffffffff80006be5:	72 e9                	jb     ffffffff80006bd0 <_ZN6Memory13HeapAllocator7RequestEm+0x10>
                size_t total_size_needed = size + sizeof(Metadata);

                Metadata* meta = (Metadata*)current;

                meta->size = size;
ffffffff80006be7:	48 89 37             	mov    %rsi,(%rdi)
                
                prev->next = (Node*)((uint64_t)current + total_size_needed);
ffffffff80006bea:	48 8d 74 37 08       	lea    0x8(%rdi,%rsi,1),%rsi
ffffffff80006bef:	48 89 71 08          	mov    %rsi,0x8(%rcx)
                prev->next->next = copy.next;
ffffffff80006bf3:	48 89 46 08          	mov    %rax,0x8(%rsi)
                prev->next->size = copy.size;
ffffffff80006bf7:	48 8b 41 08          	mov    0x8(%rcx),%rax
ffffffff80006bfb:	48 89 10             	mov    %rdx,(%rax)

                return (void*)((uint64_t)meta + sizeof(Metadata));
ffffffff80006bfe:	48 8d 47 08          	lea    0x8(%rdi),%rax
ffffffff80006c02:	c3                   	ret
ffffffff80006c03:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
            prev = current;
            current = current->next;
        }

        return nullptr;
    }
ffffffff80006c08:	c3                   	ret
ffffffff80006c09:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)

ffffffff80006c10 <_ZN6Memory13HeapAllocator7ReallocEPvm>:

    void* HeapAllocator::Realloc(void* ptr, size_t size) {
ffffffff80006c10:	f3 0f 1e fa          	endbr64
ffffffff80006c14:	41 54                	push   %r12
        Node* current = &head;
ffffffff80006c16:	48 8d 47 10          	lea    0x10(%rdi),%rax
        Node* prev = nullptr;
ffffffff80006c1a:	45 31 c0             	xor    %r8d,%r8d
    void* HeapAllocator::Realloc(void* ptr, size_t size) {
ffffffff80006c1d:	55                   	push   %rbp
ffffffff80006c1e:	48 89 f5             	mov    %rsi,%rbp
ffffffff80006c21:	53                   	push   %rbx
ffffffff80006c22:	48 89 fb             	mov    %rdi,%rbx
ffffffff80006c25:	eb 14                	jmp    ffffffff80006c3b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x2b>
ffffffff80006c27:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80006c2e:	00 00 
        while (current != nullptr) {
ffffffff80006c30:	49 89 c0             	mov    %rax,%r8
ffffffff80006c33:	48 85 c9             	test   %rcx,%rcx
ffffffff80006c36:	74 63                	je     ffffffff80006c9b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x8b>
ffffffff80006c38:	48 89 c8             	mov    %rcx,%rax
            if (current->size >= size) {
ffffffff80006c3b:	48 8b 38             	mov    (%rax),%rdi
                Node copy = *current;
ffffffff80006c3e:	48 8b 48 08          	mov    0x8(%rax),%rcx
            if (current->size >= size) {
ffffffff80006c42:	48 39 d7             	cmp    %rdx,%rdi
ffffffff80006c45:	72 e9                	jb     ffffffff80006c30 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x20>
                prev->next = (Node*)((uint64_t)current + total_size_needed);
ffffffff80006c47:	48 8d 74 10 08       	lea    0x8(%rax,%rdx,1),%rsi
                meta->size = size;
ffffffff80006c4c:	48 89 10             	mov    %rdx,(%rax)
                return (void*)((uint64_t)meta + sizeof(Metadata));
ffffffff80006c4f:	4c 8d 60 08          	lea    0x8(%rax),%r12
                prev->next = (Node*)((uint64_t)current + total_size_needed);
ffffffff80006c53:	49 89 70 08          	mov    %rsi,0x8(%r8)
                prev->next->next = copy.next;
ffffffff80006c57:	48 89 4e 08          	mov    %rcx,0x8(%rsi)
                prev->next->size = copy.size;
ffffffff80006c5b:	49 8b 48 08          	mov    0x8(%r8),%rcx
ffffffff80006c5f:	48 89 39             	mov    %rdi,(%rcx)
        auto new_ptr = Request(size);

        if (new_ptr == nullptr) {
ffffffff80006c62:	48 83 f8 f8          	cmp    $0xfffffffffffffff8,%rax
ffffffff80006c66:	74 33                	je     ffffffff80006c9b <_ZN6Memory13HeapAllocator7ReallocEPvm+0x8b>
            return nullptr;
        }

        if (ptr == nullptr) {
ffffffff80006c68:	48 85 ed             	test   %rbp,%rbp
ffffffff80006c6b:	74 26                	je     ffffffff80006c93 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x83>
            return new_ptr;
        }

        memcpy(new_ptr, ptr, size);
ffffffff80006c6d:	48 89 ee             	mov    %rbp,%rsi
ffffffff80006c70:	4c 89 e7             	mov    %r12,%rdi
ffffffff80006c73:	e8 c8 fa ff ff       	call   ffffffff80006740 <memcpy>

    void HeapAllocator::Free(void* ptr) {
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
        size_t size = meta->size;

        auto prev_next = head.next;
ffffffff80006c78:	48 8b 4b 18          	mov    0x18(%rbx),%rcx
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
ffffffff80006c7c:	48 8d 45 f8          	lea    -0x8(%rbp),%rax
        size_t size = meta->size;
ffffffff80006c80:	48 8b 55 f8          	mov    -0x8(%rbp),%rdx

        head.next = (Node*)meta;
ffffffff80006c84:	48 89 43 18          	mov    %rax,0x18(%rbx)
        head.next->next = prev_next;
ffffffff80006c88:	48 89 4d 00          	mov    %rcx,0x0(%rbp)
        head.next->size = size;
ffffffff80006c8c:	48 8b 43 18          	mov    0x18(%rbx),%rax
ffffffff80006c90:	48 89 10             	mov    %rdx,(%rax)
    }
ffffffff80006c93:	4c 89 e0             	mov    %r12,%rax
ffffffff80006c96:	5b                   	pop    %rbx
ffffffff80006c97:	5d                   	pop    %rbp
ffffffff80006c98:	41 5c                	pop    %r12
ffffffff80006c9a:	c3                   	ret
            return nullptr;
ffffffff80006c9b:	45 31 e4             	xor    %r12d,%r12d
ffffffff80006c9e:	eb f3                	jmp    ffffffff80006c93 <_ZN6Memory13HeapAllocator7ReallocEPvm+0x83>

ffffffff80006ca0 <_ZN6Memory13HeapAllocator4FreeEPv>:
    void HeapAllocator::Free(void* ptr) {
ffffffff80006ca0:	f3 0f 1e fa          	endbr64
        auto prev_next = head.next;
ffffffff80006ca4:	48 8b 4f 18          	mov    0x18(%rdi),%rcx
        Metadata* meta = (Metadata*)((uint64_t)ptr - sizeof(Metadata));
ffffffff80006ca8:	48 8d 46 f8          	lea    -0x8(%rsi),%rax
        size_t size = meta->size;
ffffffff80006cac:	48 8b 56 f8          	mov    -0x8(%rsi),%rdx
        head.next = (Node*)meta;
ffffffff80006cb0:	48 89 47 18          	mov    %rax,0x18(%rdi)
        head.next->next = prev_next;
ffffffff80006cb4:	48 89 0e             	mov    %rcx,(%rsi)
        head.next->size = size;
ffffffff80006cb7:	48 8b 47 18          	mov    0x18(%rdi),%rax
ffffffff80006cbb:	48 89 10             	mov    %rdx,(%rax)
    }
ffffffff80006cbe:	c3                   	ret
ffffffff80006cbf:	90                   	nop

ffffffff80006cc0 <_ZN6Memory13HeapAllocator4WalkEv>:
    
    // Traverses the Allocator's linked list for debugging
    void HeapAllocator::Walk() {
ffffffff80006cc0:	f3 0f 1e fa          	endbr64
ffffffff80006cc4:	55                   	push   %rbp
ffffffff80006cc5:	53                   	push   %rbx
ffffffff80006cc6:	48 83 ec 08          	sub    $0x8,%rsp
        Node* current = {head.next};
ffffffff80006cca:	48 8b 5f 18          	mov    0x18(%rdi),%rbx
        size_t i{0};

        while (current != nullptr) {
ffffffff80006cce:	48 85 db             	test   %rbx,%rbx
ffffffff80006cd1:	0f 84 a8 00 00 00    	je     ffffffff80006d7f <_ZN6Memory13HeapAllocator4WalkEv+0xbf>
        size_t i{0};
ffffffff80006cd7:	31 ed                	xor    %ebp,%ebp
ffffffff80006cd9:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            Print(string);
ffffffff80006ce0:	48 c7 c7 d2 ac 00 80 	mov    $0xffffffff8000acd2,%rdi
ffffffff80006ce7:	e8 94 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006cec:	be 0a 00 00 00       	mov    $0xa,%esi
ffffffff80006cf1:	48 89 ef             	mov    %rbp,%rdi
            t.streamBaseType = newBase;
ffffffff80006cf4:	c7 05 fa 43 00 00 0a 	movl   $0xa,0x43fa(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80006cfb:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006cfe:	e8 ad fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
            kout << "Block " << base::dec << i << " {" << current->size << " bytes & address 0x" << base::hex << (uint64_t)current << "}" << Kt::newline;
            current = current->next;
            i++;
ffffffff80006d03:	48 83 c5 01          	add    $0x1,%rbp
ffffffff80006d07:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d0a:	e8 71 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d0f:	48 c7 c7 d9 ac 00 80 	mov    $0xffffffff8000acd9,%rdi
ffffffff80006d16:	e8 65 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d1b:	8b 35 d7 43 00 00    	mov    0x43d7(%rip),%esi        # ffffffff8000b0f8 <kout>
ffffffff80006d21:	48 8b 3b             	mov    (%rbx),%rdi
ffffffff80006d24:	e8 87 fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006d29:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d2c:	e8 4f 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d31:	48 c7 c7 dc ac 00 80 	mov    $0xffffffff8000acdc,%rdi
ffffffff80006d38:	e8 43 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d3d:	be 10 00 00 00       	mov    $0x10,%esi
ffffffff80006d42:	48 89 df             	mov    %rbx,%rdi
            t.streamBaseType = newBase;
ffffffff80006d45:	c7 05 a9 43 00 00 10 	movl   $0x10,0x43a9(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80006d4c:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006d4f:	e8 5c fc ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006d54:	48 89 c7             	mov    %rax,%rdi
ffffffff80006d57:	e8 24 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006d5c:	48 c7 c7 f0 ac 00 80 	mov    $0xffffffff8000acf0,%rdi
ffffffff80006d63:	e8 18 02 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006d68:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006d6d:	e8 de 01 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
            current = current->next;
ffffffff80006d72:	48 8b 5b 08          	mov    0x8(%rbx),%rbx
        while (current != nullptr) {
ffffffff80006d76:	48 85 db             	test   %rbx,%rbx
ffffffff80006d79:	0f 85 61 ff ff ff    	jne    ffffffff80006ce0 <_ZN6Memory13HeapAllocator4WalkEv+0x20>
        }
    }
ffffffff80006d7f:	48 83 c4 08          	add    $0x8,%rsp
ffffffff80006d83:	5b                   	pop    %rbx
ffffffff80006d84:	5d                   	pop    %rbp
ffffffff80006d85:	c3                   	ret
ffffffff80006d86:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006d8d:	00 00 00 

ffffffff80006d90 <_ZN6Memory4ScanEP22limine_memmap_response>:
#include "Heap.hpp"

using namespace Kt;

namespace Memory {
    LargestSection Scan(limine_memmap_response* mmap) {
ffffffff80006d90:	f3 0f 1e fa          	endbr64
ffffffff80006d94:	41 56                	push   %r14
ffffffff80006d96:	41 55                	push   %r13
ffffffff80006d98:	41 54                	push   %r12
ffffffff80006d9a:	55                   	push   %rbp
ffffffff80006d9b:	53                   	push   %rbx
        LargestSection currentLargestSection{};

        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006d9c:	4c 8b 6f 08          	mov    0x8(%rdi),%r13
ffffffff80006da0:	4d 85 ed             	test   %r13,%r13
ffffffff80006da3:	0f 84 ef 00 00 00    	je     ffffffff80006e98 <_ZN6Memory4ScanEP22limine_memmap_response+0x108>
ffffffff80006da9:	49 89 fc             	mov    %rdi,%r12
        LargestSection currentLargestSection{};
ffffffff80006dac:	45 31 ed             	xor    %r13d,%r13d
ffffffff80006daf:	45 31 f6             	xor    %r14d,%r14d
        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006db2:	31 db                	xor    %ebx,%ebx
ffffffff80006db4:	eb 19                	jmp    ffffffff80006dcf <_ZN6Memory4ScanEP22limine_memmap_response+0x3f>
ffffffff80006db6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006dbd:	00 00 00 
ffffffff80006dc0:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80006dc4:	49 3b 5c 24 08       	cmp    0x8(%r12),%rbx
ffffffff80006dc9:	0f 83 b1 00 00 00    	jae    ffffffff80006e80 <_ZN6Memory4ScanEP22limine_memmap_response+0xf0>
            auto entry = mmap->entries[i];
ffffffff80006dcf:	49 8b 44 24 10       	mov    0x10(%r12),%rax
ffffffff80006dd4:	48 8b 2c d8          	mov    (%rax,%rbx,8),%rbp

            if (entry->base == 0) {
ffffffff80006dd8:	48 83 7d 00 00       	cmpq   $0x0,0x0(%rbp)
ffffffff80006ddd:	74 e1                	je     ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
                continue;
            }
            
            if (entry->type == LIMINE_MEMMAP_USABLE) {
ffffffff80006ddf:	48 83 7d 10 00       	cmpq   $0x0,0x10(%rbp)
ffffffff80006de4:	75 da                	jne    ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
            Print(string);
ffffffff80006de6:	48 c7 c7 a8 ae 00 80 	mov    $0xffffffff8000aea8,%rdi
ffffffff80006ded:	e8 8e 01 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006df2:	48 8b 7d 08          	mov    0x8(%rbp),%rdi
ffffffff80006df6:	be 0a 00 00 00       	mov    $0xa,%esi
            t.streamBaseType = newBase;
ffffffff80006dfb:	c7 05 f3 42 00 00 0a 	movl   $0xa,0x42f3(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80006e02:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e05:	e8 a6 fb ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006e0a:	48 89 c7             	mov    %rax,%rdi
ffffffff80006e0d:	e8 6e 01 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006e12:	48 c7 c7 f2 ac 00 80 	mov    $0xffffffff8000acf2,%rdi
ffffffff80006e19:	e8 62 01 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e1e:	48 8b 7d 00          	mov    0x0(%rbp),%rdi
ffffffff80006e22:	be 10 00 00 00       	mov    $0x10,%esi
            t.streamBaseType = newBase;
ffffffff80006e27:	c7 05 c7 42 00 00 10 	movl   $0x10,0x42c7(%rip)        # ffffffff8000b0f8 <kout>
ffffffff80006e2e:	00 00 00 
            Print(Lib::u64_2_basestr(number, t.streamBaseType));
ffffffff80006e31:	e8 7a fb ff ff       	call   ffffffff800069b0 <_ZN3Lib13u64_2_basestrEmm>
ffffffff80006e36:	48 89 c7             	mov    %rax,%rdi
ffffffff80006e39:	e8 42 01 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Print(string);
ffffffff80006e3e:	48 c7 c7 07 ad 00 80 	mov    $0xffffffff8000ad07,%rdi
ffffffff80006e45:	e8 36 01 00 00       	call   ffffffff80006f80 <_ZN2Kt5PrintEPKc>
            Putchar(chr);
ffffffff80006e4a:	bf 0a 00 00 00       	mov    $0xa,%edi
ffffffff80006e4f:	e8 fc 00 00 00       	call   ffffffff80006f50 <_ZN2Kt7PutcharEc>
                kout << "MemoryManagement: Found conventional memory section (size = " << base::dec << entry->length << " bytes, address = 0x" << base::hex << (uint64_t)entry->base << ")" << newline;                
                
                if (entry->length > currentLargestSection.size) {
ffffffff80006e54:	48 8b 45 08          	mov    0x8(%rbp),%rax
ffffffff80006e58:	49 39 c5             	cmp    %rax,%r13
ffffffff80006e5b:	0f 83 5f ff ff ff    	jae    ffffffff80006dc0 <_ZN6Memory4ScanEP22limine_memmap_response+0x30>
                    currentLargestSection = {
                        .address = (uint64_t)entry->base,
ffffffff80006e61:	4c 8b 75 00          	mov    0x0(%rbp),%r14
                    currentLargestSection = {
ffffffff80006e65:	49 89 c5             	mov    %rax,%r13
        for (size_t i = 0; i < mmap->entry_count; i++) {
ffffffff80006e68:	48 83 c3 01          	add    $0x1,%rbx
ffffffff80006e6c:	49 3b 5c 24 08       	cmp    0x8(%r12),%rbx
ffffffff80006e71:	0f 82 58 ff ff ff    	jb     ffffffff80006dcf <_ZN6Memory4ScanEP22limine_memmap_response+0x3f>
ffffffff80006e77:	66 0f 1f 84 00 00 00 	nopw   0x0(%rax,%rax,1)
ffffffff80006e7e:	00 00 
                    };
                }
            }
        }

        [[unlikely]] if (currentLargestSection.address == 0) {
ffffffff80006e80:	4d 85 f6             	test   %r14,%r14
ffffffff80006e83:	74 13                	je     ffffffff80006e98 <_ZN6Memory4ScanEP22limine_memmap_response+0x108>
            Panic("Couldn't find a usable memory section.", nullptr);
        }

        return currentLargestSection;
    }
ffffffff80006e85:	5b                   	pop    %rbx
ffffffff80006e86:	4c 89 f0             	mov    %r14,%rax
ffffffff80006e89:	5d                   	pop    %rbp
ffffffff80006e8a:	4c 89 ea             	mov    %r13,%rdx
ffffffff80006e8d:	41 5c                	pop    %r12
ffffffff80006e8f:	41 5d                	pop    %r13
ffffffff80006e91:	41 5e                	pop    %r14
ffffffff80006e93:	c3                   	ret
ffffffff80006e94:	0f 1f 40 00          	nopl   0x0(%rax)
            Panic("Couldn't find a usable memory section.", nullptr);
ffffffff80006e98:	45 31 f6             	xor    %r14d,%r14d
ffffffff80006e9b:	31 f6                	xor    %esi,%esi
ffffffff80006e9d:	48 c7 c7 e8 ae 00 80 	mov    $0xffffffff8000aee8,%rdi
ffffffff80006ea4:	e8 07 e0 ff ff       	call   ffffffff80004eb0 <_Z5PanicPKcPN6System10PanicFrameE>
    }
ffffffff80006ea9:	5b                   	pop    %rbx
ffffffff80006eaa:	4c 89 f0             	mov    %r14,%rax
ffffffff80006ead:	5d                   	pop    %rbp
ffffffff80006eae:	4c 89 ea             	mov    %r13,%rdx
ffffffff80006eb1:	41 5c                	pop    %r12
ffffffff80006eb3:	41 5d                	pop    %r13
ffffffff80006eb5:	41 5e                	pop    %r14
ffffffff80006eb7:	c3                   	ret
ffffffff80006eb8:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80006ebf:	00 

ffffffff80006ec0 <_Z3hcfv>:
    * Copyright (c) Daniel Hammer, Limine Contributors (via Limine C++ example)
*/

// Halt and catch fire function.
void hcf()
{
ffffffff80006ec0:	f3 0f 1e fa          	endbr64
ffffffff80006ec4:	0f 1f 40 00          	nopl   0x0(%rax)
    for (;;)
    {
#if defined(__x86_64__)
        asm("hlt");
ffffffff80006ec8:	f4                   	hlt
    for (;;)
ffffffff80006ec9:	eb fd                	jmp    ffffffff80006ec8 <_Z3hcfv+0x8>
ffffffff80006ecb:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80006ed0 <_ZN2Kt10InitializeEPjmmmhhhhhh>:
    void Initialize(std::uint32_t *framebuffer, std::size_t width, std::size_t height, std::size_t pitch,
        std::uint8_t red_mask_size, std::uint8_t red_mask_shift,
        std::uint8_t green_mask_size, std::uint8_t green_mask_shift,
        std::uint8_t blue_mask_size, std::uint8_t blue_mask_shift
        )
    {
ffffffff80006ed0:	f3 0f 1e fa          	endbr64
ffffffff80006ed4:	48 83 ec 08          	sub    $0x8,%rsp
ffffffff80006ed8:	48 89 f8             	mov    %rdi,%rax
        ctx = flanterm_fb_init(
ffffffff80006edb:	45 0f b6 c9          	movzbl %r9b,%r9d
ffffffff80006edf:	45 0f b6 c0          	movzbl %r8b,%r8d
ffffffff80006ee3:	6a 00                	push   $0x0
ffffffff80006ee5:	6a 00                	push   $0x0
ffffffff80006ee7:	6a 00                	push   $0x0
ffffffff80006ee9:	6a 01                	push   $0x1
ffffffff80006eeb:	6a 00                	push   $0x0
ffffffff80006eed:	6a 00                	push   $0x0
ffffffff80006eef:	6a 00                	push   $0x0
ffffffff80006ef1:	6a 00                	push   $0x0
ffffffff80006ef3:	6a 00                	push   $0x0
ffffffff80006ef5:	6a 00                	push   $0x0
ffffffff80006ef7:	6a 00                	push   $0x0
ffffffff80006ef9:	6a 00                	push   $0x0
ffffffff80006efb:	6a 00                	push   $0x0
ffffffff80006efd:	6a 00                	push   $0x0
ffffffff80006eff:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f06:	00 
ffffffff80006f07:	57                   	push   %rdi
ffffffff80006f08:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f0f:	00 
ffffffff80006f10:	57                   	push   %rdi
ffffffff80006f11:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f18:	00 
ffffffff80006f19:	57                   	push   %rdi
ffffffff80006f1a:	0f b6 bc 24 98 00 00 	movzbl 0x98(%rsp),%edi
ffffffff80006f21:	00 
ffffffff80006f22:	57                   	push   %rdi
ffffffff80006f23:	31 ff                	xor    %edi,%edi
ffffffff80006f25:	41 51                	push   %r9
ffffffff80006f27:	49 89 c9             	mov    %rcx,%r9
ffffffff80006f2a:	48 89 f1             	mov    %rsi,%rcx
ffffffff80006f2d:	31 f6                	xor    %esi,%esi
ffffffff80006f2f:	41 50                	push   %r8
ffffffff80006f31:	49 89 d0             	mov    %rdx,%r8
ffffffff80006f34:	48 89 c2             	mov    %rax,%rdx
ffffffff80006f37:	e8 24 b2 ff ff       	call   ffffffff80002160 <flanterm_fb_init>
ffffffff80006f3c:	48 89 05 95 98 0d 00 	mov    %rax,0xd9895(%rip)        # ffffffff800e07d8 <_ZN2Kt3ctxE>
            NULL, NULL,
            NULL, 0, 0, 1,
            0, 0,
            0
        );
    }
ffffffff80006f43:	48 81 c4 a8 00 00 00 	add    $0xa8,%rsp
ffffffff80006f4a:	c3                   	ret
ffffffff80006f4b:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)

ffffffff80006f50 <_ZN2Kt7PutcharEc>:

    void Putchar(char c) {
ffffffff80006f50:	f3 0f 1e fa          	endbr64
ffffffff80006f54:	48 83 ec 18          	sub    $0x18,%rsp
        flanterm_write(ctx, &c, 1);
ffffffff80006f58:	ba 01 00 00 00       	mov    $0x1,%edx
    void Putchar(char c) {
ffffffff80006f5d:	40 88 7c 24 0c       	mov    %dil,0xc(%rsp)
        flanterm_write(ctx, &c, 1);
ffffffff80006f62:	48 8b 3d 6f 98 0d 00 	mov    0xd986f(%rip),%rdi        # ffffffff800e07d8 <_ZN2Kt3ctxE>
ffffffff80006f69:	48 8d 74 24 0c       	lea    0xc(%rsp),%rsi
ffffffff80006f6e:	e8 4d c0 ff ff       	call   ffffffff80002fc0 <flanterm_write>
    }
ffffffff80006f73:	48 83 c4 18          	add    $0x18,%rsp
ffffffff80006f77:	c3                   	ret
ffffffff80006f78:	0f 1f 84 00 00 00 00 	nopl   0x0(%rax,%rax,1)
ffffffff80006f7f:	00 

ffffffff80006f80 <_ZN2Kt5PrintEPKc>:

    void Print(const char *text) {
ffffffff80006f80:	f3 0f 1e fa          	endbr64

namespace Lib {
    inline int strlen(const char *string) {
        int c = 0;

        while (*string != '\0') {
ffffffff80006f84:	80 3f 00             	cmpb   $0x0,(%rdi)
ffffffff80006f87:	48 89 fe             	mov    %rdi,%rsi
ffffffff80006f8a:	74 2c                	je     ffffffff80006fb8 <_ZN2Kt5PrintEPKc+0x38>
ffffffff80006f8c:	48 89 f8             	mov    %rdi,%rax
        int c = 0;
ffffffff80006f8f:	31 d2                	xor    %edx,%edx
ffffffff80006f91:	0f 1f 80 00 00 00 00 	nopl   0x0(%rax)
            string++;
ffffffff80006f98:	48 83 c0 01          	add    $0x1,%rax
            c++;            
ffffffff80006f9c:	83 c2 01             	add    $0x1,%edx
        while (*string != '\0') {
ffffffff80006f9f:	80 38 00             	cmpb   $0x0,(%rax)
ffffffff80006fa2:	75 f4                	jne    ffffffff80006f98 <_ZN2Kt5PrintEPKc+0x18>
        flanterm_write(ctx, text, Lib::strlen(text));
ffffffff80006fa4:	48 8b 3d 2d 98 0d 00 	mov    0xd982d(%rip),%rdi        # ffffffff800e07d8 <_ZN2Kt3ctxE>
ffffffff80006fab:	48 63 d2             	movslq %edx,%rdx
ffffffff80006fae:	e9 0d c0 ff ff       	jmp    ffffffff80002fc0 <flanterm_write>
ffffffff80006fb3:	0f 1f 44 00 00       	nopl   0x0(%rax,%rax,1)
ffffffff80006fb8:	48 8b 3d 19 98 0d 00 	mov    0xd9819(%rip),%rdi        # ffffffff800e07d8 <_ZN2Kt3ctxE>
ffffffff80006fbf:	31 d2                	xor    %edx,%edx
ffffffff80006fc1:	e9 fa bf ff ff       	jmp    ffffffff80002fc0 <flanterm_write>
ffffffff80006fc6:	66 2e 0f 1f 84 00 00 	cs nopw 0x0(%rax,%rax,1)
ffffffff80006fcd:	00 00 00 

ffffffff80006fd0 <LoadGDT>:
ffffffff80006fd0:	0f 01 17             	lgdt   (%rdi)
ffffffff80006fd3:	c3                   	ret

ffffffff80006fd4 <ReloadSegments>:
ffffffff80006fd4:	6a 08                	push   $0x8
ffffffff80006fd6:	48 8d 05 03 00 00 00 	lea    0x3(%rip),%rax        # ffffffff80006fe0 <ReloadSegments.reload_CS>
ffffffff80006fdd:	50                   	push   %rax
ffffffff80006fde:	48 cb                	lretq

ffffffff80006fe0 <ReloadSegments.reload_CS>:
ffffffff80006fe0:	66 b8 10 00          	mov    $0x10,%ax
ffffffff80006fe4:	8e d8                	mov    %eax,%ds
ffffffff80006fe6:	8e c0                	mov    %eax,%es
ffffffff80006fe8:	8e e0                	mov    %eax,%fs
ffffffff80006fea:	8e e8                	mov    %eax,%gs
ffffffff80006fec:	8e d0                	mov    %eax,%ss
ffffffff80006fee:	c3                   	ret
