// File: /workspace/github_c_makefile_star2_O2/kyz[P]amostools/./amoslib.c
// Function: AMOS_print_source
int AMOS_print_source(uint8_t *src, size_t len, FILE *out,
                      struct AMOS_token *table[AMOS_TOKEN_TABLE_SIZE])
{
    uint32_t token, linelen=0, inpos, i, compiled_len = 0;
    uint8_t *line, *endline, add_space, start_of_line, label_at_eol = 0;
    int err = 0;

    /* while we have remaining input bytes */
    for (inpos = 0; inpos < len;) {
        /* skip compiled procedures */
        if (compiled_len) {
            fprintf(out, "   ' COMPILED PROCEDURE -- can't convert this to AMOS code\n");
            inpos += compiled_len + 8 - linelen;
            if (inpos > len) break;
            compiled_len = 0;
        }

        line = &src[inpos];
        linelen = line[0] * 2;
        inpos += linelen;

        /* stop if line claims to be zero length (bad data) */
        if (linelen == 0) {
            err |= 1;
            break;
        }

        /* if the line is said to be longer than we actually have bytes for,
         * mark this as an error, but continue with the bytes we have. */
        if (inpos > len) {
            err |= 1;
            linelen = len - (inpos - linelen);
        }

        //printf("LINE: ");for(i=0;i<linelen;i+=2)printf("%02X%02X ",line[i],line[i+1]);puts("");

        /* start the line with the given indent level */
        if ((i = line[1]) > 1) {
            while (i-- > 1) putc(' ', out);
        }
        add_space = 0;

        /* decode this line */
        endline = &line[linelen];
        line += 2;
        start_of_line = 1;

        while ((line < endline) && (token = amos_deek(line))) {
            line += 2;
            label_at_eol = 0;

            if (token <= 0x0018) {
                /* Tokens 0x0000 to 0x0018 are "variable" tokens. These represent
                 * variable, label and procedure names:
                 * - 0x0006 = TkVar, variable reference e.g. "X" in "Print X".
                 * - 0x000C = TkLab, label, e.g. "X:" or "190" (at the start of a line)
                 * - 0x0012 = TkPro, procedure reference, e.g. "X" in "X[42]"
                 * - 0x0018 = TkLGo, label reference, e.g. "X" in "Goto X"
                 *
                 * All these tokens have the following format:
                 * - 2 bytes: unknown purpose
                 * - 1 byte:  length of ASCII string for variable/label name
                 * - 1 byte:  flags. For TkVar, TkPro and TkLGo:
                 *            - flags & 0x01 = this is a floating point ref (eg "X#")
                 *            - flags & 0x02 = this is a string ref (eg "X$")
                 * - n bytes: ASCII string, with the above-given string length,
                 *            rounded to a multiple of two, null terminated.
                 */
                if (add_space) putc(' ', out);
                for (i = 0; i < line[2]; i++) {
                    uint8_t c = line[4+i];
                    if (!c) break;
                    if (c >= 'a' && c <= 'z') c -= ('a'-'A'); /* to uppercase */
                    putc(c, out);
                }
                if (token == 0x000C) {
                    /* if not a "line number" label, the label needs a colon */
                    if (!(line[4] >= '0' && line[4] <= '9')) putc(':', out);
                    add_space = 1;
                    label_at_eol = 1;
                }
                else {
                    if (line[3] & 0x01) putc('#', out);
                    else if (line[3] & 0x02) putc('$', out);
                    add_space = 0;
                }
                /* advance to the next token */
                line += ((line[2] & 1) ? 5 : 4) + line[2];
            }
            else if (token < 0x004E || token == 0x2B6A) {
                /* Tokens 0x0019 to 0x004D (and 0x2B6A) are "constant" tokens.
                 * They represent literal numbers and strings:
                 *
                 * - 0x001E = TkBin, a binary integer, e.g. %100101
                 * - 0x0026 = TkCh1, a string with double quotes, e.g. "hello"
                 * - 0x002E = TkCh2, a string with single quotes, e.g. 'hello'
                 * - 0x0036 = TkHex, a hexidecimal integer, e.g. $80FAA010
                 * - 0x003E = TkEnt, a decimal integer, e.g. 1234567890
                 * - 0x0046 = TkFl,  a floating-point number, e.g 3.142
                 * - 0x2B6A = TkDFl, a double-precision float, e.g. 3.1415926543
                 *
                 * TkBin, TkHex, TkEnt, TkFl have this format:
                 * - 4 bytes: the value
                 *
                 * TkDFl has this format:
                 * - 8 bytes: the value
                 *
                 * TkCh1 and TkCh2 have this format:
                 * - 2 bytes: the length of the string
                 * - n bytes: the string, for the above number of bytes rounded up
                 *            to a multiple of two bytes and padded with nulls.
                 */
                if (add_space) { putc(' ', out); add_space = 0; }
                switch (token) {
                case 0x001E: /* TkBin */
                    print_binary(out, amos_leek(line)); line += 4;
                    break;
                case 0x0026: /* TkCh1 */
                    line += print_string(out, line, '\"');
                    break;
                case 0x002E: /* TkCh2 */
                    line += print_string(out, line, '\'');
                    break;
                case 0x0036: /* TkHex */
                    fprintf(out, "$%X", amos_leek(line)); line += 4;
                    break;
                case 0x003E: /* TkEnt */
                    fprintf(out, "%d", (int) amos_leek(line)); line += 4;
                    break;
                case 0x0046: /* TkFl */
                    print_float(out, amos_leek(line)); line += 4;
                    break;
                case 0x2B6A:
                    print_double(out, amos_leek(line), amos_leek(line+4)); line += 8;
                    break;
                default:
                    fprintf(out, "Illegal_Constant_%04X", token);
                    err |= 2;
                }
            }
            else {
                char *tok = NULL;
                int key;
                /* all other tokens: 0x004E to 0xFFFF
                 *
                 * other than the extension tokens, these are actual instructions,
                 * functions or system variables which reside in AMOS's token table.
                 * The offset given leads to the handlers for these instructions,
                 * as well as their name and what would be correct parameters.
                 *
                 * AMOS allows "extensions" to the language. They have a token table
                 * just like AMOS, each extension has its own table.
                 *
                 * The extension token is token 0x004E and has this format:
                 * - 1 byte:  extension number [1-25]
                 * - 1 byte:  unused
                 * - 2 bytes: offset into extension's token table
                 *
                 * Other than this, some tokens in the core language have a special
                 * format. They are:
                 *
                 * TkRem1 (0x064A) and TkRem2 (0x0652):
                 * - 1 byte:  unused
                 * - 1 byte:  length of the remark
                 * - n bytes: the remark -- ASCII text, null terminated,
                 *            padded to a multiple of two bytes.
                 *
                 * TkFor (0x023C), TkRpt (0x0250), TkWhl (0x0268), TkDo (0x027E),
                 * TkIf (0x02BE), TkElse (0x02D0), TkData (0x0404) and AMOS Pro's
                 * TkElsI (0x25A4)
                 * - 2 bytes: unknown purpose
                 *
                 * TkExIf (0x0290), TkExit (0x029E) and TkOn (0x0316):
                 * - 4 bytes: unknown purpose
                 *
                 * TkProc (0x0376)
                 * - 4 bytes: number of bytes to corresponding ENDPROC line
                 *            (start of line + 8 + above = start of ENDPROC line)
                 *            (start of line + 8 + 6 + above = line _after_ ENDPROC)
                 * - 2 bytes: part of seed for encryption
                 * - 1 byte: flags:
                 *   - flags & 0x80 -- procedure is folded
                 *   - flags & 0x40 -- procedure is locked and should not be unfolded
                 *   - flags & 0x20 -- procedure is currently encrypted
                 *   - flags & 0x10 -- procedure contains compiled code, not tokens
                 * - 1 byte: part of seed for encryption
                 *
                 * TkEqu (0x2A40), TkLVO (0x2A4A), TkStru (0x2A54), TkStruS (0x2A64)
                 * - 4 bytes: value of the equate
                 * - 1 byte: type of the equate (0-7)
                 * - 1 byte: unknown purpose
                 */
                if (token == 0x004E) {
                    key = line[0] << 16 | amos_deek(&line[2]);
                    line += 4;
                }
                else {
                    key = token; /* slot 0 */
                }

                /* lookup token */
                int tidx = (key >> 1) % AMOS_TOKEN_TABLE_SIZE;
                for (struct AMOS_token *e = table[tidx]; e; e = e->next) {
                    if (e->key == key) {
                        tok = e->text;
                        break;
                    }
                }

                if (tok) {
                    char type = *tok++;
                    char is_paren = (token == 0x0074);
                    char is_func = (type == 'O' || type == '0' || type == '1' ||
                                    type == '2' || type == 'V');
                    if (!is_func && !start_of_line) add_space = 1;
                    if (!is_paren && add_space && *tok != ' ') putc(' ', out);
                    fprintf(out, "%s", tok);
                    add_space = (type == 'I');
                }
                else {
                    /* unknown token */
                    fprintf(out, " Extension_%d_%04X", key >> 16, key & 0xFFFF);
                    add_space = 1;
                    err |= 4;
                }


                /* special tokens in the core language with extra data after them */
                switch (token) {
                case 0x064A: /* TkRem1 */
                case 0x0652: /* TkRem2 */
                    fprintf(out, "%s", &line[2]);
                    i = line[1]; line += 2 + i; if (i & 1) line++;
                    break;

                case 0x023C: /* TkFor */
                case 0x0250: /* TkRpt */
                case 0x0268: /* TkWhl */
                case 0x027E: /* TkDo */
                case 0x02BE: /* TkIf */
                case 0x02D0: /* TkElse */
                case 0x0404: /* TkData */
                case 0x25A4: /* TkElsI */
                    line += 2;
                    break;

                case 0x0290: /* TkExIf */
                case 0x029E: /* TkExit */
                case 0x0316: /* TkOn */
                    line += 4;
                    break;

                case 0x0376: /* TkProc */
                    if (line[6] & 0x20) AMOS_decrypt_procedure(line-4, len - (inpos-linelen));
                    if (line[6] & 0x10) compiled_len = amos_leek(&line[0]);
                    line += 8;
                    break;

                case 0x2A40: /* Equ */
                case 0x2A4A: /* Lvo */
                case 0x2A54: /* Struc */
                case 0x2A64: /* Struct */
                    line += 6;
                    break;
                }
            }
            start_of_line = 0;
        }
        if (add_space && !label_at_eol) putc(' ', out);
        putc('\n', out);
    }
    return err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0x0, (%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
movl $0x0, 0x4(%rsp)
movq %rdi, 0x30(%rsp)
movl %r12d, %r15d
cmpq 0x18(%rsp), %r15
jae 0x1b36
testl %r13d, %r13d
je 0x1485
leaq 0x1bbe(%rip), %rdi      # 0x301a
pushq $0x3b
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x11d0
addl %r12d, %r13d
subl 0x4(%rsp), %r13d
addl $0x8, %r13d
movq %r13, %r15
cmpq 0x18(%rsp), %r13
jbe 0x1488
jmp 0x1b36
movl %r12d, %r13d
movzbl (%rbx,%r15), %eax
testl %eax, %eax
je 0x1b3b
addq %rbx, %r15
movl %eax, %ecx
addl %eax, %ecx
leal (%r13,%rax,2), %eax
movl %eax, 0x14(%rsp)
movl %eax, %eax
movq 0x18(%rsp), %rdx
movl %edx, %esi
subl %r13d, %esi
xorl %ebx, %ebx
cmpq %rdx, %rax
cmovbel %ecx, %esi
movl %esi, 0x4(%rsp)
seta %r12b
movzbl 0x1(%r15), %r13d
cmpl $0x2, %r13d
jb 0x14e2
cmpl $0x2, %r13d
jb 0x14e2
decl %r13d
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x1140
jmp 0x14cc
movb %r12b, %bl
orl %ebx, (%rsp)
movl 0x4(%rsp), %ecx
movl %ecx, %eax
addq %r15, %rax
movq %rax, 0x48(%rsp)
addq $0x2, %r15
movl 0x14(%rsp), %eax
subl %ecx, %eax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
movq %rcx, 0x38(%rsp)
xorl %r13d, %r13d
xorl %edi, %edi
movq $0x0, 0x20(%rsp)
cmpq 0x48(%rsp), %r15
jae 0x1afc
movzwl (%r15), %eax
rolw $0x8, %ax
testw %ax, %ax
je 0x1afc
movzwl %ax, %ebx
leaq 0x2(%r15), %r12
cmpl $0x18, %ebx
ja 0x1593
testb %r13b, %r13b
je 0x1553
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x1140
xorl %r13d, %r13d
movzbl 0x4(%r15), %eax
cmpq %rax, %r13
jae 0x1641
movb 0x6(%r15,%r13), %al
testb %al, %al
je 0x1641
leal -0x61(%rax), %ecx
leal -0x20(%rax), %edx
cmpb $0x1a, %cl
movzbl %al, %eax
movzbl %dl, %ecx
cmovael %eax, %ecx
movzbl %cl, %edi
movq %r14, %rsi
callq 0x1140
incq %r13
jmp 0x1556
cmpl $0x4e, %ebx
setae %al
cmpl $0x2b6a, %ebx           # imm = 0x2B6A
setne %cl
testb %cl, %al
jne 0x1663
testb %r13b, %r13b
je 0x15ba
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x1140
cmpl $0x2b6a, %ebx           # imm = 0x2B6A
je 0x191a
cmpl $0x26, %ebx
je 0x19ef
cmpl $0x2e, %ebx
je 0x19e5
cmpl $0x36, %ebx
je 0x188d
cmpl $0x3e, %ebx
je 0x18f2
cmpl $0x46, %ebx
je 0x18a2
cmpl $0x1e, %ebx
jne 0x19be
movl 0x2(%r15), %eax
bswapl %eax
movb $0x0, 0x70(%rsp)
leaq 0x70(%rsp), %rdx
movl %eax, %ecx
movl %eax, %esi
andb $0x1, %sil
orb $0x30, %sil
movb %sil, -0x1(%rdx)
decq %rdx
shrl %ecx
cmpl $0x1, %eax
movl %ecx, %eax
ja 0x160e
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x1c3d(%rip), %rsi      # 0x3272
xorl %eax, %eax
callq 0x1150
jmp 0x190c
cmpl $0xc, %ebx
jne 0x170e
movb 0x6(%r15), %al
addb $-0x30, %al
movb $0x1, %r13b
pushq $0x3a
popq %rdi
cmpb $0xa, %al
jae 0x1823
jmp 0x182b
movl %ebx, %ecx
cmpl $0x4e, %ebx
jne 0x168a
movzbl 0x2(%r15), %eax
shll $0x10, %eax
movzbl 0x4(%r15), %edx
shll $0x8, %edx
movzbl 0x5(%r15), %ecx
orl %eax, %ecx
orl %edx, %ecx
addq $0x6, %r15
movq %r15, %r12
movl %ecx, %eax
shrl %eax
xorl %edx, %edx
movl $0x2069, %esi           # imm = 0x2069
divl %esi
movq 0x40(%rsp), %rax
leaq (%rax,%rdx,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x172e
cmpl %ecx, 0x8(%r15)
jne 0x16a0
movb 0xc(%r15), %bpl
addq $0xd, %r15
leal -0x30(%rbp), %ecx
cmpb $0x27, %cl
setae %al
movabsq $0x3f7ffffff8, %rdx     # imm = 0x3F7FFFFFF8
shrq %cl, %rdx
testb %r13b, %r13b
setne %cl
cmpl $0x74, %ebx
je 0x16f9
orb %dl, %al
andb %al, %dil
orb %dil, %cl
testb $0x1, %cl
je 0x16f9
cmpb $0x20, (%r15)
je 0x16f9
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x1140
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
cmpb $0x49, %bpl
sete %r13b
jmp 0x174e
movzbl 0x5(%r15), %eax
xorl %r13d, %r13d
testb $0x1, %al
jne 0x1820
pushq $0x24
popq %rdi
testb $0x2, %al
jne 0x1823
jmp 0x182b
movl %ecx, %edx
shrl $0x10, %edx
movzwl %cx, %ecx
movq %r14, %rdi
leaq 0x1933(%rip), %rsi      # 0x3073
xorl %eax, %eax
callq 0x1150
orl $0x4, (%rsp)
movb $0x1, %r13b
movb $0x1, %dil
leal -0x2a40(%rbx), %eax
cmpl $0x24, %eax
jbe 0x184a
leal -0x23c(%rbx), %eax
cmpl $0x2c, %eax
jbe 0x1867
cmpl $0x27e, %ebx            # imm = 0x27E
je 0x187b
cmpl $0x290, %ebx            # imm = 0x290
je 0x1884
cmpl $0x29e, %ebx            # imm = 0x29E
je 0x1884
cmpl $0x2be, %ebx            # imm = 0x2BE
je 0x187b
cmpl $0x2d0, %ebx            # imm = 0x2D0
je 0x187b
cmpl $0x316, %ebx            # imm = 0x316
je 0x1884
cmpl $0x376, %ebx            # imm = 0x376
je 0x1a08
cmpl $0x404, %ebx            # imm = 0x404
je 0x187b
cmpl $0x64a, %ebx            # imm = 0x64A
je 0x17f4
cmpl $0x25a4, %ebx           # imm = 0x25A4
je 0x187b
xorl %ebp, %ebp
movq %r12, %r15
cmpl $0x652, %ebx            # imm = 0x652
jne 0x151b
leaq 0x2(%r12), %rdi
movq %r14, %rsi
callq 0x1120
movb $0x1, %dil
movzbl 0x1(%r12), %r15d
leaq (%r12,%r15), %rax
addq $0x2, %rax
andl $0x1, %r15d
addq %rax, %r15
xorl %ebp, %ebp
jmp 0x151b
pushq $0x23
popq %rdi
movq %r14, %rsi
callq 0x1140
movzbl 0x4(%r15), %eax
movl %eax, %ecx
andl $0x1, %ecx
addl %eax, %ecx
leaq (%rcx,%r12), %r15
addq $0x4, %r15
movb $0x1, %dil
movl %r13d, %ebp
jmp 0x151b
movabsq $0x1000100401, %rcx     # imm = 0x1000100401
btq %rax, %rcx
jae 0x1760
addq $0x6, %r12
jmp 0x1a3b
movabsq $0x100000100001, %rcx   # imm = 0x100000100001
btq %rax, %rcx
jae 0x176f
addq $0x2, %r12
jmp 0x1a3b
addq $0x4, %r12
jmp 0x1a3b
movl 0x2(%r15), %edx
bswapl %edx
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x17b6(%rip), %rsi      # 0x3056
jmp 0x1905
movzbl 0x5(%r15), %edi
andl $0x7f, %edi
je 0x1a45
movzbl 0x2(%r15), %eax
shll $0x10, %eax
movzbl 0x3(%r15), %ecx
shll $0x8, %ecx
orl %eax, %ecx
movzbl 0x4(%r15), %eax
orl %ecx, %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, 0x8(%rsp)
addl $-0x58, %edi
movss 0x1732(%rip), %xmm0     # 0x3010
callq 0x11c0
mulss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
jmp 0x1a48
movl 0x2(%r15), %edx
bswapl %edx
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x1755(%rip), %rsi      # 0x305a
xorl %eax, %eax
callq 0x1150
addq $0x6, %r15
movb $0x1, %dil
xorl %ebp, %ebp
jmp 0x151b
movzbl 0x2(%r15), %ebx
shll $0x18, %ebx
movzbl 0x3(%r15), %r12d
shll $0x10, %r12d
orl %r12d, %ebx
shrl $0x14, %ebx
andl $0x7ff, %ebx            # imm = 0x7FF
je 0x1a82
movzbl 0x4(%r15), %r13d
shll $0x8, %r13d
movzbl 0x5(%r15), %ebp
movl 0x6(%r15), %eax
bswapl %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
leal -0x433(%rbx), %edi
movsd 0x169e(%rip), %xmm0     # 0x3008
callq 0x1060
mulsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
andl $0xf0000, %r12d         # imm = 0xF0000
orl %ebp, %r12d
leal (%r12,%r13), %eax
addl $0x100000, %eax         # imm = 0x100000
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x28(%rsp)
addl $0xfffffbed, %ebx       # imm = 0xFFFFFBED
movsd 0x1662(%rip), %xmm0     # 0x3008
movl %ebx, %edi
callq 0x1060
mulsd 0x28(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
jmp 0x1a86
xorl %r13d, %r13d
movq %r14, %rdi
leaq 0x1692(%rip), %rsi      # 0x305d
movl %ebx, %edx
xorl %eax, %eax
callq 0x1150
orl $0x2, (%rsp)
movb $0x1, %dil
movq %r12, %r15
xorl %ebp, %ebp
jmp 0x151b
movq %r14, %rdi
movq %r12, %rsi
pushq $0x27
jmp 0x19f7
movq %r14, %rdi
movq %r12, %rsi
pushq $0x22
popq %rdx
callq 0x1b50
movl %eax, %r15d
addq %r12, %r15
jmp 0x1aef
movb 0x6(%r12), %al
testb $0x20, %al
je 0x1a28
leaq -0x4(%r12), %rdi
movq 0x38(%rsp), %rsi
callq 0x1bc2
movb $0x1, %dil
movb 0x6(%r12), %al
testb $0x10, %al
je 0x1a37
movl (%r12), %eax
bswapl %eax
movq %rax, 0x20(%rsp)
addq $0x8, %r12
xorl %ebp, %ebp
movq %r12, %r15
jmp 0x151b
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
pushq $0x14
popq %rsi
leaq 0x182a(%rip), %rdx      # 0x3284
movb $0x1, %al
callq 0x1100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movzbl (%rbx), %ecx
testl %ecx, %ecx
je 0x1ad6
cmpl $0x2e, %ecx
je 0x1aeb
cmpl $0x45, %ecx
je 0x1aeb
incq %rbx
jmp 0x1a6c
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
pushq $0x1e
popq %rsi
leaq 0x17f2(%rip), %rdx      # 0x328a
movb $0x1, %al
callq 0x1100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1120
movzbl (%rbx), %ecx
testl %ecx, %ecx
je 0x1abb
cmpl $0x2e, %ecx
je 0x1ad0
incq %rbx
jmp 0x1aaa
leaq 0x17c5(%rip), %rdi      # 0x3287
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x11d0
addq $0xa, %r15
jmp 0x1aef
leaq 0x17aa(%rip), %rdi      # 0x3287
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x11d0
addq $0x6, %r15
movb $0x1, %dil
xorl %r13d, %r13d
xorl %ebp, %ebp
jmp 0x151b
testb %r13b, %r13b
sete %al
testb %bpl, %bpl
setne %cl
orb %al, %cl
jne 0x1b17
pushq $0x20
popq %rdi
movq %r14, %rsi
callq 0x1140
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x1140
movq 0x30(%rsp), %rbx
movl 0x14(%rsp), %r12d
movq 0x20(%rsp), %r13
jmp 0x1442
movl (%rsp), %eax
jmp 0x1b41
movl (%rsp), %eax
orl $0x1, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq