// File: /workspace/github_c_makefile_star2_O1/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 $0x1c8, %rsp            # imm = 0x1C8
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
movq 0x10(%rbp), %r14
leaq -0x150(%rbp), %rdi
movq %r14, %rsi
callq 0x1bbf0
movq (%r14), %rax
orl $0x10, 0x6c(%rax)
leaq 0x1b36c(%rip), %rcx     # 0x5d16a
leaq -0x1c0(%rbp), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x1bf9c
testl %r12d, %r12d
movq %rbx, -0xc8(%rbp)
je 0x42378
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 0x27bf3(%rip), %rsi     # 0x69a47
cmpl %r12d, %r8d
jge 0x4237f
movq (%r15,%r8,8), %rdi
movq %rdi, %rax
andq %rcx, %rax
movabsq $-0x4000000000000, %rcx # imm = 0xFFFC000000000000
cmpq %rcx, %rax
jne 0x4237f
movq %r8, -0xd0(%rbp)
movq %r12, -0xd8(%rbp)
movq %r15, -0xe0(%rbp)
movq %r9, -0xc0(%rbp)
movq %rdx, -0xb8(%rbp)
callq 0x4f838
movq %rax, -0x80(%rbp)
movslq -0x10(%rax), %r8
testq %r8, %r8
movq %r8, -0x40(%rbp)
jle 0x423c5
leal -0x2(%r8), %eax
movq %rax, -0xa8(%rbp)
leal -0x1(%r8), %eax
movq %rax, -0xb0(%rbp)
xorl %r12d, %r12d
movl %r8d, %edx
movl $0x0, -0x50(%rbp)
movq $0x0, -0x48(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x54(%rbp)
movq $0x0, -0x78(%rbp)
movq $0x0, -0x60(%rbp)
xorl %ebx, %ebx
xorl %r9d, %r9d
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x64(%rbp)
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq %r14, -0x70(%rbp)
movq -0x80(%rbp), %rax
movq (%rax,%r12,8), %r13
testl %r9d, %r9d
je 0x4200e
decl %edx
movq %r13, %rax
andq %rdi, %rax
movl $0x1, %r9d
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x420c1
movl %edx, -0x2c(%rbp)
movq %r13, %rdi
callq 0x4f838
movq %rax, %rdi
movabsq $-0x5000000000000, %rsi # imm = 0xFFFB000000000000
callq 0x4f9ad
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x481b3
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x41f99
movl -0x4(%rdi), %eax
incl %eax
cmpl -0x8(%rdi), %eax
jl 0x41fab
movl $0x1, %esi
movl $0x18, %edx
callq 0x4c0b4
movq %rax, %rdi
movslq -0x4(%rdi), %rax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rdi)
leaq (%rax,%rax,2), %r13
movq %rdi, %r14
leaq -0xa0(%rbp), %rdi
movq -0x70(%rbp), %r15
movq %r15, %rsi
callq 0x1bf5e
movq -0x90(%rbp), %rax
movq %rax, 0x10(%r14,%r13,8)
movups -0xa0(%rbp), %xmm0
movq %r14, -0x60(%rbp)
movups %xmm0, (%r14,%r13,8)
movq %r15, %r14
movb $0x1, %al
xorl %esi, %esi
movl -0x2c(%rbp), %edx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
movl $0x1, %r9d
jmp 0x42249
movq %r13, %rax
andq %rdi, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x420d5
movl %edx, -0x2c(%rbp)
movq %r13, %rdi
callq 0x4f838
movq %rax, %r13
cmpb $0x26, (%rax)
jne 0x42141
movq %r13, %rdi
leaq 0x1cf5a(%rip), %rsi     # 0x5efa2
callq 0x4920e
testl %eax, %eax
je 0x4217f
movq %r13, %rdi
leaq 0x27a45(%rip), %rsi     # 0x69aa4
callq 0x4920e
testl %eax, %eax
je 0x4219e
movq %r13, %rdi
leaq 0x27a74(%rip), %rsi     # 0x69aea
callq 0x4920e
testl %eax, %eax
je 0x421be
movq %r13, %rdi
leaq 0x279f7(%rip), %rsi     # 0x69a84
callq 0x4920e
testl %eax, %eax
je 0x42214
leaq -0x128(%rbp), %rdi
movq %r14, %rsi
callq 0x1bf5e
movq -0x118(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x128(%rbp), %xmm0
jmp 0x42163
xorl %esi, %esi
leaq 0x2799a(%rip), %rax     # 0x69a64
movq %rax, -0x48(%rbp)
xorl %eax, %eax
jmp 0x42249
movl %edx, %r13d
testq %rbx, %rbx
je 0x420e7
movl -0x4(%rbx), %eax
incl %eax
cmpl -0x8(%rbx), %eax
jl 0x420fc
movq %rbx, %rdi
movl $0x1, %esi
movl $0x18, %edx
callq 0x4c0b4
movq %rax, %rbx
movslq -0x4(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, -0x4(%rbx)
leaq (%rax,%rax,2), %r15
leaq -0xa0(%rbp), %rdi
movq %r14, %rsi
callq 0x1bf5e
movq -0x90(%rbp), %rax
movq %rax, 0x10(%rbx,%r15,8)
movups -0xa0(%rbp), %xmm0
movups %xmm0, (%rbx,%r15,8)
xorl %r9d, %r9d
movb $0x1, %sil
movb $0x1, %al
movl %r13d, %edx
jmp 0x4223b
leaq -0x110(%rbp), %rdi
movq %r14, %rsi
callq 0x1bf5e
movq -0x100(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0x110(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x1be97
xorl %r9d, %r9d
movb $0x1, %sil
movb $0x1, %al
jmp 0x42238
xorl %r9d, %r9d
movb $0x1, %sil
cmpl $0x0, -0x30(%rbp)
je 0x421de
movl $0x1, -0x30(%rbp)
leaq 0x278f2(%rip), %rax     # 0x69a8b
jmp 0x42232
xorl %r9d, %r9d
movb $0x1, %sil
cmpl $0x0, -0x4c(%rbp)
je 0x42262
movl $0x1, -0x4c(%rbp)
leaq 0x278ed(%rip), %rax     # 0x69aa9
jmp 0x42232
movb $0x1, %sil
cmpl $0x0, -0x30(%rbp)
je 0x422ad
xorl %r9d, %r9d
movl $0x1, -0x30(%rbp)
leaq 0x27914(%rip), %rax     # 0x69af0
jmp 0x42232
cmpq %r12, -0xb0(%rbp)
movl -0x2c(%rbp), %edx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
jne 0x42292
decl %edx
movb $0x1, %sil
movl $0x1, -0x64(%rbp)
movl $0x1, -0x30(%rbp)
jmp 0x422e9
cmpl $0x0, -0x30(%rbp)
je 0x4231a
xorl %r9d, %r9d
movb $0x1, %sil
movl $0x1, -0x30(%rbp)
leaq 0x278db(%rip), %rax     # 0x69b0d
movq %rax, -0x48(%rbp)
xorl %eax, %eax
movl -0x2c(%rbp), %edx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
testb %al, %al
je 0x42403
incq %r12
cmpq %r12, %r8
jne 0x41f28
jmp 0x4240c
xorl %r9d, %r9d
cmpq %r12, -0xb0(%rbp)
movl -0x2c(%rbp), %edx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
jne 0x422f0
movl $0x0, -0x4c(%rbp)
leaq 0x27832(%rip), %rax     # 0x69abf
jmp 0x420ca
xorl %r9d, %r9d
cmpq %r12, -0xa8(%rbp)
jne 0x42307
addl $-0x2, %edx
movb $0x1, %sil
movl $0x1, -0x30(%rbp)
jmp 0x422e2
xorl %r9d, %r9d
cmpq %r12, -0xa8(%rbp)
movl -0x2c(%rbp), %edx
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
jne 0x42365
addl $-0x2, %edx
movb $0x1, %sil
movl $0x1, -0x30(%rbp)
movl $0x1, -0x54(%rbp)
movl $0x1, -0x34(%rbp)
movb $0x1, %al
jmp 0x42249
decl %edx
movb $0x1, %sil
movl $0x1, -0x4c(%rbp)
movb $0x1, %al
movl %r12d, -0x50(%rbp)
jmp 0x42249
movl $0x0, -0x30(%rbp)
leaq 0x27776(%rip), %rax     # 0x69a8b
jmp 0x420ca
movl -0x2c(%rbp), %r15d
decl %r15d
movl $0xa, %edi
callq 0x47e96
movq %rax, -0x78(%rbp)
leaq -0xf8(%rbp), %rdi
movq %r14, %rsi
callq 0x1bf5e
movl %r15d, %edx
movb $0x1, %al
movl $0x1, -0x30(%rbp)
xorl %esi, %esi
movl $0x1, %r9d
movl $0x1, -0x54(%rbp)
movl $0x1, -0x34(%rbp)
jmp 0x4223b
movl $0x0, -0x30(%rbp)
leaq 0x2777d(%rip), %rax     # 0x69af0
jmp 0x420ca
leaq 0x27697(%rip), %rsi     # 0x69a16
movq %r14, %rdi
callq 0x1bc9e
movq %r14, %rdi
callq 0x1c045
movabsq $-0x77fffffffffff, %rdi # imm = 0xFFF8800000000001
callq 0x4f95a
movq -0xc8(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1bc4e
movq %r14, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x0, -0x70(%rbp)
movb $0x1, %al
movl %eax, -0x48(%rbp)
movl %r8d, -0x50(%rbp)
xorl %ebx, %ebx
movq $0x0, -0x60(%rbp)
movq $0x0, -0x78(%rbp)
movb $0x1, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl %r8d, -0x2c(%rbp)
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
jmp 0x42432
movq -0x48(%rbp), %rsi
jmp 0x4237f
movl %esi, -0x48(%rbp)
cmpl $0x0, -0x64(%rbp)
setne %al
movq %rax, -0x70(%rbp)
cmpl $0x0, -0x4c(%rbp)
movl %edx, -0x2c(%rbp)
movl -0x50(%rbp), %eax
cmovel %edx, %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x54(%rbp)
sete -0x30(%rbp)
testl %r8d, %r8d
jle 0x424f7
xorl %r12d, %r12d
leaq 0x1d58(%rip), %r13      # 0x4419d
xorl %r15d, %r15d
movq -0x80(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq %rsi, %rax
andq %rdi, %rax
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
je 0x424eb
testq %rbx, %rbx
je 0x42473
movl -0x4(%rbx), %eax
jmp 0x42475
xorl %eax, %eax
cmpl %r15d, %eax
jle 0x427eb
movslq %r15d, %rax
incl %r15d
leaq (%rax,%rax,2), %rax
movq 0x10(%rbx,%rax,8), %rcx
movq %rcx, -0x90(%rbp)
movups (%rbx,%rax,8), %xmm0
movaps %xmm0, -0xa0(%rbp)
movq 0x10(%rbx,%rax,8), %rcx
movq %rcx, 0x10(%rsp)
movups (%rbx,%rax,8), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x43a7e
movq -0x90(%rbp), %rax
movq %rax, 0x10(%rsp)
movaps -0xa0(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1be71
movabsq $-0x800000000000, %rdi  # imm = 0xFFFF800000000000
movq -0x40(%rbp), %r8
incq %r12
cmpq %r12, %r8
jne 0x42448
testq %rbx, %rbx
je 0x42508
addq $-0x8, %rbx
movq %rbx, %rdi
callq 0x2c187
cmpb $0x0, -0x48(%rbp)
movq -0xc0(%rbp), %rbx
movq -0xd8(%rbp), %r12
jne 0x4258d
movabsq $-0x3800000000000, %rsi # imm = 0xFFFC800000000000
movq -0x78(%rbp), %rdi
callq 0x4f9f2
movq -0xe8(%rbp), %rcx
movq %rcx, 0x10(%rsp)
movups -0xf8(%rbp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1c50(%rip), %rdx      # 0x4419d
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x43a7e
movq -0xe8(%rbp), %rax
movq %rax, 0x10(%rsp)
movups -0xf8(%rbp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x1be71
cmpq $0x0, -0x60(%rbp)
je 0x4258d
movq -0x60(%rbp), %rdi
addq $-0x8, %rdi
callq 0x2c187
testb $0x1, -0x70(%rbp)
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl -0x2c(%rbp), %ecx
cmovnel %eax, %ecx
cmpl $0x0, -0x34(%rbp)
cmovnel %eax, %ecx
movl %ecx, -0x80(%rbp)
movabsq $-0x5800000000000, %rax # imm = 0xFFFA800000000000
cmpq %rax, %rbx
jne 0x4265c
movq -0xb8(%rbp), %rdi
callq 0x4f838
movq %rax, %rbx
movq (%r14), %rax
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x425d9
movl -0x4(%rax), %ecx
jmp 0x425db
xorl %ecx, %ecx
testl %ecx, %ecx
jle 0x42603
movl %ecx, %ecx
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 0x425ee
testl %edi, %edi
jne 0x4265c
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1bf5e
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 0x21e42
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1be97
movq -0xd0(%rbp), %rcx
incl %ecx
cmpl %r12d, %ecx
jne 0x42679
movq %r14, %rdi
movl $0x4, %esi
callq 0x21a88
jmp 0x426ef
jge 0x426ef
leal -0x1(%r12), %r15d
movq %r12, %rax
movl %ecx, %r12d
movl %eax, %r13d
leaq -0xa0(%rbp), %rbx
cmpq %r12, %r15
movl $0x40000, %eax          # imm = 0x40000
movl $0x10000, %ecx          # imm = 0x10000
cmovel %ecx, %eax
movl %eax, -0x130(%rbp)
movq -0xe0(%rbp), %rax
movq (%rax,%r12,8), %rsi
movq -0x130(%rbp), %rax
movq %rax, 0x20(%rsp)
movups -0x150(%rbp), %xmm0
movups -0x140(%rbp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1ca05
cmpl $0x1, 0x48(%r14)
je 0x42387
incq %r12
cmpq %r12, %r13
jne 0x42690
movq %r14, %rdi
callq 0x1ddc8
movq %rax, %rbx
movl -0x2c(%rbp), %eax
movl %eax, 0x60(%rbx)
movl -0x50(%rbp), %eax
movl %eax, 0x64(%rbx)
movl -0x80(%rbp), %eax
movl %eax, 0x68(%rbx)
cmpl $0x0, -0x34(%rbp)
je 0x42716
orb $0x1, 0x5a(%rbx)
cmpb $0x0, -0x30(%rbp)
movq -0xc0(%rbp), %rax
jne 0x42727
orb $0x1, 0x5b(%rbx)
movabsq $-0x5000000000000, %rcx # imm = 0xFFFB000000000000
cmpq %rcx, %rax
je 0x42745
movabsq $-0x5800000000000, %rcx # imm = 0xFFFA800000000000
cmpq %rcx, %rax
jne 0x42755
movq -0xb8(%rbp), %rdi
callq 0x4f838
movq %rax, 0x48(%rbx)
leaq 0x10(%rbp), %r12
movq %rbx, %rdi
callq 0x1dd35
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4461a
movl %eax, %r15d
movl -0x2c(%rbp), %eax
addl -0x34(%rbp), %eax
cmpl 0x5c(%rbx), %eax
jle 0x4277d
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 -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x1c898
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 0x220fa
movups (%rbx), %xmm0
movq -0xc8(%rbp), %r14
movups %xmm0, (%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
jmp 0x423b0
callq 0x13f74