LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/lucvoo[P]sparse-dev/test-unssa.c
// Function: compile
static int compile(struct symbol_list *list)
{
	struct symbol *sym;
	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;
		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			output_fn(ep);
		else
			output_data(sym);
	}
	END_FOR_EACH_PTR(sym);

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xf898
leaq 0x397f7(%rip), %rbp     # 0x48e8a
movq (%rsp), %rdx
movzwl (%rdx), %eax
testb %al, %al
jle 0xf88a
xorl %esi, %esi
movq %rdx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rdx,%rsi,8), %r13
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf6c6
testq %r13, %r13
je 0xf86e
movq %r13, %rdi
callq 0xfb40
movq %r13, %rdi
callq 0x16657
movq %rax, %r14
leaq 0x59848(%rip), %rax     # 0x68f28
testb $0x10, (%rax)
je 0xf86e
testq %r14, %r14
je 0xf726
leaq 0x57ddb(%rip), %rax     # 0x674d0
movq (%rax), %r12
incq %r12
movq %r12, (%rax)
movq (%r14), %rbx
movq 0x18(%rbx), %rdi
callq 0x31039
testb $0x4, 0x68(%rbx)
jne 0xf76c
leaq 0x328f4(%rip), %rdi     # 0x4200b
movq %rax, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xe0f0
jmp 0xf77d
movq 0x18(%r13), %rdi
callq 0x31039
leaq 0x328e6(%rip), %rdi     # 0x4201c
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq 0x60(%r13), %rax
movzbl (%rax), %esi
leaq 0x328da(%rip), %rdi     # 0x42028
xorl %eax, %eax
callq 0xe0f0
movq 0x68(%r13), %rsi
leaq 0x328d4(%rip), %rdi     # 0x42034
xorl %eax, %eax
callq 0xe0f0
jmp 0xf86e
leaq 0x32891(%rip), %rdi     # 0x42004
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
movq %r14, %rdi
callq 0x32768
movq 0x18(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xf86e
movq 0x8(%rsp), %r15
movq %r12, 0x20(%rsp)
movzwl (%r15), %eax
testb %al, %al
jle 0xf85f
xorl %ebx, %ebx
movq 0x18(%r15,%rbx,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf7c7
testq %r14, %r14
je 0xf84c
cmpq %r12, 0x8(%r14)
je 0xf84c
movq %r12, 0x8(%r14)
movq %r14, %rdi
callq 0x14e31
movq %rax, %rdi
callq 0xe0a0
movq 0x28(%r14), %r12
testq %r12, %r12
je 0xf83d
movq %r12, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf834
xorl %r13d, %r13d
movq 0x18(%r14,%r13,8), %rdi
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf80c
testq %rdi, %rdi
je 0xf825
cmpq $0x0, 0x8(%rdi)
je 0xf825
callq 0x150d6
movq %rbp, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xe0f0
incq %r13
movl (%r14), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0xf7f8
movq 0x10(%r14), %r14
cmpq %r12, %r14
jne 0xf7ed
movl $0xa, %edi
callq 0xe040
movq 0x20(%rsp), %r12
incq %rbx
movl (%r15), %eax
movsbq %al, %rcx
cmpq %rcx, %rbx
jl 0xf7af
movq 0x10(%r15), %r15
cmpq 0x8(%rsp), %r15
jne 0xf7a1
movq 0x18(%rsp), %rsi
incq %rsi
movq 0x10(%rsp), %rdx
movl (%rdx), %eax
movsbq %al, %rcx
cmpq %rcx, %rsi
jl 0xf6a9
movq 0x10(%rdx), %rdx
cmpq (%rsp), %rdx
jne 0xf697
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/saulvargas[P]re-C-sys/test_pop.c
// Function: main
int main(int argc, char** argv) {
    FILE* user_data;
    FILE* item_data;
    int N_users;
    int N_items;
    int N_prefs;
    int binary;
    recdata_t* recdata;
    int uid;
    int i;
    recommender_t* recommender;
    idpairs_t* pairs;

    if (!read_args(argc, argv, &user_data, &item_data, &N_users, &N_items, &N_prefs, &binary)) {
        return EXIT_FAILURE;
    }

    recdata = recdata_simple_create(user_data, item_data, N_users, N_items, N_prefs, binary);
    
    fclose(user_data);
    fclose(item_data);

    recommender = recommender_pop_create(recdata);

    for (uid = 0; uid < recdata->N_users; uid++) {
        pairs = recommender_recommend(recommender, uid, 100);

        for (i = 0; i < idpairs_size(pairs); i++) {
            printf("%d\t%d\t%.4f\n", uid, idpairs_keys(pairs)[i], idpairs_values(pairs)[i]);
        }
        
        idpairs_close_deep(pairs);
    }
 
    recommender_close(recommender);
 
    recdata_close(recdata);
    
    return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsp, %rax
leaq 0x4(%rsp), %r10
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0xc(%rsp), %r8
leaq 0x8(%rsp), %r9
pushq %rax
pushq %r10
callq 0x2608
addq $0x10, %rsp
testl %eax, %eax
je 0x1325
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %ecx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq 0x166e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0x1060
movq 0x18(%rsp), %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x2762
movq %rax, %r14
movq %rbx, 0x10(%rsp)
cmpl $0x0, (%rbx)
jle 0x130f
xorl %r15d, %r15d
leaq 0x1d64(%rip), %r12      # 0x3004
movq %r14, %rdi
movl %r15d, %esi
movl $0x64, %edx
callq 0x204c
movq %rax, %r13
movq %rax, %rdi
callq 0x2525
testl %eax, %eax
jle 0x12fa
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x2528
movl (%rax,%rbx,4), %ebp
movq %r13, %rdi
callq 0x252d
movsd (%rax,%rbx,8), %xmm0
movq %r12, %rdi
movl %r15d, %esi
movl %ebp, %edx
movb $0x1, %al
callq 0x1080
incq %rbx
movq %r13, %rdi
callq 0x2525
cltq
cmpq %rax, %rbx
jl 0x12c1
movq %r13, %rdi
callq 0x2501
incl %r15d
movq 0x10(%rsp), %rax
cmpl (%rax), %r15d
jl 0x12a0
movq %r14, %rdi
callq 0x212e
movq 0x10(%rsp), %rdi
callq 0x1374
xorl %eax, %eax
jmp 0x132a
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: advance
static void
advance(FILE *in,FILE *out,RRA *h)
    {
    int i;
    int start = SamplesWritten;
    int more = replace(in,out,h);
    int thresholdReached = 0;
    int peak = 0;

    //printf("advancing\n");
    while (more && !(thresholdReached && peek(0) == 0 && peek(1) > 0))
        {
        if (abs(peek(0)) > peak) peak = abs(peek(0));
        if (thresholdReached == 0 && peak > AbsoluteThreshold)
            thresholdReached = 1;
        //printf("while advancing, first amp is %d\n",peek(0));
        //printf("while advancing, second amp is %d\n",peek(1));
        //printf("while advancing, thresholdReached is %d\n",thresholdReached);
        more = replace(in,out,h);
        }

    //printf("after advance, first amp is %d\n",peek(0));
    //printf("after advance, second amp is %d\n",peek(1));
    //printf("more: %d\n",more);
    //printf("thresholdReached: %d\n",thresholdReached);

    if (!more)
        {
        //printf("dumping the window, stored = %d\n",SamplesStored);
        int count = SamplesStored;
        for (i = 0; i < count; ++i)
            replace(in,out,h);
        //printf("done dumping the window, stored = %d\n",SamplesStored);
        }

    if (Report)
        fprintf(ReportFP,"no repitching of cycle with length %d, peak was %d\n",
            SamplesWritten - start,peak);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x6231(%rip), %eax      # 0x9964
movl %eax, -0x2c(%rbp)
callq 0x3824
xorl %ebx, %ebx
testl %eax, %eax
je 0x37bf
xorl %r13d, %r13d
testb $0x1, %r13b
je 0x377b
movq 0x6207(%rip), %rsi      # 0x9958
movl 0x6221(%rip), %ecx      # 0x9978
movl 0x61eb(%rip), %edi      # 0x9948
movl %ecx, %eax
cltd
idivl %edi
movslq %edx, %rax
cmpl $0x0, (%rsi,%rax,4)
jne 0x377b
incl %ecx
movl %ecx, %eax
cltd
idivl %edi
movslq %edx, %rax
cmpl $0x0, (%rsi,%rax,4)
jg 0x37de
movq 0x61d6(%rip), %rcx      # 0x9958
movl 0x61f0(%rip), %eax      # 0x9978
cltd
idivl 0x61b9(%rip)            # 0x9948
movslq %edx, %rax
movl (%rcx,%rax,4), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl %ebx, %ecx
cmovgl %ecx, %ebx
cmpl 0x61a5(%rip), %ebx      # 0x994c
setg %al
orb %al, %r13b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3824
testl %eax, %eax
jne 0x3744
movl 0x61aa(%rip), %r13d     # 0x9970
testl %r13d, %r13d
jle 0x37de
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3824
decl %r13d
jne 0x37cb
cmpb $0x1, 0x613f(%rip)      # 0x9924
jne 0x3815
movq 0x613a(%rip), %rdi      # 0x9928
movl 0x6170(%rip), %edx      # 0x9964
subl -0x2c(%rbp), %edx
leaq 0x2c2a(%rip), %rsi      # 0x6428
movl %ebx, %ecx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2170
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: replace
static int 
replace(FILE *in,FILE *out,RRA *h)
    {
    int amp;
    fprintf(out,"%d\n",Window[WindowStart]);
    ++SamplesWritten;
    WindowStart = (WindowStart + 1) % WindowSize;
    --SamplesStored;
    amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
    if (!feof(in))
        {
        ++SamplesRead;
        ++SamplesStored;
        Window[WindowEnd] = amp;
        WindowEnd = (WindowEnd + 1) % WindowSize;
        return 1;
        }
    else
        {
        return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x6119(%rip), %rax      # 0x9958
movslq 0x6132(%rip), %rcx      # 0x9978
movl (%rax,%rcx,4), %edx
leaq 0x3355(%rip), %rsi      # 0x6ba5
xorl %ebx, %ebx
movq %r15, %rdi
xorl %eax, %eax
callq 0x2170
incl 0x6102(%rip)            # 0x9964
movl 0x6110(%rip), %eax      # 0x9978
incl %eax
cltd
idivl 0x60d7(%rip)            # 0x9948
movl %edx, 0x6101(%rip)      # 0x9978
decl 0x60f3(%rip)            # 0x9970
movl 0x8(%r12), %edx
leaq 0x149c(%rip), %rcx      # 0x4d25
movq %r14, %rdi
movq %r15, %rsi
callq 0x44f4
movl %eax, %r15d
movq %r14, %rdi
callq 0x2190
testl %eax, %eax
jne 0x38d6
incl 0x60b7(%rip)            # 0x9960
incl 0x60c1(%rip)            # 0x9970
movq 0x60a2(%rip), %rax      # 0x9958
movslq 0x60b7(%rip), %rcx      # 0x9974
movl %r15d, (%rax,%rcx,4)
leal 0x1(%rcx), %eax
cltd
idivl 0x607d(%rip)            # 0x9948
movl %edx, 0x60a3(%rip)      # 0x9974
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: main.cold.6
static void usage(void)
{
	fprintf(stderr, "Usage: mujs [options] [script [scriptArgs*]]\n");
	fprintf(stderr, "\t-i: Enter interactive prompt after running code.\n");
	fprintf(stderr, "\t-s: Check strictness.\n");
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x3caf4(%rip), %r14     # 0x3ffe8
movq (%r14), %rcx
leaq 0x27bb9(%rip), %rdi     # 0x2b0b7
pushq $0x2d
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x3350
movq (%r14), %rcx
leaq 0x27bcf(%rip), %rdi     # 0x2b0e5
pushq $0x32
popq %rsi
movq %rbx, %rdx
callq 0x3350
movq (%r14), %rcx
leaq 0x27bed(%rip), %rdi     # 0x2b118
pushq $0x17
popq %rsi
movq %rbx, %rdx
callq 0x3350
pushq $0x1
popq %rdi
callq 0x3120
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: jsB_load
static void jsB_load(js_State *J)
{
	int i, n = js_gettop(J);
	for (i = 1; i < n; ++i) {
		js_loadfile(J, js_tostring(J, i));
		js_pushundefined(J);
		js_call(J, 0);
		js_pop(J, 1);
	}
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x157e3
cmpl $0x2, %eax
jl 0x3cb3
movl %eax, %ebp
movl $0x1, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14963
movq %rbx, %rdi
movq %rax, %rsi
callq 0x17b6e
movq %rbx, %rdi
callq 0x89b6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16c25
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4127
incl %r14d
cmpl %r14d, %ebp
jne 0x3c76
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x89b6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: jsB_print
static void jsB_print(js_State *J)
{
	int i, top = js_gettop(J);
	for (i = 1; i < top; ++i) {
		const char *s = js_tostring(J, i);
		if (i > 1) putchar(' ');
		fputs(s, stdout);
	}
	putchar('\n');
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x157e3
cmpl $0x2, %eax
jl 0x3d65
movl %eax, %ebp
movl $0x1, %r14d
movq 0x3c2c5(%rip), %r12     # 0x3fff8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14963
movq %rax, %r15
cmpl $0x2, %r14d
jb 0x3d51
movl $0x20, %edi
callq 0x3150
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3280
incl %r14d
cmpl %r14d, %ebp
jne 0x3d33
movl $0xa, %edi
callq 0x3150
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x89b6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: jsB_write
static void jsB_write(js_State *J)
{
	int i, top = js_gettop(J);
	for (i = 1; i < top; ++i) {
		const char *s = js_tostring(J, i);
		if (i > 1) putchar(' ');
		fputs(s, stdout);
	}
	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x157e3
cmpl $0x2, %eax
jl 0x3dd5
movl %eax, %ebp
movl $0x1, %r14d
movq 0x3c255(%rip), %r12     # 0x3fff8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14963
movq %rax, %r15
cmpl $0x2, %r14d
jb 0x3dc1
movl $0x20, %edi
callq 0x3150
movq (%r12), %rsi
movq %r15, %rdi
callq 0x3280
incl %r14d
cmpl %r14d, %ebp
jne 0x3da3
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x89b6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: jsB_read
static void jsB_read(js_State *J)
{
	const char *filename = js_tostring(J, 1);
	FILE *f;
	char *s;
	int n, t;

	f = fopen(filename, "rb");
	if (!f) {
		js_error(J, "cannot open file '%s': %s", filename, strerror(errno));
	}

	if (fseek(f, 0, SEEK_END) < 0) {
		fclose(f);
		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
	}

	n = ftell(f);
	if (n < 0) {
		fclose(f);
		js_error(J, "cannot tell in file '%s': %s", filename, strerror(errno));
	}

	if (fseek(f, 0, SEEK_SET) < 0) {
		fclose(f);
		js_error(J, "cannot seek in file '%s': %s", filename, strerror(errno));
	}

	s = malloc(n + 1);
	if (!s) {
		fclose(f);
		js_error(J, "out of memory");
	}

	t = fread(s, 1, n, f);
	if (t != n) {
		free(s);
		fclose(f);
		js_error(J, "cannot read data from file '%s': %s", filename, strerror(errno));
	}
	s[n] = 0;

	js_pushstring(J, s);
	free(s);
	fclose(f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0x14963
movq %rax, %r14
leaq 0x27332(%rip), %rsi     # 0x2b139
movq %rax, %rdi
callq 0x3180
testq %rax, %rax
je 0x3edd
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3110
testl %eax, %eax
js 0x3ec0
movq %r15, %rdi
callq 0x3070
movq %rax, %r12
testl %r12d, %r12d
js 0x3ef2
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3110
testl %eax, %eax
js 0x3ec0
leal 0x1(%r12), %edi
callq 0x3170
testq %rax, %rax
je 0x3f0f
movq %rax, %r13
movl %r12d, %ebp
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
movl $0x1, %esi
movq %rax, %rdi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x32c0
cmpl %r12d, %eax
jne 0x3f28
movb $0x0, (%r13,%rbp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x13665
movq %r13, %rdi
callq 0x31e0
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3330
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x2727b(%rip), %rsi     # 0x2b156
jmp 0x3f4b
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x2724c(%rip), %rsi     # 0x2b13c
jmp 0x3f4b
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x27266(%rip), %rsi     # 0x2b173
jmp 0x3f4b
movq %r15, %rdi
callq 0x3330
leaq 0x27272(%rip), %rsi     # 0x2b190
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
movq %r13, %rdi
callq 0x31e0
movq %r15, %rdi
callq 0x3330
callq 0x32d0
movl (%rax), %edi
callq 0x3250
leaq 0x27253(%rip), %rsi     # 0x2b19e
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/main.c
// Function: jsB_readline
static void jsB_readline(js_State *J)
{
	char *line = readline("");
	if (!line) {
		js_pushnull(J);
		return;
	}
	js_pushstring(J, line);
	if (*line)
		add_history(line);
	free(line);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x3041d(%rip), %rdi     # 0x34386
callq 0x32e0
testq %rax, %rax
je 0x3f9d
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x13665
cmpb $0x0, (%rbx)
je 0x3f8e
movq %rbx, %rdi
callq 0x3390
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x31e0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x13525
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: js_getlength
int js_getlength(js_State *J, int idx)
{
	int len;
	js_getproperty(J, idx, "length");
	len = js_tointeger(J, -1);
	js_pop(J, 1);
	return len;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x11c37
leaq 0x2f775(%rip), %rdx     # 0x33751
movq %rbx, %rdi
movq %rax, %rsi
callq 0x16778
testl %eax, %eax
jne 0x3ff3
movq %rbx, %rdi
callq 0x89b6
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x409b
movl 0x140(%rbx), %edx
movl 0x144(%rbx), %ecx
leal -0x1(%rdx), %esi
movl %esi, 0x140(%rbx)
cmpl %ecx, %edx
jle 0x401b
popq %rbx
retq
movl %ecx, 0x140(%rbx)
leaq 0x2f746(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_pop
void js_pop(js_State *J, int n)
{
	TOP -= n;
	if (TOP < BOT) {
		TOP = BOT;
		js_error(J, "stack underflow!");
	}
}

// Assembly:
movl 0x140(%rdi), %ecx
movl 0x144(%rdi), %eax
subl %esi, %ecx
movl %ecx, 0x140(%rdi)
cmpl %eax, %ecx
jl 0x4140
retq
pushq %rax
movl %eax, 0x140(%rdi)
leaq 0x2f620(%rip), %rsi     # 0x3376e
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_pushnumber
void js_pushnumber(js_State *J, double v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TNUMBER;
	STACK[TOP].u.number = v;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x41c1
shlq $0x4, %rax
movb $0x4, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movsd %xmm0, (%rax,%rcx)
incl 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x30ec2(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsrun.c
// Function: js_pushobject
void js_pushobject(js_State *J, js_Object *v)
{
	CHECKSTACK(1);
	STACK[TOP].t.type = JS_TOBJECT;
	STACK[TOP].u.object = v;
	++TOP;
}

// Assembly:
movslq 0x140(%rdi), %rax
movq 0x148(%rdi), %rcx
cmpq $0xfff, %rax            # imm = 0xFFF
jge 0x4523
shlq $0x4, %rax
movb $0x7, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
movq %rsi, (%rax,%rcx)
incl 0x140(%rdi)
retq
pushq %rax
shlq $0x4, %rax
movb $0x5, 0xf(%rcx,%rax)
movq 0x148(%rdi), %rax
movslq 0x140(%rdi), %rcx
shlq $0x4, %rcx
leaq 0x30b60(%rip), %rdx     # 0x350a6
movq %rdx, (%rax,%rcx)
incl 0x140(%rdi)
callq 0x8ec6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsbuiltin.c
// Function: jsB_propf
void jsB_propf(js_State *J, const char *name, js_CFunction cfun, int n)
{
	const char *pname = strrchr(name, '.');
	pname = pname ? pname + 1 : name;
	js_newcfunction(J, cfun, name, n);
	js_defproperty(J, -2, pname, JS_DONTENUM);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rsi, %rdi
movl $0x2e, %esi
callq 0x3240
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r15, %r13
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1a7e0
movq %r12, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movq %r13, %rdx
movl $0x2, %ecx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x66df
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_toString
static void Ap_toString(js_State *J)
{
	if (!js_iscoercible(J, 0))
		js_typeerror(J, "'this' is not an object");
	js_getproperty(J, 0, "join");
	if (!js_iscallable(J, -1)) {
		js_pop(J, 1);
		/* TODO: call Object.prototype.toString implementation directly */
		js_getglobal(J, "Object");
		js_getproperty(J, -1, "prototype");
		js_rot2pop1(J);
		js_getproperty(J, -1, "toString");
		js_rot2pop1(J);
	}
	js_copy(J, 0);
	js_call(J, 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq 0x144(%rdi), %rax
leaq 0x3be31(%rip), %rcx     # 0x403f8
testq %rax, %rax
js 0x45e2
cmpl 0x140(%rbx), %eax
jge 0x45e2
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rcx
movb 0xf(%rcx), %al
decb %al
cmpb $0x1, %al
jbe 0x46c2
leaq 0x2e456(%rip), %rdx     # 0x32a4c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4032
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x14e17
testl %eax, %eax
jne 0x46ad
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x46d3
leaq 0x2ef04(%rip), %rsi     # 0x3353d
movq %rbx, %rdi
callq 0x163ed
leaq 0x2eb5c(%rip), %rdx     # 0x331a4
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4032
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
leaq 0x2e634(%rip), %rdx     # 0x32cb2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4032
movq 0x148(%rbx), %rax
movslq 0x140(%rbx), %rcx
shlq $0x4, %rcx
movups -0x10(%rax,%rcx), %xmm0
movups %xmm0, -0x20(%rax,%rcx)
decl 0x140(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x16c25
leaq 0x2f560(%rip), %rsi     # 0x33c29
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
movl %eax, 0x140(%rbx)
leaq 0x2f08e(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_concat
static void Ap_concat(js_State *J)
{
	int i, top = js_gettop(J);
	int n, k, len;

	js_newarray(J);
	n = 0;

	for (i = 0; i < top; ++i) {
		js_copy(J, i);
		if (js_isarray(J, -1)) {
			len = js_getlength(J, -1);
			for (k = 0; k < len; ++k)
				if (js_hasindex(J, -1, k))
					js_setindex(J, -3, n++);
			js_pop(J, 1);
		} else {
			js_setindex(J, -2, n++);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
callq 0x135de
testl %r12d, %r12d
jle 0x481b
xorl %ebp, %ebp
xorl %r14d, %r14d
movl %r12d, 0x4(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x14073
movslq 0x140(%rbx), %rcx
leaq 0x3bcc2(%rip), %rax     # 0x403f8
testq %rcx, %rcx
jle 0x474d
movq 0x148(%rbx), %rax
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
cmpb $0x7, 0xf(%rax)
jne 0x47f9
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x47f9
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3fcc
testl %eax, %eax
jle 0x47d9
movl %eax, %r15d
xorl %r12d, %r12d
movslq 0x140(%rbx), %rax
leaq 0x3bc70(%rip), %rsi     # 0x403f8
testq %rax, %rax
jle 0x47a0
movq 0x148(%rbx), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r12d, %edx
callq 0x16a4d
testl %eax, %eax
je 0x47d1
leal 0x1(%r14), %r13d
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %r14d, %edx
callq 0x1393c
movl %r13d, %r14d
incl %r12d
cmpl %r12d, %r15d
jne 0x477a
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
movl 0x4(%rsp), %r12d
jg 0x4810
jmp 0x482a
leal 0x1(%r14), %r15d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r14d, %edx
callq 0x1393c
movl %r15d, %r14d
incl %ebp
cmpl %r12d, %ebp
jne 0x471e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x2ef37(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_pop
static void Ap_pop(js_State *J)
{
	int n;

	n = js_getlength(J, 0);

	if (n > 0) {
		js_getindex(J, 0, n - 1);
		js_delindex(J, 0, n - 1);
		js_setlength(J, 0, n - 1);
	} else {
		js_setlength(J, 0, 0);
		js_pushundefined(J);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3fcc
testl %eax, %eax
jle 0x4b65
movl %eax, %ebp
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x169fb
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16b45
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x2ebfc(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x41f3
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x2ebda(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41f3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x89b6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_push
static void Ap_push(js_State *J)
{
	int i, top = js_gettop(J);
	int n;

	n = js_getlength(J, 0);

	for (i = 1; i < top; ++i, ++n) {
		js_copy(J, i);
		js_setindex(J, 0, n);
	}

	js_setlength(J, 0, n);

	js_pushnumber(J, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r15d
subl 0x144(%rdi), %r15d
xorl %esi, %esi
callq 0x3fcc
movl %eax, %ebp
cmpl $0x2, %r15d
jl 0x4bdd
movl $0x1, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x14073
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1393c
incl %r14d
incl %ebp
cmpl %r14d, %r15d
jne 0x4bbc
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x4184
leaq 0x2eb5c(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41f3
movq %rbx, %rdi
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_reverse
static void Ap_reverse(js_State *J)
{
	int len, middle, lower;

	len = js_getlength(J, 0);
	middle = len / 2;
	lower = 0;

	while (lower != middle) {
		int upper = len - lower - 1;
		int haslower = js_hasindex(J, 0, lower);
		int hasupper = js_hasindex(J, 0, upper);
		if (haslower && hasupper) {
			js_setindex(J, 0, lower);
			js_setindex(J, 0, upper);
		} else if (hasupper) {
			js_setindex(J, 0, lower);
			js_delindex(J, 0, upper);
		} else if (haslower) {
			js_setindex(J, 0, upper);
			js_delindex(J, 0, lower);
		}
		++lower;
	}

	js_copy(J, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x3fcc
movl %eax, %r14d
leal 0x1(%r14), %eax
cmpl $0x3, %eax
jb 0x4d3c
movl %r14d, %r12d
shrl $0x1f, %r12d
addl %r14d, %r12d
sarl %r12d
decl %r14d
leaq 0x3b7a4(%rip), %r13     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r13, %rsi
testq %rax, %rax
js 0x4c7c
movq %r13, %rsi
cmpl 0x140(%rbx), %eax
jge 0x4c7c
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
movl %eax, %r15d
movslq 0x144(%rbx), %rax
movq %r13, %rsi
testq %rax, %rax
js 0x4cbc
movq %r13, %rsi
cmpl 0x140(%rbx), %eax
jge 0x4cbc
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x16a4d
testl %r15d, %r15d
je 0x4cf6
testl %eax, %eax
je 0x4cf6
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1393c
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x1393c
jmp 0x4d2e
testl %eax, %eax
je 0x4d10
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1393c
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
jmp 0x4d29
testl %r15d, %r15d
je 0x4d2e
movq %rbx, %rdi
xorl %esi, %esi
movl %r14d, %edx
callq 0x1393c
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16b45
incl %ebp
decl %r14d
cmpl %ebp, %r12d
jne 0x4c54
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14073
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_shift
static void Ap_shift(js_State *J)
{
	int k, len;

	len = js_getlength(J, 0);

	if (len == 0) {
		js_setlength(J, 0, 0);
		js_pushundefined(J);
		return;
	}

	js_getindex(J, 0, 0);

	for (k = 1; k < len; ++k) {
		if (js_hasindex(J, 0, k))
			js_setindex(J, 0, k - 1);
		else
			js_delindex(J, 0, k - 1);
	}

	js_delindex(J, 0, len - 1);
	js_setlength(J, 0, len - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3fcc
testl %eax, %eax
je 0x4e21
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x169fb
cmpl $0x2, %ebp
jl 0x4dec
movl $0x1, %r14d
leaq 0x3b66b(%rip), %r15     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r15, %rsi
testq %rax, %rax
js 0x4db5
movq %r15, %rsi
cmpl 0x140(%rbx), %eax
jge 0x4db5
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x16a4d
leal -0x1(%r14), %edx
movq %rbx, %rdi
xorl %esi, %esi
testl %eax, %eax
je 0x4ddf
callq 0x1393c
jmp 0x4de4
callq 0x16b45
incl %r14d
cmpl %r14d, %ebp
jne 0x4d8d
decl %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x16b45
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x2e944(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x41f3
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x2e91e(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41f3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x89b6
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_slice
static void Ap_slice(js_State *J)
{
	int len, s, e, n;
	double sv, ev;

	js_newarray(J);

	len = js_getlength(J, 0);
	sv = js_tointeger(J, 1);
	ev = js_isdefined(J, 2) ? js_tointeger(J, 2) : len;

	if (sv < 0) sv = sv + len;
	if (ev < 0) ev = ev + len;

	s = sv < 0 ? 0 : sv > len ? len : sv;
	e = ev < 0 ? 0 : ev > len ? len : ev;

	for (n = 0; s < e; ++s, ++n)
		if (js_hasindex(J, 0, s))
			js_setindex(J, -2, n);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x135de
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
movl %eax, %ebp
movq %rbx, %rdi
movl $0x1, %esi
callq 0x409b
movl %eax, %r14d
movl 0x144(%rbx), %ecx
leaq 0x3b56d(%rip), %rax     # 0x403f8
cmpl $-0x2, %ecx
jl 0x4ea8
addl $0x2, %ecx
cmpl 0x140(%rbx), %ecx
jge 0x4ea8
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
movl %ebp, %eax
je 0x4ebd
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
cvtsi2sd %r14d, %xmm2
cvtsi2sd %ebp, %xmm0
movsd 0x26572(%rip), %xmm3    # 0x2b440
movapd %xmm0, %xmm1
testl %r14d, %r14d
js 0x4edb
movapd %xmm3, %xmm1
addsd %xmm2, %xmm1
cvtsi2sd %eax, %xmm4
movapd %xmm0, %xmm2
testl %eax, %eax
js 0x4eef
movapd %xmm3, %xmm2
addsd %xmm4, %xmm2
xorl %r15d, %r15d
xorpd %xmm3, %xmm3
ucomisd %xmm1, %xmm3
movl $0x0, %r12d
ja 0x4f13
movapd %xmm0, %xmm4
minsd %xmm1, %xmm4
cvttsd2si %xmm4, %r12d
ucomisd %xmm2, %xmm3
ja 0x4f22
minsd %xmm2, %xmm0
cvttsd2si %xmm0, %r15d
subl %r12d, %r15d
jle 0x4f8e
xorl %r14d, %r14d
leaq 0x3b4c7(%rip), %r13     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r13, %rsi
testq %rax, %rax
js 0x4f59
movq %r13, %rsi
cmpl 0x140(%rbx), %eax
jge 0x4f59
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
leal (%r12,%r14), %ebp
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
testl %eax, %eax
je 0x4f86
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r14d, %edx
callq 0x1393c
incl %r14d
cmpl %r14d, %r15d
jne 0x4f31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_sort
static void Ap_sort(js_State *J)
{
	int len;

	len = js_getlength(J, 0);
	if (len <= 1) {
		js_copy(J, 0);
		return;
	}

	if (!js_iscallable(J, 1) && !js_isundefined(J, 1))
		js_typeerror(J, "comparison function must be a function or undefined");

	if (len >= INT_MAX)
		js_rangeerror(J, "array is too large to sort");

	Ap_sort_heapsort(J, len);

	js_copy(J, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3fcc
cmpl $0x2, %eax
jl 0x504c
movl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14e17
testl %eax, %eax
jne 0x4ffa
movl 0x144(%rbx), %ecx
leaq 0x3b420(%rip), %rax     # 0x403f8
cmpl $-0x1, %ecx
jl 0x4ff4
incl %ecx
cmpl 0x140(%rbx), %ecx
jge 0x4ff4
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
jne 0x5071
cmpl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
je 0x5060
movl %r14d, %r15d
shrl %r15d
incl %r15d
leal -0x2(%r15), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x1cb76
decl %r15d
cmpl $0x1, %r15d
jg 0x500c
incl %r14d
leal -0x2(%r14), %ebp
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1cc16
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x1cb76
decl %r14d
cmpl $0x2, %r14d
jg 0x5027
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14073
leaq 0x2ec10(%rip), %rsi     # 0x33c77
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcab5
leaq 0x2ebcb(%rip), %rsi     # 0x33c43
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_unshift
static void Ap_unshift(js_State *J)
{
	int i, top = js_gettop(J);
	int k, len;

	len = js_getlength(J, 0);

	for (k = len; k > 0; --k) {
		int from = k - 1;
		int to = k + top - 2;
		if (js_hasindex(J, 0, from))
			js_setindex(J, 0, to);
		else
			js_delindex(J, 0, to);
	}

	for (i = 1; i < top; ++i) {
		js_copy(J, i);
		js_setindex(J, 0, i - 1);
	}

	js_setlength(J, 0, len + top - 1);

	js_pushnumber(J, len + top - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r12d
subl 0x144(%rdi), %r12d
xorl %esi, %esi
callq 0x3fcc
movq %rax, (%rsp)
testl %eax, %eax
jle 0x545f
movq (%rsp), %rax
leal 0x1(%rax), %r13d
leaq 0x3b002(%rip), %r14     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r14, %rsi
testq %rax, %rax
js 0x541e
movq %r14, %rsi
cmpl 0x140(%rbx), %eax
jge 0x541e
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
leal -0x2(%r13), %r15d
leal (%r12,%r13), %ebp
addl $-0x3, %ebp
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r15d, %edx
callq 0x16a4d
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %edx
testl %eax, %eax
je 0x5451
callq 0x1393c
jmp 0x5456
callq 0x16b45
decl %r13d
cmpl $0x1, %r13d
jg 0x53f6
cmpl $0x2, %r12d
jl 0x548c
movl $0x1, %r15d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x14073
leal -0x1(%r15), %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1393c
incl %r15d
cmpl %r12d, %r15d
jne 0x546b
movq (%rsp), %rax
addl %r12d, %eax
decl %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x4184
leaq 0x2e2a4(%rip), %rdx     # 0x33751
movq %rbx, %rdi
xorl %esi, %esi
callq 0x41f3
movq %rbx, %rdi
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4184
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_indexOf
static void Ap_indexOf(js_State *J)
{
	int k, len, from;

	len = js_getlength(J, 0);
	from = js_isdefined(J, 2) ? js_tointeger(J, 2) : 0;
	if (from < 0) from = len + from;
	if (from < 0) from = 0;

	js_copy(J, 1);
	for (k = from; k < len; ++k) {
		if (js_hasindex(J, 0, k)) {
			if (js_strictequal(J)) {
				js_pushnumber(J, k);
				return;
			}
			js_pop(J, 1);
		}
	}

	js_pushnumber(J, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x3fcc
movl %eax, %ebp
movl 0x144(%rbx), %ecx
leaq 0x3af03(%rip), %rax     # 0x403f8
cmpl $-0x2, %ecx
jl 0x5512
addl $0x2, %ecx
cmpl 0x140(%rbx), %ecx
jge 0x5512
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
je 0x5528
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
movl %eax, %r14d
movl %r14d, %eax
sarl $0x1f, %eax
andl %ebp, %eax
addl %r14d, %eax
xorl %r14d, %r14d
testl %eax, %eax
cmovgl %eax, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
movsd 0x25ef7(%rip), %xmm0    # 0x2b448
cmpl %ebp, %r14d
jge 0x55e2
leaq 0x3ae97(%rip), %r15     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r15, %rsi
testq %rax, %rax
js 0x5589
movq %r15, %rsi
cmpl 0x140(%rbx), %eax
jge 0x5589
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x16a4d
testl %eax, %eax
je 0x55c8
movq %rbx, %rdi
callq 0x1b33a
testl %eax, %eax
jne 0x55da
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x55f4
incl %r14d
cmpl %r14d, %ebp
jne 0x5561
movsd 0x25e70(%rip), %xmm0    # 0x2b448
jmp 0x55e2
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4184
movl %eax, 0x140(%rbx)
leaq 0x2e16d(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_lastIndexOf
static void Ap_lastIndexOf(js_State *J)
{
	int k, len, from;

	len = js_getlength(J, 0);
	from = js_isdefined(J, 2) ? js_tointeger(J, 2) : len - 1;
	if (from > len - 1) from = len - 1;
	if (from < 0) from = len + from;

	js_copy(J, 1);
	for (k = from; k >= 0; --k) {
		if (js_hasindex(J, 0, k)) {
			if (js_strictequal(J)) {
				js_pushnumber(J, k);
				return;
			}
			js_pop(J, 1);
		}
	}

	js_pushnumber(J, -1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3fcc
movl %eax, %r15d
movl 0x144(%rbx), %ecx
leaq 0x3adcc(%rip), %rax     # 0x403f8
cmpl $-0x2, %ecx
jl 0x5649
addl $0x2, %ecx
cmpl 0x140(%rbx), %ecx
jge 0x5649
movl %ecx, %eax
shlq $0x4, %rax
addq 0x148(%rbx), %rax
cmpb $0x1, 0xf(%rax)
jne 0x5655
leal -0x1(%r15), %eax
jmp 0x5662
movq %rbx, %rdi
movl $0x2, %esi
callq 0x409b
leal -0x1(%r15), %ebp
cmpl %r15d, %eax
cmovll %eax, %ebp
movl %ebp, %r14d
sarl $0x1f, %r14d
andl %r15d, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
addl %ebp, %r14d
movsd 0x25dba(%rip), %xmm0    # 0x2b448
js 0x5720
leaq 0x3ad5d(%rip), %r15     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r15, %rsi
testq %rax, %rax
js 0x56c3
movq %r15, %rsi
cmpl 0x140(%rbx), %eax
jge 0x56c3
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x16a4d
testl %eax, %eax
je 0x5702
movq %rbx, %rdi
callq 0x1b33a
testl %eax, %eax
jne 0x5718
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x5732
leal -0x1(%r14), %eax
testl %r14d, %r14d
movl %eax, %r14d
jg 0x569b
movsd 0x25d32(%rip), %xmm0    # 0x2b448
jmp 0x5720
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4184
movl %eax, 0x140(%rbx)
leaq 0x2e02f(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_every
static void Ap_every(js_State *J)
{
	int hasthis = js_gettop(J) >= 3;
	int k, len;

	if (!js_iscallable(J, 1))
		js_typeerror(J, "callback is not a function");

	len = js_getlength(J, 0);
	for (k = 0; k < len; ++k) {
		if (js_hasindex(J, 0, k)) {
			js_copy(J, 1);
			if (hasthis)
				js_copy(J, 2);
			else
				js_pushundefined(J);
			js_copy(J, -3);
			js_pushnumber(J, k);
			js_copy(J, 0);
			js_call(J, 3);
			if (!js_toboolean(J, -1))
				return;
			js_pop(J, 2);
		}
	}

	js_pushboolean(J, 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %r15d
subl 0x144(%rdi), %r15d
movl $0x1, %esi
callq 0x14e17
testl %eax, %eax
je 0x58c4
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
testl %eax, %eax
jle 0x5883
movl %eax, %r14d
leaq 0x3ac63(%rip), %r12     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r12, %rsi
testq %rax, %rax
js 0x57bd
movq %r12, %rsi
cmpl 0x140(%rbx), %eax
jge 0x57bd
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
testl %eax, %eax
je 0x5878
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
movq %rbx, %rdi
cmpl $0x3, %r15d
jl 0x57fc
movl $0x2, %esi
callq 0x14073
jmp 0x5801
callq 0x89b6
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x14073
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
movl $0x3, %esi
callq 0x16c25
movslq 0x140(%rbx), %r13
movq %r12, %rsi
testq %r13, %r13
jle 0x5859
movq 0x148(%rbx), %rax
movq %r13, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
callq 0x150c0
testl %eax, %eax
je 0x589e
addl $-0x2, %r13d
movl %r13d, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %r13d
jl 0x58ad
incl %ebp
cmpl %ebp, %r14d
jne 0x5795
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14ad9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x2deb4(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x2e3c7(%rip), %rsi     # 0x33c92
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_forEach
static void Ap_forEach(js_State *J)
{
	int hasthis = js_gettop(J) >= 3;
	int k, len;

	if (!js_iscallable(J, 1))
		js_typeerror(J, "callback is not a function");

	len = js_getlength(J, 0);
	for (k = 0; k < len; ++k) {
		if (js_hasindex(J, 0, k)) {
			js_copy(J, 1);
			if (hasthis)
				js_copy(J, 2);
			else
				js_pushundefined(J);
			js_copy(J, -3);
			js_pushnumber(J, k);
			js_copy(J, 0);
			js_call(J, 3);
			js_pop(J, 2);
		}
	}

	js_pushundefined(J);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %r15d
subl 0x144(%rdi), %r15d
movl $0x1, %esi
callq 0x14e17
testl %eax, %eax
je 0x5b8d
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
testl %eax, %eax
jle 0x5b66
movl %eax, %r14d
leaq 0x3a951(%rip), %r12     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r12, %rsi
testq %rax, %rax
js 0x5acf
movq %r12, %rsi
cmpl 0x140(%rbx), %eax
jge 0x5acf
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
testl %eax, %eax
je 0x5b5b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
movq %rbx, %rdi
cmpl $0x3, %r15d
jl 0x5b0a
movl $0x2, %esi
callq 0x14073
jmp 0x5b0f
callq 0x89b6
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x14073
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
movl $0x3, %esi
callq 0x16c25
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
addl $-0x2, %ecx
movl %ecx, 0x140(%rbx)
cmpl %eax, %ecx
jl 0x5b76
incl %ebp
cmpl %ebp, %r14d
jne 0x5aa7
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x89b6
movl %eax, 0x140(%rbx)
leaq 0x2dbeb(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x2e0fe(%rip), %rsi     # 0x33c92
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_map
static void Ap_map(js_State *J)
{
	int hasthis = js_gettop(J) >= 3;
	int k, len;

	if (!js_iscallable(J, 1))
		js_typeerror(J, "callback is not a function");

	js_newarray(J);

	len = js_getlength(J, 0);
	for (k = 0; k < len; ++k) {
		if (js_hasindex(J, 0, k)) {
			js_copy(J, 1);
			if (hasthis)
				js_copy(J, 2);
			else
				js_pushundefined(J);
			js_copy(J, -3);
			js_pushnumber(J, k);
			js_copy(J, 0);
			js_call(J, 3);
			js_setindex(J, -3, k);
			js_pop(J, 1);
		}
	}
	js_setlength(J, -1, len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x140(%rdi), %r15d
subl 0x144(%rdi), %r15d
movl $0x1, %esi
callq 0x14e17
testl %eax, %eax
je 0x5d04
movq %rbx, %rdi
callq 0x135de
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
movl %eax, %r14d
testl %eax, %eax
jle 0x5cc1
leaq 0x3a809(%rip), %r12     # 0x403f8
movslq 0x144(%rbx), %rax
movq %r12, %rsi
testq %rax, %rax
js 0x5c17
movq %r12, %rsi
cmpl 0x140(%rbx), %eax
jge 0x5c17
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
testl %eax, %eax
je 0x5cb6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
movq %rbx, %rdi
cmpl $0x3, %r15d
jl 0x5c56
movl $0x2, %esi
callq 0x14073
jmp 0x5c5b
callq 0x89b6
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x14073
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
movl $0x3, %esi
callq 0x16c25
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
movl %ebp, %edx
callq 0x1393c
movl 0x140(%rbx), %ecx
movl 0x144(%rbx), %eax
leal -0x1(%rcx), %edx
movl %edx, 0x140(%rbx)
cmpl %eax, %ecx
jle 0x5ced
incl %ebp
cmpl %ebp, %r14d
jne 0x5bef
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movq %rbx, %rdi
callq 0x4184
leaq 0x2da79(%rip), %rdx     # 0x33751
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x41f3
movl %eax, 0x140(%rbx)
leaq 0x2da74(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x2df87(%rip), %rsi     # 0x33c92
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3
// File: /workspace/github_c_makefile_star2_O1/ccxvii[P]mujs/./jsarray.c
// Function: Ap_filter
static void Ap_filter(js_State *J)
{
	int hasthis = js_gettop(J) >= 3;
	int k, to, len;

	if (!js_iscallable(J, 1))
		js_typeerror(J, "callback is not a function");

	js_newarray(J);
	to = 0;

	len = js_getlength(J, 0);
	for (k = 0; k < len; ++k) {
		if (js_hasindex(J, 0, k)) {
			js_copy(J, 1);
			if (hasthis)
				js_copy(J, 2);
			else
				js_pushundefined(J);
			js_copy(J, -3);
			js_pushnumber(J, k);
			js_copy(J, 0);
			js_call(J, 3);
			if (js_toboolean(J, -1)) {
				js_pop(J, 1);
				js_setindex(J, -2, to++);
			} else {
				js_pop(J, 2);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x140(%rdi), %eax
subl 0x144(%rdi), %eax
movl %eax, 0x4(%rsp)
movl $0x1, %esi
callq 0x14e17
testl %eax, %eax
je 0x5eb5
movq %rbx, %rdi
callq 0x135de
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3fcc
testl %eax, %eax
jle 0x5e8f
movl %eax, %r14d
leaq 0x3a68d(%rip), %r13     # 0x403f8
xorl %r15d, %r15d
movslq 0x144(%rbx), %rax
movq %r13, %rsi
testq %rax, %rax
js 0x5d96
movq %r13, %rsi
cmpl 0x140(%rbx), %eax
jge 0x5d96
shlq $0x4, %rax
addq 0x148(%rbx), %rax
movq %rax, %rsi
movq %rbx, %rdi
callq 0x15489
movq %rbx, %rdi
movq %rax, %rsi
movl %ebp, %edx
callq 0x16a4d
testl %eax, %eax
je 0x5e84
movq %rbx, %rdi
movl $0x1, %esi
callq 0x14073
cmpl $0x3, 0x4(%rsp)
jl 0x5dd6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x14073
jmp 0x5dde
movq %rbx, %rdi
callq 0x89b6
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x14073
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
movq %rbx, %rdi
callq 0x4184
movq %rbx, %rdi
xorl %esi, %esi
callq 0x14073
movq %rbx, %rdi
movl $0x3, %esi
callq 0x16c25
movslq 0x140(%rbx), %r12
movq %r13, %rsi
testq %r12, %r12
jle 0x5e36
movq 0x148(%rbx), %rax
movq %r12, %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $-0x10, %rsi
callq 0x150c0
testl %eax, %eax
je 0x5e6e
leal -0x1(%r12), %eax
movl %eax, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %r12d
jle 0x5e9e
leal 0x1(%r15), %r12d
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl %r15d, %edx
callq 0x1393c
movl %r12d, %r15d
jmp 0x5e84
addl $-0x2, %r12d
movl %r12d, 0x140(%rbx)
movl 0x144(%rbx), %eax
cmpl %eax, %r12d
jl 0x5e9e
incl %ebp
cmpl %ebp, %r14d
jne 0x5d6e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, 0x140(%rbx)
leaq 0x2d8c3(%rip), %rsi     # 0x3376e
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc939
leaq 0x2ddd6(%rip), %rsi     # 0x33c92
movq %rbx, %rdi
xorl %eax, %eax
callq 0xcce3