LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/unssa.c
// Function: rewrite_phi_bb
static void rewrite_phi_bb(struct basic_block *bb)
{
	struct instruction *insn;

	// Replace all the phi-nodes by copies of a temporary
	// (which represent the set of all the %phi that feed them).
	// The target pseudo doesn't change.
	FOR_EACH_PTR(bb->insns, insn) {
		if (!insn->bb)
			continue;
		if (insn->opcode != OP_PHI)
			continue;
		replace_phi_node(insn);
	} END_FOR_EACH_PTR(insn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a294
jmp 0x4a32a
jmp 0x4a296
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x20(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4a312
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4a2e1
cmpq $0x0, -0x10(%rbp)
jne 0x4a2e1
jmp 0x4a307
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4a2ee
jmp 0x4a307
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7f, %eax
cmpl $0x46, %eax
je 0x4a2fe
jmp 0x4a307
movq -0x10(%rbp), %rdi
callq 0x4a330
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4a29d
jmp 0x4a314
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x4a296
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/unssa.c
// Function: simplify_phi_node
static int simplify_phi_node(struct instruction *phi, pseudo_t tmp)
{
	pseudo_t target = phi->target;
	struct pseudo_user *pu;
	pseudo_t src;

	// verify if this phi can be simplified
	FOR_EACH_PTR(phi->phi_list, src) {
		struct instruction *def = src->def;

		if (!def)
			continue;
		if (def->bb == phi->bb)
			return 0;
	} END_FOR_EACH_PTR(src);

	// no need to make a copy of this one
	// -> replace the target pseudo by the tmp
	FOR_EACH_PTR(target->users, pu) {
		use_pseudo(pu->insn, tmp, pu->userp);
	} END_FOR_EACH_PTR(pu);

	phi->bb = NULL;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x4a587
jmp 0x4a62f
jmp 0x4a589
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x40(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4a617
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4a5d4
cmpq $0x0, -0x30(%rbp)
jne 0x4a5d4
jmp 0x4a609
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x4a5e9
jmp 0x4a609
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x4a607
movl $0x0, -0x4(%rbp)
jmp 0x4a6f4
jmp 0x4a609
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4a590
jmp 0x4a619
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
cmpq -0x38(%rbp), %rax
jne 0x4a589
jmp 0x4a631
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x4a659
jmp 0x4a6e1
jmp 0x4a65b
movl $0x0, -0x74(%rbp)
movl -0x74(%rbp), %eax
movq -0x68(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x4a6c9
movq -0x68(%rbp), %rax
movslq -0x74(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x68(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x4a6a6
cmpq $0x0, -0x28(%rbp)
jne 0x4a6a6
jmp 0x4a6be
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x4a740
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x4a662
jmp 0x4a6cb
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x68(%rbp)
cmpq -0x60(%rbp), %rax
jne 0x4a65b
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %r10
leaq -0x30(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3260
cmpl $0x0, %eax
jne 0x1274
movl $0x1, -0x4(%rbp)
jmp 0x1376
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x2c(%rbp), %r8d
movl -0x30(%rbp), %r9d
callq 0x1910
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x20(%rbp), %rdi
callq 0x1060
movq -0x38(%rbp), %rdi
callq 0x3420
movq %rax, -0x48(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x135d
movq -0x48(%rbp), %rdi
movl -0x3c(%rbp), %esi
movl $0x64, %edx
callq 0x2970
movq %rax, -0x50(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30c0
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jge 0x1346
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30d0
movslq -0x40(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x30f0
movl -0x5c(%rbp), %esi
movl -0x58(%rbp), %edx
movslq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x2cd0(%rip), %rdi      # 0x4004
movb $0x1, %al
callq 0x1080
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x12e4
movq -0x50(%rbp), %rdi
callq 0x3060
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x12b9
movq -0x48(%rbp), %rdi
callq 0x2ab0
movq -0x38(%rbp), %rdi
callq 0x1440
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: readLegalNotes
static void
readLegalNotes(FILE *fp)
    {
    char *note;

    fscanf(fp,"%ms",&note);
    LegalNoteCount = 0;
    while (!feof(fp))
        {
        //fprintf(stderr,"read note: %s\n",note);
        LegalNotes[LegalNoteCount++] = note;
        fscanf(fp,"%ms",&note);
        }

    int i,j;
    for (i = 0; i < LegalNoteCount; ++i)
        {
        int found = 0;
        for (j = 0; !found && j < sizeof(freqs) / sizeof(double); ++j)
            {
            //fprintf(stderr,"comparing %s with %s\n",LegalNotes[i],notes[j]);
            if (strcmp(LegalNotes[i],notes[j]) == 0)
                {
                LegalNoteIndices[i] = j;
                //printf("legal note %s, %f cps, %d samples\n",
                //    notes[j],freqs[j],(int)(SampleRate/freqs[j]));
                found = 1;
                }
            }
        if (!found)
            Fatal("note %s is not a legal note\n",LegalNotes[i]);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4be6(%rip), %rsi      # 0x76bd
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x2050
movl $0x0, 0x7e80(%rip)      # 0xa96c
movq -0x8(%rbp), %rdi
callq 0x2150
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2b03
jmp 0x2b3e
movq -0x10(%rbp), %rdx
movl 0x7e5f(%rip), %eax      # 0xa96c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x7e54(%rip)      # 0xa96c
movslq %eax, %rcx
leaq 0x865e(%rip), %rax      # 0xb180
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
leaq 0x4b8c(%rip), %rsi      # 0x76bd
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x2050
jmp 0x2aec
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x7e1e(%rip), %eax      # 0xa96c
jge 0x2c04
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
jne 0x2b7b
movslq -0x18(%rbp), %rax
cmpq $0x6c, %rax
setb %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x2b84
jmp 0x2bd1
movslq -0x14(%rbp), %rcx
leaq 0x85f1(%rip), %rax      # 0xb180
movq (%rax,%rcx,8), %rdi
movslq -0x18(%rbp), %rcx
leaq 0x7902(%rip), %rax      # 0xa4a0
movq (%rax,%rcx,8), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0x2bc4
movl -0x18(%rbp), %edx
movslq -0x14(%rbp), %rcx
leaq 0x7db6(%rip), %rax      # 0xa970
movl %edx, (%rax,%rcx,4)
movl $0x1, -0x1c(%rbp)
jmp 0x2bc6
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2b62
cmpl $0x0, -0x1c(%rbp)
jne 0x2bf4
movslq -0x14(%rbp), %rcx
leaq 0x859e(%rip), %rax      # 0xb180
movq (%rax,%rcx,8), %rsi
leaq 0x4ad4(%rip), %rdi      # 0x76c1
movb $0x0, %al
callq 0x3b30
jmp 0x2bf6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b45
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: skip
static void
skip(int count,FILE *in,FILE *out,RRA *h)
    {
    int i,amp;
    for (i = 0; i < count; ++i)
        {
        WindowStart = (WindowStart + 1) % WindowSize;
        --SamplesStored;
        amp = readRRAAmplitude(in,out,h->bitsPerSample,outputComment);
        if (!feof(in))
            {
            ++SamplesRead;
            ++SamplesStored;
            Window[WindowEnd] = amp;
            WindowEnd = (WindowEnd + 1) % WindowSize;
            }
        }
    //printf("after repitching/skipping, first amp is %d\n",peek(0));
    if (feof(in))
        {
        int count = SamplesStored;
        //printf("dumping the window, stored = %d\n",SamplesStored);
        for (i = 0; i < count; ++i)
            replace(in,out,h);
        //printf("done dumping the window, stored = %d\n",SamplesStored);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x34d3
movl 0x7538(%rip), %eax      # 0xa968
addl $0x1, %eax
cltd
idivl 0x74fe(%rip)            # 0xa938
movl %edx, 0x7528(%rip)      # 0xa968
movl 0x751a(%rip), %eax      # 0xa960
addl $-0x1, %eax
movl %eax, 0x7511(%rip)      # 0xa960
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x25db(%rip), %rcx      # 0x5a40
callq 0x4d90
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x34c3
movl 0x74cf(%rip), %eax      # 0xa950
addl $0x1, %eax
movl %eax, 0x74c6(%rip)      # 0xa950
movl 0x74d0(%rip), %eax      # 0xa960
addl $0x1, %eax
movl %eax, 0x74c7(%rip)      # 0xa960
movl -0x28(%rbp), %edx
movq 0x74a5(%rip), %rax      # 0xa948
movslq 0x74ba(%rip), %rcx      # 0xa964
movl %edx, (%rax,%rcx,4)
movl 0x74b1(%rip), %eax      # 0xa964
addl $0x1, %eax
cltd
idivl 0x747b(%rip)            # 0xa938
movl %edx, 0x74a1(%rip)      # 0xa964
jmp 0x34c5
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x341e
movq -0x10(%rbp), %rdi
callq 0x2150
cmpl $0x0, %eax
je 0x3517
movl 0x7479(%rip), %eax      # 0xa960
movl %eax, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x3515
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3520
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x34f1
jmp 0x3517
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq 0x7409(%rip), %rax      # 0xa948
movslq 0x7422(%rip), %rcx      # 0xa968
movl (%rax,%rcx,4), %edx
leaq 0x46d5(%rip), %rsi      # 0x7c25
movb $0x0, %al
callq 0x2130
movl 0x73f7(%rip), %eax      # 0xa954
addl $0x1, %eax
movl %eax, 0x73ee(%rip)      # 0xa954
movl 0x73fc(%rip), %eax      # 0xa968
addl $0x1, %eax
cltd
idivl 0x73c2(%rip)            # 0xa938
movl %edx, 0x73ec(%rip)      # 0xa968
movl 0x73de(%rip), %eax      # 0xa960
addl $-0x1, %eax
movl %eax, 0x73d5(%rip)      # 0xa960
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x249f(%rip), %rcx      # 0x5a40
callq 0x4d90
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2150
cmpl $0x0, %eax
jne 0x3608
movl 0x7393(%rip), %eax      # 0xa950
addl $0x1, %eax
movl %eax, 0x738a(%rip)      # 0xa950
movl 0x7394(%rip), %eax      # 0xa960
addl $0x1, %eax
movl %eax, 0x738b(%rip)      # 0xa960
movl -0x24(%rbp), %edx
movq 0x7369(%rip), %rax      # 0xa948
movslq 0x737e(%rip), %rcx      # 0xa964
movl %edx, (%rax,%rcx,4)
movl 0x7375(%rip), %eax      # 0xa964
addl $0x1, %eax
cltd
idivl 0x733f(%rip)            # 0xa938
movl %edx, 0x7365(%rip)      # 0xa964
movl $0x1, -0x4(%rbp)
jmp 0x360f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: crossing
static int
crossing(int start,int *peak)
    {
    int i;
    for (i = start; i < WindowSize-1; ++i)
        {
        if (abs(peek(i+1)) > *peak) *peak = abs(peek(i+1));
        if (peek(i) == 0 && peek(i+1) > 0)
            return i;
        }
    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl 0x72fa(%rip), %ecx      # 0xa938
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x36ab
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x2fc0
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x3679
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x2fc0
movl %eax, %ecx
movl %ecx, %eax
negl %eax
cmovnsl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x14(%rbp), %edi
callq 0x2fc0
cmpl $0x0, %eax
jne 0x369e
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x2fc0
cmpl $0x0, %eax
jle 0x369e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x36b2
jmp 0x36a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3635
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: correlate
static double
correlate(int end)
    {
    int i,j;
    double sum;

    sum = 0;
    for (i = 1; i <= CycleCount; ++i)
        {
        for (j = 0; j < end; ++j)
            sum += pow(peek(i*end + j) - peek(j),2);
        }

    return pow(sum / (CycleCount * (1.0 * end)),0.5);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x71a5(%rip), %eax      # 0xa8d8
jg 0x3798
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x378b
movl -0x8(%rbp), %edi
imull -0x4(%rbp), %edi
addl -0xc(%rbp), %edi
callq 0x2fc0
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %edi
callq 0x2fc0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x38af(%rip), %xmm1     # 0x7020
callq 0x2070
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x373c
jmp 0x378d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x372a
movsd -0x18(%rbp), %xmm0
cvtsi2sdl 0x7133(%rip), %xmm1 # 0xa8d8
cvtsi2sdl -0x4(%rbp), %xmm3
movsd 0x3856(%rip), %xmm2     # 0x7008
mulsd %xmm3, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0x387a(%rip), %xmm1     # 0x7040
callq 0x2070
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: findLegalFactor
static double
findLegalFactor(int cycle,int *n)
    {
    int i,j;
    double freq = SampleRate / (double) cycle;

    i = 0;
    while (i < LegalNoteCount)
        {
        int index = LegalNoteIndices[i];
        for (j = 1; j < OctavesAllowed + 1; ++j)
            {
            double factor = freqs[index] / (freq*j);
            if (factor > MinFactor && factor < MaxFactor)
                {
                if (Report)
                    {
                    if (j > 1) fprintf(ReportFP,
                        "found an octave multiple at %d\n",j);
                    fprintf(ReportFP,"    closest note to cycle %d is %s, "
                        "with factor %.4f\n",
                        cycle,notes[index],factor);
                    }
                *n = index;
                return factor;
                }
            }
        ++i;
        }
    if (Report)
        fprintf(ReportFP,"    no close note found\n");
    return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cvtsi2sdl 0x7119(%rip), %xmm0 # 0xa910
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x7157(%rip), %eax      # 0xa96c
jge 0x3916
movslq -0x1c(%rbp), %rcx
leaq 0x714a(%rip), %rax      # 0xa970
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl 0x7084(%rip), %ecx      # 0xa8c0
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3908
movslq -0x2c(%rbp), %rcx
leaq 0x68ee(%rip), %rax      # 0xa140
movsd (%rax,%rcx,8), %xmm0
movsd -0x28(%rbp), %xmm1
cvtsi2sdl -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
ucomisd 0x70ad(%rip), %xmm0     # 0xa928
jbe 0x38f8
movsd -0x38(%rbp), %xmm1
movsd 0x70a6(%rip), %xmm0     # 0xa930
ucomisd %xmm1, %xmm0
jbe 0x38f8
cmpl $0x0, 0x707d(%rip)      # 0xa914
je 0x38e3
cmpl $0x1, -0x20(%rbp)
jle 0x38b7
movq 0x7072(%rip), %rdi      # 0xa918
movl -0x20(%rbp), %edx
leaq 0x3cd9(%rip), %rsi      # 0x7589
movb $0x0, %al
callq 0x2130
movq 0x705a(%rip), %rdi      # 0xa918
movl -0xc(%rbp), %edx
movslq -0x2c(%rbp), %rcx
leaq 0x6bd4(%rip), %rax      # 0xa4a0
movq (%rax,%rcx,8), %rcx
movsd -0x38(%rbp), %xmm0
leaq 0x3ccd(%rip), %rsi      # 0x75a9
movb $0x1, %al
callq 0x2130
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x393c
jmp 0x38fa
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3833
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x380c
cmpl $0x0, 0x6ff7(%rip)      # 0xa914
je 0x3934
movq 0x6ff2(%rip), %rdi      # 0xa918
leaq 0x3cb2(%rip), %rsi      # 0x75df
movb $0x0, %al
callq 0x2130
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: findAnyFactor
static double
findAnyFactor(int cycle,int *n)
    {
    int i;
    int best;
    double freq;
    double diff;
    double closest;
    double factor;

    /* find the closest note */

    best = -1;
    closest = -1;
    freq = SampleRate / (double) cycle;
    for (i = 0; i < sizeof(freqs) / sizeof(double); ++i)
        {
        diff = fabs(freqs[i] - freq);
        double factor = freqs[i] / freq;
        if (factor > MinFactor && factor < MaxFactor)
            {
            if (closest < 0 || diff < closest)
                {
                closest = diff;
                best = i;
                }
            }
        }


    if (best < 0)
        return 0;
    else
        {
        factor = freqs[best] / freq;
        *n = best;
        if (Report)
            fprintf(ReportFP,"possible repitch: cycle %d, "
                "from %f cps to %f cps(%s), factor is %f\n",
                cycle,freq,freqs[best],notes[best],factor);
        return factor;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movsd 0x36ca(%rip), %xmm0     # 0x7038
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl 0x6f95(%rip), %xmm0 # 0xa910
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq $0x6c, %rax
jae 0x3a3b
movslq -0x1c(%rbp), %rcx
leaq 0x6797(%rip), %rax      # 0xa140
movsd (%rax,%rcx,8), %xmm0
subsd -0x28(%rbp), %xmm0
movaps 0x3726(%rip), %xmm1     # 0x70e0
pand %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movslq -0x1c(%rbp), %rcx
leaq 0x6772(%rip), %rax      # 0xa140
movsd (%rax,%rcx,8), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
ucomisd 0x6f3e(%rip), %xmm0     # 0xa928
jbe 0x3a2b
movsd -0x48(%rbp), %xmm1
movsd 0x6f37(%rip), %xmm0     # 0xa930
ucomisd %xmm1, %xmm0
jbe 0x3a2b
xorps %xmm0, %xmm0
ucomisd -0x38(%rbp), %xmm0
ja 0x3a19
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3a29
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x3a2b
jmp 0x3a2d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3990
cmpl $0x0, -0x20(%rbp)
jge 0x3a4b
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x3ac2
movslq -0x20(%rbp), %rcx
leaq 0x66ea(%rip), %rax      # 0xa140
movsd (%rax,%rcx,8), %xmm0
divsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, 0x6e9f(%rip)      # 0xa914
je 0x3ab8
movq 0x6e9a(%rip), %rdi      # 0xa918
movl -0xc(%rbp), %edx
movsd -0x28(%rbp), %xmm0
movslq -0x20(%rbp), %rcx
leaq 0x66af(%rip), %rax      # 0xa140
movsd (%rax,%rcx,8), %xmm1
movslq -0x20(%rbp), %rcx
leaq 0x69ff(%rip), %rax      # 0xa4a0
movq (%rax,%rcx,8), %rcx
movsd -0x40(%rbp), %xmm2
leaq 0x3b47(%rip), %rsi      # 0x75f8
movb $0x3, %al
callq 0x2130
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pipde[P]deos-songlib/utils/fixpitch/fixpitch.c
// Function: interpolate
static int
interpolate(double spot)
    {
    int index = (int) spot;
    int low = peek(index);
    int high = peek(index + 1);
    return (int)(low + (spot - index) * (high - low));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
cvttsd2si -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x2fc0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
callq 0x2fc0
movl %eax, -0x14(%rbp)
cvtsi2sdl -0x10(%rbp), %xmm1
movsd -0x8(%rbp), %xmm0
cvtsi2sdl -0xc(%rbp), %xmm2
subsd %xmm2, %xmm0
movl -0x14(%rbp), %eax
subl -0x10(%rbp), %eax
cvtsi2sd %eax, %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/main.c
// Function: usage
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 %rbp
movq %rsp, %rbp
movq 0x434ad(%rip), %rax     # 0x46fe8
movq (%rax), %rdi
leaq 0x2f572(%rip), %rsi     # 0x330b7
movb $0x0, %al
callq 0x3350
movq 0x43495(%rip), %rax     # 0x46fe8
movq (%rax), %rdi
leaq 0x2f588(%rip), %rsi     # 0x330e5
movb $0x0, %al
callq 0x3350
movq 0x4347d(%rip), %rax     # 0x46fe8
movq (%rax), %rdi
leaq 0x2f5a3(%rip), %rsi     # 0x33118
movb $0x0, %al
callq 0x3350
movl $0x1, %edi
callq 0x3100
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3c44
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14b80
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x19060
movq -0x8(%rbp), %rdi
callq 0x8640
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x17ea0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3bef
movq -0x8(%rbp), %rdi
callq 0x8640
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3d45
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14b80
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x3d27
movl $0x20, %edi
callq 0x3130
movq -0x18(%rbp), %rdi
movq 0x432c6(%rip), %rax     # 0x46ff8
movq (%rax), %rsi
callq 0x3260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cff
movl $0xa, %edi
callq 0x3130
movq -0x8(%rbp), %rdi
callq 0x8640
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3dc5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14b80
movq %rax, -0x18(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0x3da7
movl $0x20, %edi
callq 0x3130
movq -0x18(%rbp), %rdi
movq 0x43246(%rip), %rax     # 0x46ff8
movq (%rax), %rsi
callq 0x3260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d7f
movq -0x8(%rbp), %rdi
callq 0x8640
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x38a09(%rip), %rdi     # 0x3ca3c
callq 0x32c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x404e
movq -0x8(%rbp), %rdi
callq 0x136f0
jmp 0x4076
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13880
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x406d
movq -0x10(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
callq 0x31c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/main.c
// Function: eval_print
static int eval_print(js_State *J, const char *source)
{
	if (js_ploadstring(J, "[stdin]", source)) {
		fprintf(stderr, "%s\n", js_trystring(J, -1, "Error"));
		js_pop(J, 1);
		return 1;
	}
	js_pushundefined(J);
	if (js_pcall(J, 0)) {
		fprintf(stderr, "%s\n", js_trystring(J, -1, "Error"));
		js_pop(J, 1);
		return 1;
	}
	if (js_isdefined(J, -1)) {
		printf("%s\n", js_tryrepr(J, -1, "can't convert to string"));
	}
	js_pop(J, 1);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x2f2a6(%rip), %rsi     # 0x33395
callq 0x18eb0
cmpl $0x0, %eax
je 0x414b
movq 0x42ee8(%rip), %rax     # 0x46fe8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x37712(%rip), %rdx     # 0x3b829
callq 0x19360
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f273(%rip), %rsi     # 0x3339d
movb $0x0, %al
callq 0x3350
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movl $0x1, -0x4(%rbp)
jmp 0x4201
movq -0x10(%rbp), %rdi
callq 0x8640
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x189f0
cmpl $0x0, %eax
je 0x41b3
movq 0x42e7d(%rip), %rax     # 0x46fe8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x376a7(%rip), %rdx     # 0x3b829
callq 0x19360
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x2f208(%rip), %rsi     # 0x3339d
movb $0x0, %al
callq 0x3350
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movl $0x1, -0x4(%rbp)
jmp 0x4201
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x150d0
cmpl $0x0, %eax
je 0x41ec
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x2f1cb(%rip), %rdx     # 0x333a1
callq 0x14bc0
movq %rax, %rsi
leaq 0x2f1b8(%rip), %rdi     # 0x3339d
movb $0x0, %al
callq 0x3030
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ccxvii[P]mujs/main.c
// Function: read_stdin
static char *read_stdin(void)
{
	int n = 0;
	int t = 512;
	char *s = NULL;

	for (;;) {
		char *ss = realloc(s, t);
		if (!ss) {
			free(s);
			fprintf(stderr, "cannot allocate storage for stdin contents\n");
			return NULL;
		}
		s = ss;
		n += fread(s + n, 1, t - n - 1, stdin);
		if (n < t - 1)
			break;
		t *= 2;
	}

	if (ferror(stdin)) {
		free(s);
		fprintf(stderr, "error reading stdin\n");
		return NULL;
	}

	s[n] = 0;
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movl $0x200, -0x10(%rbp)     # imm = 0x200
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x10(%rbp), %rsi
callq 0x3330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4274
movq -0x18(%rbp), %rdi
callq 0x31c0
movq 0x42d92(%rip), %rax     # 0x46fe8
movq (%rax), %rdi
leaq 0x2f159(%rip), %rsi     # 0x333b9
movb $0x0, %al
callq 0x3350
movq $0x0, -0x8(%rbp)
jmp 0x4323
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rdx
movq 0x42d3e(%rip), %rax     # 0x46fd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x32a0
movq %rax, %rcx
movslq -0xc(%rbp), %rax
addq %rcx, %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x42c3
jmp 0x42d0
movl -0x10(%rbp), %eax
shll %eax
movl %eax, -0x10(%rbp)
jmp 0x422e
movq 0x42d01(%rip), %rax     # 0x46fd8
movq (%rax), %rdi
callq 0x31f0
cmpl $0x0, %eax
je 0x430f
movq -0x18(%rbp), %rdi
callq 0x31c0
movq 0x42cf4(%rip), %rax     # 0x46fe8
movq (%rax), %rdi
leaq 0x2f0e7(%rip), %rsi     # 0x333e5
movb $0x0, %al
callq 0x3350
movq $0x0, -0x8(%rbp)
jmp 0x4323
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq 0x37aaf(%rip), %rdx     # 0x3bdfc
callq 0x4380
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x43c0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x144(%rcx), %eax
jge 0x4460
movq -0x8(%rbp), %rax
movl 0x144(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rdi
leaq 0x379c0(%rip), %rsi     # 0x3be19
movb $0x0, %al
callq 0xbb10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x44fe
movq -0x8(%rbp), %rdi
callq 0x14dc0
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x4, 0xf(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %eax
addl $0x1, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jl 0x489d
movq -0x8(%rbp), %rdi
callq 0x14dc0
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x140(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x7, 0xf(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rax
movq -0x8(%rbp), %rdx
movslq 0x140(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x140(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x140(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3220
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x493e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4946
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x6580
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0x2, %ecx
callq 0x65c0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x15240
cmpl $0x0, %eax
jne 0x49ae
movq -0x8(%rbp), %rdi
leaq 0x3792d(%rip), %rsi     # 0x3c2d4
movb $0x0, %al
callq 0xbfe0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
leaq 0x36725(%rip), %rdx     # 0x3b0e0
callq 0x4380
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15290
cmpl $0x0, %eax
jne 0x4a2d
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
movq -0x8(%rbp), %rdi
leaq 0x371fc(%rip), %rsi     # 0x3bbe8
callq 0x17220
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x36e37(%rip), %rdx     # 0x3b838
callq 0x4380
movq -0x8(%rbp), %rdi
callq 0x16600
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
leaq 0x36927(%rip), %rdx     # 0x3b346
callq 0x4380
movq -0x8(%rbp), %rdi
callq 0x16600
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14410
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x17ea0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13830
movl $0x0, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4b3f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x15310
cmpl $0x0, %eax
je 0x4b16
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4330
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4b06
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x17b20
cmpl $0x0, %eax
je 0x4af9
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x13bb0
jmp 0x4afb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4ac2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4400
jmp 0x4b2f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x13bb0
jmp 0x4b31
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4a7f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4330
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x4dd5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x17aa0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x17cc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x4470
jmp 0x4deb
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4470
movq -0x8(%rbp), %rdi
callq 0x8640
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4330
movl %eax, -0x14(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4e63
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x14410
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4e2d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x4470
movq -0x8(%rbp), %rdi
cvtsi2sdl -0x14(%rbp), %xmm0
callq 0x44d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4330
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x4f7b
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x17b20
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
xorl %esi, %esi
callq 0x17b20
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4f23
cmpl $0x0, -0x20(%rbp)
je 0x4f23
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
jmp 0x4f6d
cmpl $0x0, -0x20(%rbp)
je 0x4f47
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
xorl %esi, %esi
callq 0x17cc0
jmp 0x4f6b
cmpl $0x0, -0x1c(%rbp)
je 0x4f69
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
xorl %esi, %esi
callq 0x13bb0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x17cc0
jmp 0x4f6b
jmp 0x4f6d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ebf
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x14410
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4330
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x4fcb
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x4470
movq -0x8(%rbp), %rdi
callq 0x8640
jmp 0x504d
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x17aa0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x502b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
xorl %esi, %esi
callq 0x17b20
cmpl $0x0, %eax
je 0x500d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x13bb0
jmp 0x501e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x17cc0
jmp 0x5020
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4fdf
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x17cc0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x4470
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)