// File: /workspace/github_c_makefile_star2_O3/janet-lang[P]janet/src/core/specials.c
// Function: janetc_fn
static JanetSlot janetc_fn(JanetFopts opts, int32_t argn, const Janet *argv) {
    JanetCompiler *c = opts.compiler;
    JanetFuncDef *def;
    JanetSlot ret;
    Janet head;
    JanetScope fnscope;
    int32_t paramcount, argi, parami, arity, min_arity = 0, max_arity, defindex, i;
    JanetFopts subopts = janetc_fopts_default(c);
    const Janet *params;
    const char *errmsg = NULL;

    /* Function flags */
    int vararg = 0;
    int structarg = 0;
    int allow_extra = 0;
    int selfref = 0;
    int hasname = 0;
    int seenamp = 0;
    int seenopt = 0;
    int namedargs = 0;

    /* Begin function */
    c->scope->flags |= JANET_SCOPE_CLOSURE;
    janetc_scope(&fnscope, c, JANET_SCOPE_FUNCTION, "function");

    if (argn == 0) {
        errmsg = "expected at least 1 argument to function literal";
        goto error;
    }

    /* Read function parameters */
    parami = 0;
    head = argv[0];
    if (janet_checktype(head, JANET_SYMBOL)) {
        selfref = 1;
        hasname = 1;
        parami = 1;
    } else if (janet_checktype(head, JANET_KEYWORD)) {
        hasname = 1;
        parami = 1;
    }
    if (parami >= argn || !janet_checktype(argv[parami], JANET_TUPLE)) {
        errmsg = "expected function parameters";
        goto error;
    }

    /* Keep track of destructured parameters */
    JanetSlot *destructed_params = NULL;
    JanetSlot *named_params = NULL;
    JanetTable *named_table = NULL;
    JanetSlot named_slot;

    /* Compile function parameters */
    params = janet_unwrap_tuple(argv[parami]);
    paramcount = janet_tuple_length(params);
    arity = paramcount;
    for (i = 0; i < paramcount; i++) {
        Janet param = params[i];
        if (namedargs) {
            arity--;
            if (!janet_checktype(param, JANET_SYMBOL)) {
                errmsg = "only named arguments can follow &named";
                goto error;
            }
            Janet key = janet_wrap_keyword(janet_unwrap_symbol(param));
            janet_table_put(named_table, key, param);
            janet_v_push(named_params, janetc_farslot(c));
        } else if (janet_checktype(param, JANET_SYMBOL)) {
            /* Check for varargs and unfixed arity */
            const uint8_t *sym = janet_unwrap_symbol(param);
            if (sym[0] == '&') {
                if (!janet_cstrcmp(sym, "&")) {
                    if (seenamp) {
                        errmsg = "& in unexpected location";
                        goto error;
                    } else if (i == paramcount - 1) {
                        allow_extra = 1;
                        arity--;
                    } else if (i == paramcount - 2) {
                        vararg = 1;
                        arity -= 2;
                    } else {
                        errmsg = "& in unexpected location";
                        goto error;
                    }
                    seenamp = 1;
                } else if (!janet_cstrcmp(sym, "&opt")) {
                    if (seenopt) {
                        errmsg = "only one &opt allowed";
                        goto error;
                    } else if (i == paramcount - 1) {
                        errmsg = "&opt cannot be last item in parameter list";
                        goto error;
                    }
                    min_arity = i;
                    arity--;
                    seenopt = 1;
                } else if (!janet_cstrcmp(sym, "&keys")) {
                    if (seenamp) {
                        errmsg = "&keys in unexpected location";
                        goto error;
                    } else if (i == paramcount - 2) {
                        vararg = 1;
                        structarg = 1;
                        arity -= 2;
                    } else {
                        errmsg = "&keys in unexpected location";
                        goto error;
                    }
                    seenamp = 1;
                } else if (!janet_cstrcmp(sym, "&named")) {
                    if (seenamp) {
                        errmsg = "&named in unexpected location";
                        goto error;
                    }
                    vararg = 1;
                    structarg = 1;
                    arity--;
                    seenamp = 1;
                    namedargs = 1;
                    named_table = janet_table(10);
                    named_slot = janetc_farslot(c);
                } else {
                    janetc_nameslot(c, sym, janetc_farslot(c));
                }
            } else {
                janetc_nameslot(c, sym, janetc_farslot(c));
            }
        } else {
            janet_v_push(destructed_params, janetc_farslot(c));
        }
    }

    /* Compile destructed params */
    int32_t j = 0;
    for (i = 0; i < paramcount; i++) {
        Janet param = params[i];
        if (!janet_checktype(param, JANET_SYMBOL)) {
            janet_assert(janet_v_count(destructed_params) > j, "out of bounds");
            JanetSlot reg = destructed_params[j++];
            destructure(c, param, reg, defleaf, NULL);
            janetc_freeslot(c, reg);
        }
    }
    janet_v_free(destructed_params);

    /* Compile named arguments */
    if (namedargs) {
        Janet param = janet_wrap_table(named_table);
        destructure(c, param, named_slot, defleaf, NULL);
        janetc_freeslot(c, named_slot);
        janet_v_free(named_params);
    }

    max_arity = (vararg || allow_extra) ? INT32_MAX : arity;
    if (!seenopt) min_arity = arity;

    /* Check for self ref (also avoid if arguments shadow own name) */
    if (selfref) {
        /* Check if the parameters shadow the function name. If so, don't
         * emit JOP_LOAD_SELF and add a binding since that most users
         * seem to expect that function parameters take precedence over the
         * function name */
        const uint8_t *sym = janet_unwrap_symbol(head);
        int32_t len = janet_v_count(c->scope->syms);
        int found = 0;
        for (int32_t i = 0; i < len; i++) {
            if (c->scope->syms[i].sym == sym) {
                found = 1;
            }
        }
        if (!found) {
            JanetSlot slot = janetc_farslot(c);
            slot.flags = JANET_SLOT_NAMED | JANET_FUNCTION;
            janetc_emit_s(c, JOP_LOAD_SELF, slot, 1);
            janetc_nameslot(c, sym, slot);
        }
    }

    /* Compile function body */
    if (parami + 1 == argn) {
        janetc_emit(c, JOP_RETURN_NIL);
    } else {
        for (argi = parami + 1; argi < argn; argi++) {
            subopts.flags = (argi == (argn - 1)) ? JANET_FOPTS_TAIL : JANET_FOPTS_DROP;
            janetc_value(subopts, argv[argi]);
            if (c->result.status == JANET_COMPILE_ERROR)
                goto error2;
        }
    }

    /* Build function */
    def = janetc_pop_funcdef(c);
    def->arity = arity;
    def->min_arity = min_arity;
    def->max_arity = max_arity;
    if (vararg) def->flags |= JANET_FUNCDEF_FLAG_VARARG;
    if (structarg) def->flags |= JANET_FUNCDEF_FLAG_STRUCTARG;

    if (hasname) def->name = janet_unwrap_symbol(head); /* Also correctly unwraps keyword */
    janet_def_addflags(def);
    defindex = janetc_addfuncdef(c, def);

    /* Ensure enough slots for vararg function. */
    if (arity + vararg > def->slotcount) def->slotcount = arity + vararg;

    /* Instantiate closure */
    ret = janetc_gettarget(opts);
    janetc_emit_su(c, JOP_CLOSURE, ret, defindex, 1);
    return ret;

error:
    janetc_cerror(c, errmsg);
error2:
    janetc_popscope(c);
    return janetc_cslot(janet_wrap_nil());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r13
movl %esi, %r15d
movq %rdi, %rbx
movq 0x10(%rbp), %r14
leaq -0x128(%rbp), %rdi
movq %r14, %rsi
callq 0x1ba98
movq (%r14), %rax
orl $0x10, 0x6c(%rax)
leaq 0x1aae9(%rip), %rcx     # 0x5c16a
leaq -0x198(%rbp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1be43
testl %r15d, %r15d
movq %rbx, -0xb0(%rbp)
je 0x41aa4
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
movq (%r13), %rdx
movq %rdx, %r12
andq %rcx, %r12
movabsq $0x5800000000000, %rax  # imm = 0x5800000000000
addq %r12, %rax
xorl %r8d, %r8d
shrq $0x30, %rax
sete %r8b
leaq 0x2734f(%rip), %rsi     # 0x68a27
cmpl %r15d, %r8d
jge 0x41aab
movq (%r13,%r8,8), %rdi
movq %rdi, %rax
andq %rcx, %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x41aab
movq %r8, -0xb8(%rbp)
movq %rdx, -0xa8(%rbp)
callq 0x4ebc4
movq %rax, -0x68(%rbp)
movslq -0x10(%rax), %rcx
testq %rcx, %rcx
movq %r12, -0x88(%rbp)
movq %r15, -0x60(%rbp)
jle 0x41af1
movq %r13, -0x98(%rbp)
leal -0x2(%rcx), %eax
movq %rax, -0xa0(%rbp)
leal -0x1(%rcx), %eax
movq %rax, -0x58(%rbp)
xorl %r12d, %r12d
movl %ecx, -0x2c(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x48(%rbp)
movq $0x0, -0x90(%rbp)
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %eax, %eax
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x68(%rbp), %rcx
movq (%rcx,%r12,8), %r13
testl %eax, %eax
je 0x4184f
movq %r13, %rax
andq %rdi, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x41ecb
movq %r13, %rdi
callq 0x4ebc4
movq %rax, %rdi
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
callq 0x4ed39
movq -0x90(%rbp), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x476f0
testq %r15, %r15
je 0x417fd
movl -0x4(%r15), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r15), %ecx
jl 0x41818
movq %r15, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4b4e8
movq %rax, %r15
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
decl -0x2c(%rbp)
movl %ecx, -0x4(%r15)
cltq
leaq (%rax,%rax,2), %r13
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x1be05
movq -0x70(%rbp), %rax
movq %rax, 0x10(%r15,%r13,8)
movups -0x80(%rbp), %xmm0
movups %xmm0, (%r15,%r13,8)
movl $0x1, %eax
xorl %esi, %esi
jmp 0x41986
movq %r13, %rax
andq %rdi, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x418fc
movq %r13, %rdi
callq 0x4ebc4
movq %rax, %r13
cmpb $0x26, (%rax)
jne 0x41950
movq %r13, %rdi
leaq 0x1c71c(%rip), %rsi     # 0x5dfa2
callq 0x4872e
testl %eax, %eax
je 0x419a5
movq %r13, %rdi
leaq 0x271e7(%rip), %rsi     # 0x68a84
callq 0x4872e
testl %eax, %eax
je 0x419cd
movq %r13, %rdi
leaq 0x27216(%rip), %rsi     # 0x68aca
callq 0x4872e
testl %eax, %eax
je 0x41a2d
movq %r13, %rdi
leaq 0x27199(%rip), %rsi     # 0x68a64
callq 0x4872e
testl %eax, %eax
je 0x41a56
leaq -0x100(%rbp), %rdi
movq %r14, %rsi
callq 0x1be05
movq -0xf0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x100(%rbp), %xmm0
jmp 0x41972
testq %rbx, %rbx
je 0x4190c
movl -0x4(%rbx), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%rbx), %ecx
jl 0x41927
movq %rbx, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4b4e8
movq %rax, %rbx
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rbx)
cltq
leaq (%rax,%rax,2), %r13
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x1be05
movq -0x70(%rbp), %rax
movq %rax, 0x10(%rbx,%r13,8)
movups -0x80(%rbp), %xmm0
movups %xmm0, (%rbx,%r13,8)
jmp 0x41981
leaq -0xe8(%rbp), %rdi
movq %r14, %rsi
callq 0x1be05
movq -0xd8(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xe8(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x1bd3f
xorl %eax, %eax
movb $0x1, %sil
movq -0x40(%rbp), %rdx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
incq %r12
cmpq %r12, %rdx
jne 0x41796
jmp 0x41b01
cmpl $0x0, -0x30(%rbp)
jne 0x41ed7
cmpq %r12, -0x58(%rbp)
jne 0x419f6
decl -0x2c(%rbp)
xorl %eax, %eax
movb $0x1, %sil
movl $0x1, -0x38(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x41986
cmpl $0x0, -0x4c(%rbp)
jne 0x41ee3
cmpq %r12, -0x58(%rbp)
je 0x41eef
decl -0x2c(%rbp)
xorl %eax, %eax
movb $0x1, %sil
movl $0x1, -0x4c(%rbp)
movl %r12d, -0x44(%rbp)
jmp 0x41986
cmpq %r12, -0xa0(%rbp)
movq -0x40(%rbp), %rdx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
jne 0x41ed7
addl $-0x2, -0x2c(%rbp)
xorl %eax, %eax
movb $0x1, %sil
movl $0x1, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x41994
cmpl $0x0, -0x30(%rbp)
jne 0x41f07
cmpq %r12, -0xa0(%rbp)
jne 0x41f07
addl $-0x2, -0x2c(%rbp)
xorl %eax, %eax
movb $0x1, %sil
movl $0x1, -0x30(%rbp)
jmp 0x41a91
cmpl $0x0, -0x30(%rbp)
jne 0x41efb
decl -0x2c(%rbp)
movl $0xa, %edi
callq 0x47425
movq %rax, -0x90(%rbp)
leaq -0xd0(%rbp), %rdi
movq %r14, %rsi
callq 0x1be05
movl $0x1, -0x30(%rbp)
xorl %esi, %esi
movl $0x1, %eax
movl $0x1, -0x48(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x41986
leaq 0x26f4b(%rip), %rsi     # 0x689f6
movq %r14, %rdi
callq 0x1bb46
movq %r14, %rdi
callq 0x1beec
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4ece6
movq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1baf6
movq %r14, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edx, %edx
movb $0x1, -0x30(%rbp)
movl %ecx, -0x44(%rbp)
xorl %eax, %eax
jmp 0x41c7a
movl %esi, -0x58(%rbp)
cmpl $0x0, -0x38(%rbp)
setne %al
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x4c(%rbp)
movl -0x44(%rbp), %eax
cmovel -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x48(%rbp)
sete -0x30(%rbp)
testl %edx, %edx
jle 0x41bd5
xorl %r12d, %r12d
xorl %r13d, %r13d
movq -0x68(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %rsi, %rax
andq %rdi, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
je 0x41bc9
testq %rbx, %rbx
je 0x41b59
movl -0x4(%rbx), %eax
jmp 0x41b5b
xorl %eax, %eax
cmpl %r13d, %eax
jle 0x41f13
movslq %r13d, %rax
incl %r13d
leaq (%rax,%rax,2), %rax
movq 0x10(%rbx,%rax,8), %rcx
movq %rcx, -0x70(%rbp)
movups (%rbx,%rax,8), %xmm0
movaps %xmm0, -0x80(%rbp)
movq 0x10(%rbx,%rax,8), %rcx
movq %rcx, 0x10(%rsp)
movups (%rbx,%rax,8), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
leaq 0x1ce6(%rip), %rdx      # 0x43881
xorl %ecx, %ecx
callq 0x43160
movq -0x70(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x80(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1bd19
movq -0x40(%rbp), %rdx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
incq %r12
cmpq %r12, %rdx
jne 0x41b32
testq %rbx, %rbx
je 0x41be6
addq $-0x8, %rbx
movq %rbx, %rdi
callq 0x2bcd9
cmpb $0x0, -0x58(%rbp)
movq -0x88(%rbp), %r12
movq -0x98(%rbp), %r13
jne 0x41c6b
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq -0x90(%rbp), %rdi
callq 0x4ed7e
movq -0xc0(%rbp), %rcx
movq %rcx, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1c53(%rip), %rdx      # 0x43881
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x43160
movq -0xc0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xd0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1bd19
testq %r15, %r15
je 0x41c6b
addq $-0x8, %r15
movq %r15, %rdi
callq 0x2bcd9
movl -0x2c(%rbp), %eax
movl %eax, %ecx
movq -0x60(%rbp), %r15
movl -0x34(%rbp), %edx
movl -0x38(%rbp), %eax
testb $0x1, %al
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rcx, -0x40(%rbp)
cmovnel %eax, %ecx
movl %edx, -0x34(%rbp)
testl %edx, %edx
cmovnel %eax, %ecx
movl %ecx, -0x68(%rbp)
movabsq $-0x5800000000000, %rax # imm = 0xFFFA800000000000
cmpq %rax, %r12
jne 0x41d46
movq -0xa8(%rbp), %rdi
callq 0x4ebc4
movq %rax, %rbx
movq (%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x41cec
movslq -0x4(%rax), %rcx
testq %rcx, %rcx
jle 0x41cec
imulq $0x38, %rcx, %rcx
xorl %edx, %edx
movl $0x1, %esi
xorl %edi, %edi
cmpq %rbx, 0x18(%rax,%rdx)
cmovel %esi, %edi
addq $0x38, %rdx
cmpq %rdx, %rcx
jne 0x41cd7
testl %edi, %edi
jne 0x41d46
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1be05
movl $0x2000c, 0x10(%r15)    # imm = 0x2000C
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movl $0x2e, %esi
movl $0x1, %edx
callq 0x21ae6
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movq -0x60(%rbp), %r15
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bd3f
movq -0xb8(%rbp), %rcx
incl %ecx
cmpl %r15d, %ecx
jne 0x41d63
movq %r14, %rdi
movl $0x4, %esi
callq 0x21728
jmp 0x41dcd
jge 0x41dcd
movq %r13, %rbx
movq %r15, %rax
decl %r15d
movl %ecx, %r13d
movl %eax, %r12d
cmpq %r13, %r15
movl $0x40000, %eax          # imm = 0x40000
movl $0x10000, %ecx          # imm = 0x10000
cmovel %ecx, %eax
movl %eax, -0x108(%rbp)
movq (%rbx,%r13,8), %rsi
movq -0x108(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x128(%rbp), %xmm0
movups -0x118(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x80(%rbp), %rdi
callq 0x1c7be
cmpl $0x1, 0x48(%r14)
je 0x41ab3
incq %r13
cmpq %r13, %r12
jne 0x41d74
movq %r14, %rdi
callq 0x1da6f
movq %rax, %rbx
movq -0x40(%rbp), %rax
movl %eax, 0x60(%rbx)
movl -0x44(%rbp), %eax
movl %eax, 0x64(%rbx)
movl -0x68(%rbp), %eax
movl %eax, 0x68(%rbx)
movl -0x34(%rbp), %r13d
testl %r13d, %r13d
je 0x41df8
orb $0x1, 0x5a(%rbx)
cmpb $0x0, -0x30(%rbp)
movq -0x88(%rbp), %rax
jne 0x41e09
orb $0x1, 0x5b(%rbx)
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x41e27
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x41e37
movq -0xa8(%rbp), %rdi
callq 0x4ebc4
movq %rax, 0x48(%rbx)
leaq 0x10(%rbp), %r12
movq %rbx, %rdi
callq 0x1d9dc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43d00
movl %eax, %r15d
movq -0x40(%rbp), %rax
addl %r13d, %eax
cmpl 0x5c(%rbx), %eax
jle 0x41e60
movl %eax, 0x5c(%rbx)
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c64f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movzwl %r15w, %edx
movq %r14, %rdi
movl $0x30, %esi
movl $0x1, %ecx
callq 0x21d9e
movups (%rbx), %xmm0
movq -0xb0(%rbp), %r14
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x41adc
leaq 0x26b72(%rip), %rsi     # 0x68a44
jmp 0x41aab
leaq 0x26b8d(%rip), %rsi     # 0x68a6b
jmp 0x41aab
leaq 0x26b9f(%rip), %rsi     # 0x68a89
jmp 0x41aab
leaq 0x26ba9(%rip), %rsi     # 0x68a9f
jmp 0x41aab
leaq 0x26beb(%rip), %rsi     # 0x68aed
jmp 0x41aab
leaq 0x26bc2(%rip), %rsi     # 0x68ad0
jmp 0x41aab
callq 0x13f64