// File: /workspace/github_c_makefile_star2_O2/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 $0x1b8, %rsp            # imm = 0x1B8
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rbp), %r14
leaq -0x140(%rbp), %rdi
movq %r14, %rsi
callq 0x19f04
movq (%r14), %rax
orl $0x10, 0x6c(%rax)
leaq 0x1a0bb(%rip), %rcx     # 0x5816a
leaq -0x1b0(%rbp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x1a294
testl %r12d, %r12d
movq %rbx, -0xb0(%rbp)
je 0x3e505
movabsq $-0x800000000000, %rcx  # imm = 0xFFFF800000000000
movq (%r15), %rdx
movq %rdx, %r9
andq %rcx, %r9
movabsq $0x5800000000000, %rax  # imm = 0x5800000000000
addq %r9, %rax
xorl %r8d, %r8d
shrq $0x30, %rax
sete %r8b
leaq 0x26944(%rip), %rsi     # 0x64a47
cmpl %r12d, %r8d
jge 0x3e50c
movq (%r15,%r8,8), %rdi
movq %rdi, %rax
andq %rcx, %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x3e50c
movq %r8, -0xc0(%rbp)
movq %r12, -0xc8(%rbp)
movq %r15, -0xd0(%rbp)
movq %r9, -0xa8(%rbp)
movq %rdx, -0x98(%rbp)
movq %r14, -0x38(%rbp)
callq 0x4b1f1
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
movq %rax, -0xb8(%rbp)
movl -0x10(%rax), %eax
leal -0x2(%rax), %ecx
movq %rcx, -0x90(%rbp)
leal -0x1(%rax), %ecx
movq %rcx, -0xa0(%rbp)
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %ecx
movq %rax, -0x40(%rbp)
cmovgl %eax, %ecx
movq %rcx, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x50(%rbp)
xorl %edi, %edi
xorl %r13d, %r13d
xorl %r15d, %r15d
movq $0x0, -0x88(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x48(%rbp)
pushq $0x1
popq %r14
cmpq %rbx, -0x60(%rbp)
je 0x3e552
movq -0xb8(%rbp), %rax
movq (%rax,%rbx,8), %r12
movq %r12, %rax
andq %rdx, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
testl %edi, %edi
je 0x3e2a8
cmpq %rcx, %rax
jne 0x3e722
movq %r12, %rdi
callq 0x4b1f1
movq %rax, %rdi
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
callq 0x4b366
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x43e19
testq %r15, %r15
je 0x3e246
movl -0x4(%r15), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r15), %ecx
jl 0x3e25d
movq %r15, %rdi
movl %r14d, %esi
pushq $0x18
popq %rdx
callq 0x4799c
movq %rax, %r15
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %r14d, %r12d
movq -0x40(%rbp), %rdx
decl %edx
movq %rdx, -0x40(%rbp)
movl %ecx, -0x4(%r15)
cltq
imulq $0x18, %rax, %r14
leaq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a259
movq -0x70(%rbp), %rax
movq %rax, 0x10(%r15,%r14)
movups -0x80(%rbp), %xmm0
movups %xmm0, (%r15,%r14)
movl %r12d, %edi
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
movl %r12d, %r14d
jmp 0x3e402
cmpq %rcx, %rax
jne 0x3e358
movq %r12, %rdi
callq 0x4b1f1
movq %rax, %r12
cmpb $0x26, (%rax)
jne 0x3e3bd
movq %r12, %rdi
leaq 0x1bcd3(%rip), %rsi     # 0x59fa2
callq 0x44ca9
testl %eax, %eax
je 0x3e40a
movq %r12, %rdi
leaq 0x267be(%rip), %rsi     # 0x64aa4
callq 0x44ca9
testl %eax, %eax
je 0x3e433
movq %r12, %rdi
leaq 0x267ed(%rip), %rsi     # 0x64aea
callq 0x44ca9
testl %eax, %eax
je 0x3e490
movq %r12, %rdi
leaq 0x26770(%rip), %rsi     # 0x64a84
callq 0x44ca9
testl %eax, %eax
je 0x3e4ba
leaq -0x118(%rbp), %rdi
movq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0x1a259
movq -0x108(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x118(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x1a19d
jmp 0x3e3ab
testq %r13, %r13
je 0x3e36a
movl -0x4(%r13), %eax
leal 0x1(%rax), %ecx
cmpl -0x8(%r13), %ecx
jl 0x3e381
movq %r13, %rdi
movl %r14d, %esi
pushq $0x18
popq %rdx
callq 0x4799c
movq %rax, %r13
movl -0x4(%rax), %eax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%r13)
cltq
imulq $0x18, %rax, %r14
leaq -0x80(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a259
movq -0x70(%rbp), %rax
movq %rax, 0x10(%r13,%r14)
movups -0x80(%rbp), %xmm0
movups %xmm0, (%r13,%r14)
xorl %edi, %edi
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
pushq $0x1
popq %r14
jmp 0x3e402
leaq -0x100(%rbp), %rdi
movq -0x38(%rbp), %r14
movq %r14, %rsi
callq 0x1a259
movq -0xf0(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x100(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
pushq $0x1
popq %r14
movq %r12, %rsi
callq 0x1a19d
xorl %edi, %edi
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
incq %rbx
jmp 0x3e1d2
cmpl $0x0, -0x2c(%rbp)
jne 0x3e911
cmpq %rbx, -0xa0(%rbp)
jne 0x3e45f
movq -0x40(%rbp), %rax
decl %eax
movq %rax, -0x40(%rbp)
xorl %edi, %edi
movl %r14d, -0x54(%rbp)
movl %r14d, -0x2c(%rbp)
jmp 0x3e3f8
cmpl $0x0, -0x50(%rbp)
jne 0x3e91a
cmpq %rbx, -0xa0(%rbp)
je 0x3e923
movq -0x40(%rbp), %rax
decl %eax
movq %rax, -0x40(%rbp)
xorl %edi, %edi
movl %r14d, -0x50(%rbp)
movl %ebx, -0x48(%rbp)
jmp 0x3e3f8
cmpq %rbx, -0x90(%rbp)
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
jne 0x3e911
movq -0x40(%rbp), %rax
addl $-0x2, %eax
movq %rax, -0x40(%rbp)
xorl %edi, %edi
movl %r14d, -0x2c(%rbp)
movl %r14d, -0x44(%rbp)
jmp 0x3e402
cmpl $0x0, -0x2c(%rbp)
jne 0x3e935
cmpq %rbx, -0x90(%rbp)
jne 0x3e935
movq -0x40(%rbp), %rax
addl $-0x2, %eax
movq %rax, -0x40(%rbp)
xorl %edi, %edi
movl %r14d, -0x2c(%rbp)
jmp 0x3e4f8
cmpl $0x0, -0x2c(%rbp)
jne 0x3e92c
movq -0x40(%rbp), %rax
decl %eax
movq %rax, -0x40(%rbp)
pushq $0xa
popq %rdi
callq 0x43b8a
movq %rax, -0x88(%rbp)
leaq -0xe8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1a259
pushq $0x1
popq %r14
movl %r14d, -0x2c(%rbp)
movl %r14d, %edi
movl %r14d, -0x4c(%rbp)
movl %r14d, -0x44(%rbp)
jmp 0x3e3f8
leaq 0x2650a(%rip), %rsi     # 0x64a16
movq %r14, %rdi
callq 0x19fa9
movq %r14, %rdi
callq 0x1a338
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4b313
movq -0xb0(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x19f5c
movq %r14, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
xorl %r12d, %r12d
movl %edi, -0x2c(%rbp)
movq -0x38(%rbp), %r14
cmpq %rbx, -0x60(%rbp)
je 0x3e60e
movq -0xb8(%rbp), %rax
movq (%rax,%rbx,8), %rsi
movq %rsi, %rax
andq %rdx, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
je 0x3e606
testq %r13, %r13
je 0x3e593
movl -0x4(%r13), %eax
jmp 0x3e595
xorl %eax, %eax
cmpl %r12d, %eax
jle 0x3e945
movslq %r12d, %rax
incl %r12d
imulq $0x18, %rax, %rax
movq 0x10(%r13,%rax), %rcx
movq %rcx, -0x70(%rbp)
movups (%r13,%rax), %xmm0
movaps %xmm0, -0x80(%rbp)
movq 0x10(%r13,%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%r13,%rax), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
leaq 0x1c7b(%rip), %rdx      # 0x40254
xorl %ecx, %ecx
callq 0x3fb99
movq -0x70(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0x80(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1a177
movabsq $-0x800000000000, %rdx  # imm = 0xFFFF800000000000
movl -0x2c(%rbp), %edi
incq %rbx
jmp 0x3e55e
testq %r13, %r13
je 0x3e622
addq $-0x8, %r13
movq %r13, %rdi
callq 0x298c1
movl -0x2c(%rbp), %edi
testl %edi, %edi
movq -0x38(%rbp), %r12
je 0x3e69b
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq -0x88(%rbp), %rdi
callq 0x4b3ab
movq -0xd8(%rbp), %rcx
movq %rcx, 0x10(%rsp)
movups -0xe8(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1bf6(%rip), %rdx      # 0x40254
movq %r12, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x3fb99
movq -0xd8(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xe8(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x1a177
testq %r15, %r15
je 0x3e69b
addq $-0x8, %r15
movq %r15, %rdi
callq 0x298c1
movl -0x54(%rbp), %eax
orl -0x44(%rbp), %eax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq -0x40(%rbp), %rax
cmovel %eax, %ecx
movl %ecx, -0x60(%rbp)
cmpl $0x0, -0x50(%rbp)
movl -0x48(%rbp), %ecx
cmovel %eax, %ecx
movl %ecx, -0x48(%rbp)
movabsq $-0x5800000000000, %rax # imm = 0xFFFA800000000000
cmpq %rax, -0xa8(%rbp)
movq -0xc8(%rbp), %r13
jne 0x3e788
movq -0x98(%rbp), %rdi
callq 0x4b1f1
movq %rax, %rbx
movq (%r12), %rax
movq 0x20(%rax), %rcx
xorl %eax, %eax
movl $0x0, %edx
testq %rcx, %rcx
je 0x3e701
movl -0x4(%rcx), %edx
testl %edx, %edx
cmovlel %eax, %edx
imulq $0x38, %rdx, %rdx
pushq $0x1
popq %rsi
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x3e732
cmpq %rbx, 0x18(%rcx,%rdi)
cmovel %esi, %eax
addq $0x38, %rdi
jmp 0x3e70f
movq -0x38(%rbp), %r14
leaq 0x26337(%rip), %rsi     # 0x64a64
jmp 0x3e50c
testl %eax, %eax
jne 0x3e788
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a259
movl $0x2000c, 0x10(%r15)    # imm = 0x2000C
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
pushq $0x2e
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x1fbb3
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1a19d
movq -0xc0(%rbp), %rax
incl %eax
cmpl %r13d, %eax
jne 0x3e89b
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x1f7c4
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x1bcb6
movq %rax, %rbx
movq -0x40(%rbp), %r13
movl %r13d, 0x60(%rax)
movl -0x48(%rbp), %eax
movl %eax, 0x64(%rbx)
movl -0x60(%rbp), %eax
movl %eax, 0x68(%rbx)
cmpl $0x0, -0x44(%rbp)
je 0x3e7d2
orb $0x1, 0x5a(%rbx)
cmpl $0x0, -0x4c(%rbp)
movq -0xb0(%rbp), %r14
movq -0xa8(%rbp), %rax
je 0x3e7ea
orb $0x1, 0x5b(%rbx)
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x3e808
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x3e818
movq -0x98(%rbp), %rdi
callq 0x4b1f1
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x1bc23
movq %r12, %rdi
movq %rbx, %rsi
callq 0x406c6
movl %eax, %r15d
addl -0x44(%rbp), %r13d
cmpl 0x5c(%rbx), %r13d
jle 0x3e83c
movl %r13d, 0x5c(%rbx)
leaq 0x10(%rbp), %rcx
movq 0x20(%rcx), %rax
movq %rax, 0x20(%rsp)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x1aa9e
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
movzwl %r15w, %edx
pushq $0x30
popq %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
callq 0x1fe7f
movups (%rbx), %xmm0
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x3e53d
movl %eax, %r15d
movslq %r13d, %r12
decl %r13d
movl $0x10000, %r14d         # imm = 0x10000
leaq -0x80(%rbp), %rbx
cmpq %r12, %r15
jge 0x3e7a5
cmpq %r15, %r13
movl $0x40000, %eax          # imm = 0x40000
cmovel %r14d, %eax
movl %eax, -0x120(%rbp)
movq -0xd0(%rbp), %rax
movq (%rax,%r15,8), %rsi
movq -0x120(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x140(%rbp), %xmm0
movups -0x130(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1abbf
incq %r15
movq -0x38(%rbp), %rdi
cmpl $0x1, 0x48(%rdi)
jne 0x3e8ae
jmp 0x3e517
leaq 0x26173(%rip), %rsi     # 0x64a8b
jmp 0x3e93c
leaq 0x26188(%rip), %rsi     # 0x64aa9
jmp 0x3e93c
leaq 0x26195(%rip), %rsi     # 0x64abf
jmp 0x3e93c
leaq 0x261da(%rip), %rsi     # 0x64b0d
jmp 0x3e93c
leaq 0x261b4(%rip), %rsi     # 0x64af0
movq -0x38(%rbp), %r14
jmp 0x3e50c
movq 0x416a4(%rip), %rax     # 0x7fff0
movq (%rax), %rdi
leaq 0x116ba(%rip), %rsi     # 0x50010
leaq 0x25f10(%rip), %rcx     # 0x6486d
leaq 0x196f1(%rip), %r8      # 0x58055
movl $0x41a, %edx            # imm = 0x41A
xorl %eax, %eax
callq 0x125e0
callq 0x12100