LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: makeSeq
void makeSeq(const char seq[], const unsigned int seqLen, unsigned char sequence[]){
    int i;
    // make all multiples of 4 possible
    for(i = 0; i < seqLen/4; i++){
        sequence[i] = seqToChar(seq[i*4], seq[i*4 + 1], seq[i*4 + 2], seq[i*4 + 3]);
    }
    if(seqLen%4 == 3){
        sequence[seqLen/4] = seqToChar(seq[i*4], seq[i*4 + 1], seq[i*4 + 2], 'T');
    }else if(seqLen%4 == 2){
        sequence[seqLen/4] = seqToChar(seq[i*4], seq[i*4 + 1], 'T', 'T');
    }else if(seqLen%4 == 1){
        sequence[seqLen/4] = seqToChar(seq[i*4], 'T', 'T', 'T');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jae 0xc63e
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dil
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %sil
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movsbl %dil, %edi
movsbl %sil, %esi
movsbl %dl, %edx
movsbl (%rax,%rcx), %ecx
callq 0xc2f0
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc5ba
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x3, %eax
jne 0xc6aa
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dil
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %sil
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x2, %ecx
movslq %ecx, %rdx
movl $0x54, %ecx
movsbl %dil, %edi
movsbl %sil, %esi
movsbl (%rax,%rdx), %edx
callq 0xc2f0
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0xc73c
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x2, %eax
jne 0xc6fd
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %sil
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
movl $0x54, %ecx
movsbl %sil, %edi
movsbl (%rax,%rdx), %esi
movl %ecx, %edx
callq 0xc2f0
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0xc73a
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x1, %eax
jne 0xc738
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x2, %ecx
movslq %ecx, %rdx
movl $0x54, %ecx
movsbl (%rax,%rdx), %edi
movl %ecx, %esi
movl %ecx, %edx
callq 0xc2f0
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0xc73a
jmp 0xc73c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: charToSeqFour
void charToSeqFour(unsigned char num, char seq[]){
  seq[0] = theFourConverter[num][0];
  seq[1] = theFourConverter[num][1];
  seq[2] = theFourConverter[num][2];
  seq[3] = theFourConverter[num][3];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x24bc5(%rip), %rax     # 0x31370
movb (%rax,%rcx,4), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x24baf(%rip), %rax     # 0x31370
movb 0x1(%rax,%rcx,4), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x24b97(%rip), %rax     # 0x31370
movb 0x2(%rax,%rcx,4), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x24b7f(%rip), %rax     # 0x31370
movb 0x3(%rax,%rcx,4), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: charToSeq
void charToSeq(unsigned char num, char seq[], const int len){
    int i;
    for(i = 0; i < len; i++){
        if(num%2){ // A or G
            num = num >> 1;
            if(num%2){ // A or C match?
                seq[i] = 'A';
            }else{
                seq[i] = 'G';
            }
        }else{
            num = num >> 1;
            if(num%2){ // A or C match?
                seq[i] = 'C';
            }else{
                seq[i] = 'T';
            }
        }
        num = num >> 1;
    }
    for(i = len; i < 4; i++){ // fill in the rest with spaces
        seq[i] = ' ';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xc8b8
movzbl -0x1(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc86b
movzbl -0x1(%rbp), %eax
sarl %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc85d
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x41, (%rax,%rcx)
jmp 0xc869
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x47, (%rax,%rcx)
jmp 0xc8a1
movzbl -0x1(%rbp), %eax
sarl %eax
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xc893
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x43, (%rax,%rcx)
jmp 0xc89f
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x54, (%rax,%rcx)
jmp 0xc8a1
movzbl -0x1(%rbp), %eax
sarl %eax
movb %al, -0x1(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc818
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0xc8db
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x20, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc8be
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: PrintSequenceNumeric
void PrintSequenceNumeric(const unsigned char sequence[], const unsigned int seqLen){
    int j;
    for(j = 0; j < seqLen/4; j++){
        //printf("%i ", sequence[j]);
    }
    if(seqLen%4 != 0){ //print the end
        //printf("%i", sequence[seqLen/4]);
    }
    //printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jae 0xc90c
jmp 0xc901
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc8f2
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xc919
jmp 0xc919
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: PrintSequence
void PrintSequence(const unsigned char sequence[], const unsigned int seqLen){
    char seqer[4];
    int j;
    for(j = 0; j < seqLen/4; j++){
        charToSeq(sequence[j], seqer, 4);
        //printf("%.4s", seqer);
    }
    if(seqLen%4 != 0){
        charToSeq(sequence[seqLen/4], seqer, seqLen%4);
        //printf("%.4s", seqer);
    }
    //printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
cmpl %ecx, %eax
jae 0xc99a
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
leaq -0x10(%rbp), %rsi
movl $0x4, %edx
movzbl %al, %edi
callq 0xc800
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc966
movl -0xc(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0xc9c6
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
leaq -0x10(%rbp), %rsi
movl -0xc(%rbp), %edx
andl $0x3, %edx
movzbl %al, %edi
callq 0xc800
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: initAlignment
void initAlignment(alignSet_t *dst) {
    dst->likelihood = 0.0;
    dst->likelihoodInsert = 0.0;
    dst->start1 = -1;
    dst->start2 = -1;
    dst->end1 = -1;
    dst->end2 = -1;
    dst->contigId1 = -1;
    dst->contigId2 = -1;
    dst->name = NULL;
    dst->orientation = NO_READS;
    dst->nextAlignment = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0xd, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: copyAlignment
void copyAlignment(alignSet_t *dst, const alignSet_t *src) {
    assert(dst != NULL);
    assert(src != NULL);
    destroyAlignment(dst);

    dst->likelihood = src->likelihood;
    dst->likelihoodInsert = src->likelihoodInsert;
    dst->start1 = src->start1;
    dst->start2 = src->start2;
    dst->end1 = src->end1;
    dst->end2 = src->end2;
    dst->contigId1 = src->contigId1;
    dst->contigId2 = src->contigId2;
    if (src->name != NULL)
        dst->name = strdup(src->name);
    else
        dst->name = NULL;
    dst->orientation = src->orientation;
    dst->nextAlignment = src->nextAlignment;
    dst->bamOfAlignment1 = src->bamOfAlignment1;
    dst->bamOfAlignment2 = src->bamOfAlignment2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcc49
jmp 0xcc68
leaq 0x24bba(%rip), %rdi     # 0x3180a
leaq 0x24bbf(%rip), %rsi     # 0x31816
movl $0x162, %edx            # imm = 0x162
leaq 0x24be4(%rip), %rcx     # 0x31847
callq 0x3220
cmpq $0x0, -0x10(%rbp)
je 0xcc71
jmp 0xcc90
leaq 0x24c04(%rip), %rdi     # 0x3187c
leaq 0x24b97(%rip), %rsi     # 0x31816
movl $0x163, %edx            # imm = 0x163
leaq 0x24bbc(%rip), %rcx     # 0x31847
callq 0x3220
movq -0x8(%rbp), %rdi
callq 0xcbd0
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xcd34
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3620
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0xcd40
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getGCtotal
int getGCtotal(char seq1[], int seq1len){
    int GCtot = 0, i;
    for(i = 0; i < seq1len; i++){
        if(isGC(seq1[i])){
            GCtot++;
        }
    }
    return GCtot;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xcf41
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xcea0
cmpl $0x0, %eax
je 0xcf34
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcf36
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcf0d
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: findNumAssemPieces
int findNumAssemPieces(kseq_t *ins){
    int l, count = 0;
    while ((l = kseq_read(ins)) >= 0) {
        count++;
    }
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcf90
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jl 0xcf7f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcf63
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: validateAssemblyIsSameAsAlignment
int validateAssemblyIsSameAsAlignment(bam_header_t *header, assemblyT *theAssembly) {
    int i;
    //printf("Validating assembly and alignment files consisting of %d contigs\n", header->n_targets);
    if (header->n_targets != theAssembly->numContigs) {
        //printf("Different number of contigs in assembly (%d) and alignmentfile (%d)\n", theAssembly->numContigs, header->n_targets);
        return 0;
    }
    for (i = 0; i < header->n_targets; i++) {
        if (header->target_len[i] != theAssembly->contigs[i]->seqLen) {
        	//printf("Different contig length in contig %d: %d vs %d\n", i, header->target_len[i], theAssembly->contigs[i]->seqLen);
        	return 0;
        }
        if (strcmp(header->target_name[i], theAssembly->contigs[i]->name) != 0) {
        	//printf("Warning assembly and alignment files disagree on the name of contig %d: %s vs %s\n", i, header->target_name[i], theAssembly->contigs[i]->name);
        }
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xd77a
movl $0x0, -0x4(%rbp)
jmp 0xd802
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xd7fb
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq 0xa0(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x8(%rcx), %eax
je 0xd7bc
movl $0x0, -0x4(%rbp)
jmp 0xd802
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x3330
cmpl $0x0, %eax
je 0xd7ee
jmp 0xd7ee
jmp 0xd7f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd781
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getContigAvgDepth
double getContigAvgDepth(contig_t *contig) {
	double depth = 0.0;
	int j;
	for(j=0; j < contig->seqLen; j++)
		depth += contig->depth[j];
	return depth / contig->seqLen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xdd5d
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xdd27
movsd -0x10(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdl 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: getFragmentMapLenBAM
int getFragmentMapLenBAM(bam1_t *read1) {
    assert(read1 != NULL);

    int left = read1->core.pos < read1->core.mpos ? read1->core.pos : read1->core.mpos;
    int readLength = getSeqMapLenBAM(read1);
    int right1 = read1->core.pos + readLength;
    int right2 = read1->core.mpos + readLength;
    int right = right1 > right2 ? right1 : right2;
    assert(right >= left);
    return right - left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xde05
jmp 0xde24
leaq 0x21fab(%rip), %rdi     # 0x2fdb7
leaq 0x23a03(%rip), %rsi     # 0x31816
movl $0x240, %edx            # imm = 0x240
leaq 0x23b1f(%rip), %rcx     # 0x3193e
callq 0x3220
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xde40
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xde4a
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0xdd80
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0xde86
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xde8c
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0xde9c
jmp 0xdebb
leaq 0x23abe(%rip), %rdi     # 0x31961
leaq 0x2396c(%rip), %rsi     # 0x31816
movl $0x247, %edx            # imm = 0x247
leaq 0x23a88(%rip), %rcx     # 0x3193e
callq 0x3220
movl -0x1c(%rbp), %eax
subl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: readNextBAM
enum MATE_ORIENTATION readNextBAM(samfile_t *ins, bam1_t *read1) {
    assert(ins != NULL);
    assert(read1 != NULL);

    while (1) {
      int bytesRead = samread(ins, read1);
      if (bytesRead <= 0) {
        return NO_READS;
      } else if ( ( read1->core.flag & ( BAM_FSECONDARY | BAM_FQCFAIL | BAM_FDUP | BAM_FSUPPLEMENTARY)) == 0) { // only consider the read if it is primary, passedqc and not duplicated
        enum MATE_ORIENTATION o = getPairedMateOrientation(read1);
        //printf("readNextBam: %s %d %d %s\n", bam1_qname(read1), read1->core.flag, o, MATE_ORIENTATION_LABELS[o]);
        return o;
      }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe269
jmp 0xe288
leaq 0x23796(%rip), %rdi     # 0x31a06
leaq 0x2359f(%rip), %rsi     # 0x31816
movl $0x296, %edx            # imm = 0x296
leaq 0x2378f(%rip), %rcx     # 0x31a12
callq 0x3220
cmpq $0x0, -0x18(%rbp)
je 0xe291
jmp 0xe2b0
leaq 0x21b1f(%rip), %rdi     # 0x2fdb7
leaq 0x23577(%rip), %rsi     # 0x31816
movl $0x297, %edx            # imm = 0x297
leaq 0x23767(%rip), %rcx     # 0x31a12
callq 0x3220
jmp 0xe2b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cb90
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jg 0xe2d1
movl $0xd, -0x4(%rbp)
jmp 0xe305
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shrq $0x20, %rax
andq $0xffff, %rax           # imm = 0xFFFF
andl $0xf00, %eax            # imm = 0xF00
cmpl $0x0, %eax
jne 0xe301
movq -0x18(%rbp), %rdi
callq 0xded0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xe305
jmp 0xe303
jmp 0xe2b2
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: printAlignments
void printAlignments(alignSet_t *head){
    // print out the head
    //printf("Alignment 1 for read %s: %f at %i-%i and %i-%i.\n", head->name, head->likelihood, head->start1, head->end1, head->start2, head->end2);
    alignSet_t *current = head;
    int i = 1;
    while(current->nextAlignment != NULL){
        current = current->nextAlignment;
        i++;
        //printf("Alignment %i for read %s: %f at %i-%i and %i-%i.\n", i, current->name, current->likelihood, current->start1, current->end1, current->start2, current->end2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe349
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xe327
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: loadAssembly
assemblyT *loadAssembly(char *filename) {

    // attempt to open the input file
    gzFile assemblyFile = gzopen(filename, "r");
    kseq_t *Aseq;
    if(assemblyFile == NULL){
        printf("Error! Could not open assembly file: %s\n", filename);
        exit(1);
    }

    assemblyT *theAssembly = malloc(sizeof(assemblyT));
    if (theAssembly == NULL)
        exit(1);

    Aseq = kseq_init(assemblyFile);

    readAssembly(Aseq, theAssembly);

    kseq_destroy(Aseq);

    //printf("Done reading in assembly.\n");

    //printAssembly(theAssembly);
    assemblySanityCheck(theAssembly);
    gzclose(assemblyFile);

    return theAssembly;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x24bb8(%rip), %rsi     # 0x3341f
callq 0x34e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe893
movq -0x8(%rbp), %rsi
leaq 0x233c3(%rip), %rdi     # 0x31c45
movb $0x0, %al
callq 0x3200
movl $0x1, %edi
callq 0x35b0
movl $0xa8, %edi
callq 0x3420
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xe8b2
movl $0x1, %edi
callq 0x35b0
movq -0x10(%rbp), %rdi
callq 0xe900
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd370
movq -0x18(%rbp), %rdi
callq 0xe940
movq -0x20(%rbp), %rdi
callq 0xe680
movq -0x10(%rbp), %rdi
callq 0x3040
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: freeContig
void freeContig(contig_t *contig) {
    if (contig == NULL)
        return;
    free(contig->name);
    free(contig->seq);
    free(contig->depth);
    free(contig->seqNum);
    free(contig->ambiguousBasePositions);
    free(contig->matchLogLikelihood);
    free(contig->insertLogLikelihood);
    free(contig->kmerLogLikelihood);
    free(contig->depthLogLikelihood);
    free(contig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe9c5
jmp 0xea42
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: freeAssembly
void freeAssembly(assemblyT *theAssembly) {
    if (theAssembly != NULL) {
        if (theAssembly->contigs != NULL) {
        	int i;
        	for (i = 0; i < theAssembly->numContigs; i++)
        		freeContig(theAssembly->contigs[i]);
        	free(theAssembly->contigs);
        }
        free(theAssembly);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xeabf
movq -0x8(%rbp), %rax
cmpq $0x0, 0xa0(%rax)
je 0xeab6
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xeaa6
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xe9b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xea78
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: openSamOrBam
samfile_t *openSamOrBam(const char *fileName) {
    samfile_t *in = samopen(fileName, "rb", 0);
    if (in == NULL || in->header == NULL) {
        printf("Checking if %s is a SAM formatted file, instead of BAM\n", fileName);
        in = samopen(fileName, "r", 0);
        if (in == NULL || in->header == NULL) {
            printf("Error! Failed to open BAM/SAM file %s\n", fileName);
            exit(1);
        }
    }
    return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x23187(%rip), %rsi     # 0x31c6e
xorl %eax, %eax
movl %eax, %edx
callq 0x1c430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeb06
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xeb60
movq -0x8(%rbp), %rsi
leaq 0x23160(%rip), %rdi     # 0x31c71
movb $0x0, %al
callq 0x3200
movq -0x8(%rbp), %rdi
leaq 0x248fc(%rip), %rsi     # 0x3341f
xorl %eax, %eax
movl %eax, %edx
callq 0x1c430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeb42
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xeb5e
movq -0x8(%rbp), %rsi
leaq 0x2315c(%rip), %rdi     # 0x31ca9
movb $0x0, %al
callq 0x3200
movl $0x1, %edi
callq 0x35b0
jmp 0xeb60
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ALEhelpers.c
// Function: zNormalizationInsertStd
double zNormalizationInsertStd(double std) {
  // int((pmf of normal(0,sigma))^2, 0, infty)
  double expIns = 1.0;
  if (std > 0.0){
      expIns = 1.0/(2.0*sqrt(3.14159265)*std);
  }
  return expIns;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movsd 0x1cebb(%rip), %xmm0    # 0x2ba40
movsd %xmm0, -0x10(%rbp)
movsd -0x8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xebc7
movsd 0x22770(%rip), %xmm0    # 0x31310
callq 0x35f0
movsd 0x1cedb(%rip), %xmm1    # 0x2ba88
mulsd %xmm0, %xmm1
mulsd -0x8(%rbp), %xmm1
movsd 0x1ce82(%rip), %xmm0    # 0x2ba40
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: ssw_init
s_profile* ssw_init (const int8_t* read, const int32_t readLen, const int8_t* mat, const int32_t n, const int8_t score_size) {
	s_profile* p = (s_profile*)calloc(1, sizeof(struct _profile));
	p->profile_byte = 0;
	p->profile_word = 0;
	p->bias = 0;

	if (score_size == 0 || score_size == 2) {
		/* Find the bias to use in the substitution matrix */
		int32_t bias = 0, i;
		for (i = 0; i < n*n; i++) if (mat[i] < bias) bias = mat[i];
		bias = abs(bias);

		p->bias = bias;
		p->profile_byte = qP_byte (read, mat, readLen, n, bias);
	}
	if (score_size == 1 || score_size == 2) p->profile_word = qP_word (read, mat, readLen, n);
	p->read = read;
	p->mat = mat;
	p->readLen = readLen;
	p->n = n;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x3310
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x28(%rax)
movsbl -0x1d(%rbp), %eax
cmpl $0x0, %eax
je 0x10594
movsbl -0x1d(%rbp), %eax
cmpl $0x2, %eax
jne 0x1061a
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x1c(%rbp), %ecx
imull -0x1c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x105dd
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x2c(%rbp), %eax
jge 0x105d0
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x2c(%rbp)
jmp 0x105d2
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x105a2
movl -0x2c(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x28(%rbp), %rax
movb %cl, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
movl -0x2c(%rbp), %eax
movzbl %al, %r8d
callq 0x10680
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movsbl -0x1d(%rbp), %eax
cmpl $0x1, %eax
je 0x1062c
movsbl -0x1d(%rbp), %eax
cmpl $0x2, %eax
jne 0x1064a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %ecx
callq 0x107b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: qP_byte
static __m128i* qP_byte (const int8_t* read_num,
				  const int8_t* mat,
				  const int32_t readLen,
				  const int32_t n,	/* the edge length of the squre matrix mat */
				  uint8_t bias) {

	int32_t segLen = (readLen + 15) / 16; /* Split the 128 bit register into 16 pieces.
								     Each piece is 8 bit. Split the read into 16 segments.
								     Calculat 16 segments in parallel.
								   */
	__m128i* vProfile = (__m128i*)malloc(n * segLen * sizeof(__m128i));
	int8_t* t = (int8_t*)vProfile;
	int32_t nt, i, j, segNum;

	/* Generate query profile rearrange query sequence & calculate the weight of match/mismatch */
	for (nt = 0; LIKELY(nt < n); nt ++) {
		for (i = 0; i < segLen; i ++) {
			j = i;
			for (segNum = 0; LIKELY(segNum < 16) ; segNum ++) {
				*t++ = j>= readLen ? bias : mat[nt * n + read_num[j]] + bias;
				j += segLen;
			}
		}
	}
	return vProfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl -0x14(%rbp), %eax
addl $0xf, %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %eax
imull -0x20(%rbp), %eax
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0x3420
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x107a5
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x10795
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
cmpl $0x10, -0x40(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x10785
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x10732
movzbl -0x19(%rbp), %eax
movl %eax, -0x44(%rbp)
jmp 0x1075b
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movslq -0x3c(%rbp), %rsi
movsbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movzbl -0x19(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x20(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x1070d
jmp 0x10787
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x106f4
jmp 0x10797
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x106d3
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: qP_word
static __m128i* qP_word (const int8_t* read_num,
				  const int8_t* mat,
				  const int32_t readLen,
				  const int32_t n) {

	int32_t segLen = (readLen + 7) / 8;
	__m128i* vProfile = (__m128i*)malloc(n * segLen * sizeof(__m128i));
	int16_t* t = (int16_t*)vProfile;
	int32_t nt, i, j;
	int32_t segNum;

	/* Generate query profile rearrange query sequence & calculate the weight of match/mismatch */
	for (nt = 0; LIKELY(nt < n); nt ++) {
		for (i = 0; i < segLen; i ++) {
			j = i;
			for (segNum = 0; LIKELY(segNum < 8) ; segNum ++) {
				*t++ = j>= readLen ? 0 : mat[nt * n + read_num[j]];
				j += segLen;
			}
		}
	}
	return vProfile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x7, %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
imull -0x1c(%rbp), %eax
movslq %eax, %rdi
shlq $0x4, %rdi
callq 0x3420
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x108c9
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x108b9
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
cmpl $0x8, -0x40(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x108a9
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jl 0x1085a
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x1087d
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movslq -0x3c(%rbp), %rsi
movsbl (%rdx,%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movw %ax, %cx
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x2, %rdx
movq %rdx, -0x30(%rbp)
movw %cx, (%rax)
movl -0x1c(%rbp), %eax
addl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x10837
jmp 0x108ab
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1081e
jmp 0x108bb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x107fd
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: seq_reverse
static int8_t* seq_reverse(const int8_t* seq, int32_t end)	/* end is 0-based alignment ending position */
{
	int8_t* reverse = (int8_t*)calloc(end + 1, sizeof(int8_t));
	int32_t start = 0;
	while (LIKELY(start <= end)) {
		reverse[start] = seq[end];
		reverse[end] = seq[start];
		++ start;
		-- end;
	}
	return reverse;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x3310
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x13243
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x131ed
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: add_cigar
uint32_t* add_cigar (uint32_t* new_cigar, int32_t* p, int32_t* s, uint32_t length, char op) {
	if ((*p) >= (*s)) {
		++(*s);
		kroundup32(*s);
		new_cigar = (uint32_t*)realloc(new_cigar, (*s)*sizeof(uint32_t));
	}
	new_cigar[(*p) ++] = to_cigar_int(length, op);
	return new_cigar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x1426c
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl $0x2, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl $0x4, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl $0x8, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
sarl $0x10, %ecx
movq -0x18(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x3470
movq %rax, -0x8(%rbp)
movl -0x1c(%rbp), %edi
movsbl -0x1d(%rbp), %esi
callq 0x142a0
movl %eax, %edx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sc932[P]ALE/src/ssw.c
// Function: store_previous_m
uint32_t* store_previous_m (int8_t choice,	// 0: current not M, 1: current match, 2: current mismatch
					   uint32_t* length_m,
					   uint32_t* length_x,
					   int32_t* p,
					   int32_t* s,
					   uint32_t* new_cigar) {

	if ((*length_m) && (choice == 2 || !choice)) {
		new_cigar = add_cigar (new_cigar, p, s, (*length_m), '='); 
		(*length_m) = 0;
	} else if ((*length_x) && (choice == 1 || !choice)) { 
		new_cigar = add_cigar (new_cigar, p, s, (*length_x), 'X'); 
		(*length_x) = 0;
	}
	return new_cigar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x14337
movsbl -0x1(%rbp), %eax
cmpl $0x2, %eax
je 0x1430a
cmpb $0x0, -0x1(%rbp)
jne 0x14337
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x3d, %r8d
callq 0x141b0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1437c
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1437a
movsbl -0x1(%rbp), %eax
cmpl $0x1, %eax
je 0x1434f
cmpb $0x0, -0x1(%rbp)
jne 0x1437a
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movl $0x58, %r8d
callq 0x141b0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
jmp 0x1437c
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src_con12/con12safe.cpp
// Function: usage()
void usage(void){
	fputs("con12: output stderr to stdout with buffering\n", stderr);
	fputs("usage: con12 <command> [args]\n", stderr);
	fputs("\nCopyright (C) 2021 Ryuichi Ueda\n", stderr);
	fputs("Released under the MIT License.\n", stderr);
	fputs("https://github.com/ryuichiueda/glueutils\n", stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2d25(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xd3f(%rip), %rdi       # 0x2004
callq 0x10f0
movq 0x2d0f(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xd58(%rip), %rdi       # 0x2033
callq 0x10f0
movq 0x2cf9(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xd61(%rip), %rdi       # 0x2052
callq 0x10f0
movq 0x2ce3(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xd6d(%rip), %rdi       # 0x2074
callq 0x10f0
movq 0x2ccd(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xd78(%rip), %rdi       # 0x2095
callq 0x10f0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ryuichiueda[P]glueutils/src_con12/con12safe.cpp
// Function: thread_read(void*)
void *thread_read(void *arg)
{
	int *fd = (int *)arg;
	char buf[1024];
	string line;
	int ret = 1;
	while (ret > 0){
		ret = read(*fd, &buf, 1024);
		for(int i=0;i<ret;i++){
			line += buf[i];
			if(buf[i] == '\n'){
				mtx.lock();
				fputs(line.c_str(), stdout);
				fflush(stdout);
				mtx.unlock();
				line.clear();
			}
		}
	}
	mtx.lock();
	fputs(line.c_str(), stdout);
	fflush(stdout);
	mtx.unlock();

	if(ret == -1){
		fputs("Error: reading error\n", stderr);
		exit(1);
	}
	try_close(*fd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x1140
movl $0x1, -0x434(%rbp)
cmpl $0x0, -0x434(%rbp)
jle 0x14cd
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x1160
movq %rax, -0x450(%rbp)
jmp 0x13da
movq -0x450(%rbp), %rax
movl %eax, -0x434(%rbp)
movl $0x0, -0x448(%rbp)
movl -0x448(%rbp), %eax
cmpl -0x434(%rbp), %eax
jge 0x14c8
movslq -0x448(%rbp), %rax
movsbl -0x410(%rbp,%rax), %esi
leaq -0x430(%rbp), %rdi
callq 0x1090
jmp 0x1420
movslq -0x448(%rbp), %rax
movsbl -0x410(%rbp,%rax), %eax
cmpl $0xa, %eax
jne 0x14b2
leaq 0x2cbd(%rip), %rdi      # 0x40f8
callq 0x1820
jmp 0x1442
leaq -0x430(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
movq 0x2b70(%rip), %rax      # 0x3fc8
movq (%rax), %rsi
callq 0x10f0
jmp 0x1462
movq 0x2b5f(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
callq 0x1100
jmp 0x1473
leaq 0x2c7e(%rip), %rdi      # 0x40f8
callq 0x1850
jmp 0x1481
leaq -0x430(%rbp), %rdi
callq 0x1120
jmp 0x14b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x440(%rbp)
movl %eax, -0x444(%rbp)
leaq -0x430(%rbp), %rdi
callq 0x1080
jmp 0x1569
jmp 0x14b4
movl -0x448(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x448(%rbp)
jmp 0x13f1
jmp 0x13ad
leaq 0x2c24(%rip), %rdi      # 0x40f8
callq 0x1820
jmp 0x14db
leaq -0x430(%rbp), %rdi
callq 0x1070
movq %rax, %rdi
movq 0x2ad7(%rip), %rax      # 0x3fc8
movq (%rax), %rsi
callq 0x10f0
jmp 0x14fb
movq 0x2ac6(%rip), %rax      # 0x3fc8
movq (%rax), %rdi
callq 0x1100
jmp 0x150c
leaq 0x2be5(%rip), %rdi      # 0x40f8
callq 0x1850
jmp 0x151a
cmpl $-0x1, -0x434(%rbp)
jne 0x1545
movq 0x2ab6(%rip), %rax      # 0x3fe0
movq (%rax), %rsi
leaq 0xb96(%rip), %rdi       # 0x20ca
callq 0x10f0
jmp 0x153b
movl $0x1, %edi
callq 0x1110
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x1330
jmp 0x1552
leaq -0x430(%rbp), %rdi
callq 0x1080
xorl %eax, %eax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
movq -0x440(%rbp), %rdi
callq 0x1180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.10/socket-server.c
// Function: server
int server(int client_socket)
{
    while (1)
    {
        int length;
        char *text;
        /* First, read the length of the text message from the socket. If read returns zero, the client closed the connection. */
        if (read(client_socket, &length, sizeof(length)) == 0)
            return 0;
        /* Allocate a buffer to hold the text. */
        text = (char *)malloc(length);
        /* Read the text itself, and print it. */

        read(client_socket, text, length);
        printf("%s\n", text);

        /* If the client sent the message "quit," we’re all done. */
        if (!strcmp(text, "quit"))
        {
            free(text);
            return 1;
        }
        /* Free the buffer. */
        free(text);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x1090
cmpq $0x0, %rax
jne 0x122b
movl $0x0, -0x4(%rbp)
jmp 0x128f
movslq -0xc(%rbp), %rdi
callq 0x10b0
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x1090
movq -0x18(%rbp), %rsi
leaq 0xdb1(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1070
movq -0x18(%rbp), %rdi
leaq 0xda3(%rip), %rsi       # 0x2008
callq 0x10a0
cmpl $0x0, %eax
jne 0x1281
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x128f
movq -0x18(%rbp), %rdi
callq 0x1030
jmp 0x120b
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.10/socket-server.c
// Function: main
int main(int argc, char *const argv[])
{
    const char *const socket_name = argv[1];
    int socket_fd;
    struct sockaddr_un name;
    int client_sent_quit_message;

    /* Create the socket. */
    socket_fd = socket(PF_LOCAL, SOCK_STREAM, 0);

    /*Indicate that this is a server.*/
    name.sun_family = AF_LOCAL;
    strcpy(name.sun_path, socket_name);
    bind(socket_fd, (struct sockaddr *)&name, SUN_LEN(&name));
    /* Listen for connections. */
    listen(socket_fd, 5);

    /*Repeatedly accept connections, spinning off one server() to deal
  with each client. Continue until a client sends a "quit" message.*/

    do
    {
        struct sockaddr_un client_name;
        socklen_t client_name_len;
        int client_socket_fd;

        /*Accept a connection.*/
        client_socket_fd = accept(socket_fd, (struct sockaddr *restrict)&client_name, &client_name_len);
        /* Handle the connection. */
        client_sent_quit_message = server(client_socket_fd);
        /* Close our end of the connection. */
        close(client_socket_fd);
    } while (!client_sent_quit_message);
    /* Remove the socket file. */
    close(socket_fd);
    unlink(socket_name);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x10f0
movl %eax, -0x1c(%rbp)
movw $0x1, -0x8a(%rbp)
leaq -0x8a(%rbp), %rdi
addq $0x2, %rdi
movq -0x18(%rbp), %rsi
callq 0x1050
movl -0x1c(%rbp), %eax
movl %eax, -0x10c(%rbp)
leaq -0x8a(%rbp), %rdi
addq $0x2, %rdi
callq 0x1060
movl -0x10c(%rbp), %edi
movq %rax, %rcx
xorl %eax, %eax
addq $0x2, %rax
addq %rcx, %rax
movl %eax, %edx
leaq -0x8a(%rbp), %rsi
callq 0x10d0
movl -0x1c(%rbp), %edi
movl $0x5, %esi
callq 0x10c0
movl -0x1c(%rbp), %edi
leaq -0xfe(%rbp), %rsi
leaq -0x104(%rbp), %rdx
callq 0x10e0
movl %eax, -0x108(%rbp)
movl -0x108(%rbp), %edi
callq 0x1200
movl %eax, -0x90(%rbp)
movl -0x108(%rbp), %edi
callq 0x1080
cmpl $0x0, -0x90(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1339
movl -0x1c(%rbp), %edi
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x1040
xorl %eax, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jarun[P]nnn/src/nnn.c
// Function: check_key_collision
static void check_key_collision(void)
{
	wint_t key;
	bool bitmap[KEY_MAX] = {FALSE};

	for (ullong_t i = 0; i < ELEMENTS(bindings); ++i) {
		key = bindings[i].sym;

		if (bitmap[key])
			fprintf(stderr, "key collision! [%s]\n", keyname(key));
		else
			bitmap[key] = TRUE;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x4380
movq $0x0, -0x218(%rbp)
cmpq $0x58, -0x218(%rbp)
jae 0x5dd8
movq -0x218(%rbp), %rcx
leaq 0x1a76f(%rip), %rax     # 0x204e0
movl (%rax,%rcx,8), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
testb $0x1, -0x210(%rbp,%rax)
je 0x5db7
movq 0x1a26d(%rip), %rax     # 0x1fff8
movq (%rax), %rax
movq %rax, -0x220(%rbp)
movl -0x4(%rbp), %edi
callq 0x48a0
movq -0x220(%rbp), %rdi
movq %rax, %rdx
leaq 0x15e63(%rip), %rsi     # 0x1bc11
movb $0x0, %al
callq 0x4510
jmp 0x5dc2
movl -0x4(%rbp), %eax
movb $0x1, -0x210(%rbp,%rax)
jmp 0x5dc4
movq -0x218(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x218(%rbp)
jmp 0x5d59
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)