LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/string_alloc.c
// Function: string_alloc
char *string_alloc(string_alloc_t *a_str, size_t length) {
    string_t *str;
    char *ret;

    if (length <= 0) return NULL;

    // add to last string pool if we have space
    if (a_str->nstrings) {
        str = &a_str->strings[a_str->nstrings - 1];

        if (str->used + length < a_str->max_length) {
            ret = str->str + str->used;
            str->used += length;
            return ret;
        }
    }

    // increase the max length if needs be
    if (length > a_str->max_length) a_str->max_length = length;

    // need a new string pool
    str = new_string_pool(a_str);

    if (NULL == str) return NULL;

    str->used = length;
    return str->str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
ja 0x82444
movq $0x0, -0x8(%rbp)
jmp 0x82500
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x824b2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x824b0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x82500
jmp 0x824b2
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x824ca
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x82510
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x824e9
movq $0x0, -0x8(%rbp)
jmp 0x82500
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/string_alloc.c
// Function: new_string_pool
static string_t *new_string_pool(string_alloc_t *a_str) {
    string_t *str;

    if (a_str->nstrings == a_str->max_strings) {
        size_t new_max = (a_str->max_strings | (a_str->max_strings >> 2)) + 1;
        str = realloc(a_str->strings, new_max * sizeof(*a_str->strings));

        if (NULL == str) return NULL;

        a_str->strings = str;
        a_str->max_strings = new_max;
    }

    str = &a_str->strings[a_str->nstrings];

    str->str = malloc(a_str->max_length);

    if (NULL == str->str) return NULL;

    str->used = 0;
    a_str->nstrings++;

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x82593
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
shrq $0x2, %rcx
orq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x4, %rsi
callq 0x4820
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x8257b
movq $0x0, -0x8(%rbp)
jmp 0x825fd
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4650
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x825d9
movq $0x0, -0x8(%rbp)
jmp 0x825fd
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/string_alloc.c
// Function: string_ndup
char *string_ndup(string_alloc_t *a_str, const char *instr, size_t len) {
    char *str = string_alloc(a_str, len + 1);

    if (NULL == str) return NULL;

    memcpy(str, instr, len);
    str[len] = 0;

    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x82420
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x8268b
movq $0x0, -0x8(%rbp)
jmp 0x826b0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x43b0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/arith_dynamic.c
// Function: arith_compress_bound
unsigned int arith_compress_bound(unsigned int size, int order) {
    int N = (order>>8) & 0xff;
    if (!N) N=4;
    return (order == 0
        ? 1.05*size + 257*3 + 4
        : 1.05*size + 257*257*3 + 4 + 257*3+4) + 5 +
        ((order & X_PACK) ? 1 : 0) +
        ((order & X_RLE) ? 1 + 257*3+4: 0) +
        ((order & X_STRIPE) ? 7 + 5*N: 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x826e5
movl $0x4, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x8271e
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x72e85(%rip), %xmm1    # 0xf5580
mulsd %xmm1, %xmm0
movsd 0x73ad9(%rip), %xmm1    # 0xf61e0
addsd %xmm1, %xmm0
movsd 0x72e45(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x82767
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x72e52(%rip), %xmm1    # 0xf5580
mulsd %xmm1, %xmm0
movsd 0x73aae(%rip), %xmm1    # 0xf61e8
addsd %xmm1, %xmm0
movsd 0x72e12(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd 0x73a8e(%rip), %xmm1    # 0xf61e0
addsd %xmm1, %xmm0
movsd 0x72dfa(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x73a7c(%rip), %xmm1    # 0xf61f0
addsd %xmm1, %xmm0
movl -0x8(%rbp), %edx
andl $0x80, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movl -0x8(%rbp), %edx
andl $0x40, %edx
xorl %eax, %eax
movl $0x308, %ecx            # imm = 0x308
cmpl $0x0, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x8(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x827cd
imull $0x5, -0xc(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x24(%rbp)
jmp 0x827d4
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x827d4
movsd -0x20(%rbp), %xmm0
movl -0x24(%rbp), %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/arith_dynamic.c
// Function: arith_uncompress_O0
static
unsigned char *arith_uncompress_O0(unsigned char *in, unsigned int in_size,
                                   unsigned char *out, unsigned int out_sz) {
    RangeCoder rc;
    int i;
    unsigned int m = in[0] ? in[0] : 256;

    SIMPLE_MODEL(256,_) byte_model;
    SIMPLE_MODEL(256,_init)(&byte_model, m);

    unsigned char *out_free = NULL;
    if (!out)
        out_free = out = malloc(out_sz);
    if (!out)
        return NULL;

    RC_SetInput(&rc, (char *)in+1, (char *)in+in_size);
    RC_StartDecode(&rc);

    for (i = 0; i < out_sz; i++)
        out[i] = SIMPLE_MODEL(256, _decodeSymbol)(&byte_model, &rc);

    if (RC_FinishDecode(&rc) < 0) {
        free(out_free);
        return NULL;
    }
    
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x490, %rsp            # imm = 0x490
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x857c4
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x48c(%rbp)
jmp 0x857d1
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x48c(%rbp)
jmp 0x857d1
movl -0x48c(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %esi
leaq -0x480(%rbp), %rdi
callq 0x859d0
movq $0x0, -0x488(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x85810
movl -0x24(%rbp), %eax
movl %eax, %edi
callq 0x4650
movq %rax, -0x20(%rbp)
movq %rax, -0x488(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x85824
movq $0x0, -0x8(%rbp)
jmp 0x858ab
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %eax
addq %rax, %rdx
leaq -0x68(%rbp), %rdi
callq 0x860a0
leaq -0x68(%rbp), %rdi
callq 0x860e0
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x8587f
leaq -0x480(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x861a0
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x6c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x8584f
leaq -0x68(%rbp), %rdi
callq 0x86420
cmpl $0x0, %eax
jge 0x858a3
movq -0x488(%rbp), %rdi
callq 0x45a0
movq $0x0, -0x8(%rbp)
jmp 0x858ab
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x490, %rsp            # imm = 0x490
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/c_range_coder.h
// Function: RC_StartEncode
static inline void RC_StartEncode(RangeCoder *rc)
{ 
    rc->range = 0xFFFFFFFF;
    rc->low   = 0;
    rc->FFNum = 0;
    rc->Carry = 0;
    rc->Cache = 0;
    rc->code  = 0;
    rc->err   = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/c_range_coder.h
// Function: RC_Encode
static inline void RC_Encode (RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t totFreq) 
{
    uint32_t tmp = rc->low;
    rc->low  += cumFreq * (rc->range/= totFreq);
    rc->range*= freq;

    rc->Carry += rc->low<tmp; // Overflow

    while (rc->range < TOP) {
        rc->range <<= 8;
        RC_ShiftLowCheck(rc);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %esi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
xorl %edx, %edx
divl %esi
movq -0x20(%rbp), %rdx
movl %eax, 0x8(%rdx)
imull %eax, %ecx
movq -0x8(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
setb %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
addl 0x14(%rax), %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1000000, 0x8(%rax)   # imm = 0x1000000
jae 0x85ed3
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
shll $0x8, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x85f40
jmp 0x85eae
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/c_range_coder.h
// Function: RC_ShiftLowCheck
static inline void RC_ShiftLowCheck(RangeCoder *rc) {
    if (rc->low < Thres || rc->Carry) {
        if (rc->out_end && rc->FFNum >= rc->out_end - rc->out_buf) {
            rc->err = -1;
            return;
        }

        *rc->out_buf++ = rc->Cache + rc->Carry;

        // Flush any stored FFs
        while (rc->FFNum) {
            *rc->out_buf++ = rc->Carry-1; // (Carry-1)&255;
            rc->FFNum--;
        }

        // Take copy of top byte ready for next flush
        rc->Cache = rc->low >> 24;
        rc->Carry = 0;
    } else {
        // Low if FFxx xxxx.  Bump FF count and shift in as before
        rc->FFNum++;
    }
    rc->low = rc->low<<8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0xff000000, (%rax)     # imm = 0xFF000000
jb 0x85f62
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x86018
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x85f9c
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jl 0x85f9c
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
jmp 0x86034
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x14(%rcx), %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x20(%rdx)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x85ffb
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rdx
movq 0x20(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x20(%rdx)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x85fc1
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shrl $0x18, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
jmp 0x86025
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/c_range_coder.h
// Function: RC_StartDecode
static inline void RC_StartDecode(RangeCoder *rc)
{ 
    rc->range = 0xFFFFFFFF;
    rc->low   = 0;
    rc->FFNum = 0;
    rc->Carry = 0;
    rc->Cache = 0;
    rc->code  = 0;
    rc->err   = 0;
    if (rc->in_buf+5 > rc->in_end) {
        rc->in_buf = rc->in_end; // prevent decode
        return;
    }
    DO(5) rc->code = (rc->code<<8) | *rc->in_buf++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x5, %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x8615c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x8619d
movl $0x0, -0xc(%rbp)
cmpl $0x5, -0xc(%rbp)
jge 0x8619d
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movzbl (%rax), %eax
orl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x86163
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/c_range_coder.h
// Function: RC_Decode
static inline void RC_Decode (RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t totFreq) 
{
    rc->code -= cumFreq * rc->range;
    rc->range *= freq;
    while (rc->range < TOP) {
        if (rc->in_buf >= rc->in_end) {
            rc->err = -1;
            return;
        }
        rc->code = (rc->code<<8) + *rc->in_buf++;
        rc->range <<= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
imull 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
imull 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1000000, 0x8(%rax)   # imm = 0x1000000
jae 0x8653a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x86502
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
jmp 0x8653a
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
movzbl (%rax), %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
shll $0x8, %ecx
movl %ecx, 0x8(%rax)
jmp 0x864d6
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/fqzcomp_qual.c
// Function: fqz_compress
char *fqz_compress(int vers, fqz_slice *s, char *in, size_t uncomp_size,
                   size_t *comp_size, int strat, fqz_gparams *gp) {
    if (uncomp_size > INT_MAX) {
        *comp_size = 0;
        return NULL;
    }

    return (char *)compress_block_fqz2f(vers, strat, s, (unsigned char *)in,
                                        uncomp_size, comp_size, gp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jbe 0x88192
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x881b9
movl -0xc(%rbp), %edi
movl -0x34(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x881d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/fqzcomp_qual.c
// Function: fqz_store_parameters
static 
int fqz_store_parameters(fqz_gparams *gp, unsigned char *comp) {
    int comp_idx = 0;
    comp[comp_idx++] = gp->vers; // Format number

    comp[comp_idx++] = gp->gflags;

    if (gp->gflags & GFLAG_MULTI_PARAM)
        comp[comp_idx++] = gp->nparam;

    if (gp->gflags & GFLAG_HAVE_STAB) {
        comp[comp_idx++] = gp->max_sel;
        comp_idx += store_array(comp+comp_idx, gp->stab, 256);
    }

    int i;
    for (i = 0; i < gp->nparam; i++)
        comp_idx += fqz_store_parameters1(&gp->p[i], comp+comp_idx);

    //fprintf(stderr, "Encoded %d bytes of param\n", comp_idx);
    return comp_idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8a61f
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x8a66f
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x8afd0
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x8a6bc
movq -0x8(%rbp), %rax
movq 0x418(%rax), %rdi
movslq -0x18(%rbp), %rax
imulq $0x1c64, %rax, %rax     # imm = 0x1C64
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
callq 0x8b280
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8a676
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/fqzcomp_qual.c
// Function: fqz_create_models
static int fqz_create_models(fqz_model *m, fqz_gparams *gp) {
    int i;

    if (!(m->qual = htscodecs_tls_alloc(sizeof(*m->qual) * CTX_SIZE)))
        return -1;

    for (i = 0; i < CTX_SIZE; i++)
        SIMPLE_MODEL(QMAX,_init)(&m->qual[i], gp->max_sym+1);

    for (i = 0; i < 4; i++)
        SIMPLE_MODEL(256,_init)(&m->len[i],256);

    SIMPLE_MODEL(2,_init)(&m->revcomp,2);
    SIMPLE_MODEL(2,_init)(&m->dup,2);
    if (gp->max_sel > 0)
        SIMPLE_MODEL(256,_init)(&m->sel, gp->max_sel+1);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x4100000, %edi        # imm = 0x4100000
callq 0xce6a0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x8a703
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8a7d2
movl $0x0, -0x1c(%rbp)
cmpl $0x10000, -0x1c(%rbp)   # imm = 0x10000
jge 0x8a745
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x410, %rax, %rax      # imm = 0x410
addq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x410(%rax), %esi
addl $0x1, %esi
callq 0x8b4b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a70a
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0x8a77d
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x410, %rax, %rax      # imm = 0x410
addq %rax, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x8b4b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8a74c
movq -0x10(%rbp), %rdi
addq $0x1048, %rdi           # imm = 0x1048
movl $0x2, %esi
callq 0x8b580
movq -0x10(%rbp), %rdi
addq $0x1470, %rdi           # imm = 0x1470
movl $0x2, %esi
callq 0x8b580
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jle 0x8a7cb
movq -0x10(%rbp), %rdi
addq $0x1060, %rdi           # imm = 0x1060
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0x8b4b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/pack.c
// Function: hts_unpack_meta
uint8_t hts_unpack_meta(uint8_t *data, uint32_t data_len,
                        uint64_t udata_len, uint8_t *map, int *nsym) {
    if (data_len == 0)
        return 0;

    // Number of symbols used
    unsigned int n = data[0];
    if (n == 0)
        n = 256;

    // Symbols per byte
    if (n <= 1)
        *nsym = 0;
    else if (n <= 2)
        *nsym = 8;
    else if (n <= 4)
        *nsym = 4;
    else if (n <= 16)
        *nsym = 2;
    else {
        *nsym = 1; // no packing
        return 1;
    }

    if (data_len <= 1)
        return 0;

    int j = 1, c = 0;
    do {
        map[c++] = data[j++];
    } while (c < n && j < data_len);

    return c < n ? 0 : j;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8d7a6
movb $0x0, -0x1(%rbp)
jmp 0x8d89d
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0x8d7bd
movl $0x100, -0x34(%rbp)     # imm = 0x100
cmpl $0x1, -0x34(%rbp)
ja 0x8d7cf
movq -0x30(%rbp), %rax
movl $0x0, (%rax)
jmp 0x8d81e
cmpl $0x2, -0x34(%rbp)
ja 0x8d7e1
movq -0x30(%rbp), %rax
movl $0x8, (%rax)
jmp 0x8d81c
cmpl $0x4, -0x34(%rbp)
ja 0x8d7f3
movq -0x30(%rbp), %rax
movl $0x4, (%rax)
jmp 0x8d81a
cmpl $0x10, -0x34(%rbp)
ja 0x8d805
movq -0x30(%rbp), %rax
movl $0x2, (%rax)
jmp 0x8d818
movq -0x30(%rbp), %rax
movl $0x1, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x8d89d
jmp 0x8d81a
jmp 0x8d81c
jmp 0x8d81e
cmpl $0x1, -0x14(%rbp)
ja 0x8d82a
movb $0x0, -0x1(%rbp)
jmp 0x8d89d
movl $0x1, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x38(%rbp)
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x3c(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x34(%rbp), %ecx
movb %al, -0x3d(%rbp)
jae 0x8d87b
movl -0x38(%rbp), %eax
cmpl -0x14(%rbp), %eax
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x8d838
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x8d891
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x8d897
movl -0x38(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static4x16pr.c
// Function: rans_compress_bound_4x16
unsigned int rans_compress_bound_4x16(unsigned int size, int order) {
    int N = (order>>8) & 0xff;
    if (!N) N=4;

    order &= 0xff;
    unsigned int sz = (order == 0
        ? 1.05*size + 257*3 + 4
        : 1.05*size + 257*257*3 + 4 + 257*3+4) +
        ((order & RANS_ORDER_PACK) ? 1 : 0) +
        ((order & RANS_ORDER_RLE) ? 1 + 257*3+4: 0) + 20 +
        ((order & RANS_ORDER_X32) ? (32-4)*4 : 0) +
        ((order & RANS_ORDER_STRIPE) ? 7 + 5*N: 0);
    return sz + (sz&1) + 2; // make this even so buffers are word aligned
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x8e2f5
movl $0x4, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x8e339
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x6726a(%rip), %xmm1    # 0xf5580
mulsd %xmm1, %xmm0
movsd 0x67ebe(%rip), %xmm1    # 0xf61e0
addsd %xmm1, %xmm0
movsd 0x6722a(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x8e382
movl -0x4(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0x67237(%rip), %xmm1    # 0xf5580
mulsd %xmm1, %xmm0
movsd 0x67e93(%rip), %xmm1    # 0xf61e8
addsd %xmm1, %xmm0
movsd 0x671f7(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd 0x67e73(%rip), %xmm1    # 0xf61e0
addsd %xmm1, %xmm0
movsd 0x671df(%rip), %xmm1    # 0xf5558
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movl -0x8(%rbp), %edx
andl $0x80, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movl -0x8(%rbp), %edx
andl $0x40, %edx
xorl %eax, %eax
movl $0x308, %ecx            # imm = 0x308
cmpl $0x0, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movsd 0x68048(%rip), %xmm1    # 0xf6410
addsd %xmm1, %xmm0
movl -0x8(%rbp), %edx
andl $0x4, %edx
xorl %eax, %eax
movl $0x70, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x8(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x8e403
imull $0x5, -0xc(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x24(%rbp)
jmp 0x8e40a
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x8e40a
movsd -0x20(%rbp), %xmm0
movl -0x24(%rbp), %eax
cvtsi2sd %eax, %xmm1
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x10(%rbp), %ecx
andl $0x1, %ecx
addl %ecx, %eax
addl $0x2, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static16_int.h
// Function: encode_freq
static inline int encode_freq(uint8_t *cp, uint32_t *F) {
    uint8_t *op = cp;
    int j;

    cp += encode_alphabet(cp, F);

    for (j = 0; j < 256; j++) {
        if (F[j])
            cp += var_put_u32(cp, NULL, F[j]);
    }

    return cp - op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x92a80
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jge 0x8f148
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x8f13b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x91410
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8f13d
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8f0fc
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_word.h
// Function: RansEncPutSymbol
static inline void RansEncPutSymbol(RansState* r, uint8_t** pptr, RansEncSymbol const* sym)
{
    //RansAssert(sym->x_max != 0); // can't encode symbol with freq=0

    // renormalize
    uint32_t x = *r;
    uint32_t x_max = sym->x_max;

#ifdef HTSCODECS_LITTLE_ENDIAN
    // Branchless renorm.
    //
    // This works best on high entropy data where branch prediction
    // is poor.
    //
    // Note the bit-packing and RLE modes are more likely to be used on
    // low entropy data, making this assertion generally true.  See
    // RansEncPutSymbol_branched for a low-entropy optimised function.

    // NB: "(x > x_max)*2" turns back into branched code with gcc.
    int c = (x > x_max); c*=2;
    memcpy(*pptr-2, &x, 2);
    x >>= c*8;
    *pptr = *pptr - c;
#else
    if (x > x_max) {
        uint8_t* ptr = *pptr;
        ptr -= 2;
        ptr[0] = x & 0xff;
        ptr[1] = (x >> 8) & 0xff;
        x >>= 16;
        *pptr = ptr;
    }
#endif

    // x = C(s,x)
    // NOTE: written this way so we get a 32-bit "multiply high" when
    // available. If you're on a 64-bit platform with cheap multiplies
    // (e.g. x64), just bake the +32 into rcp_shift.
    //uint32_t q = (uint32_t) (((uint64_t)x * sym->rcp_freq) >> 32) >> sym->rcp_shift;

    // Slow method, but robust
//    *r = ((x / sym->freq) << sym->scale_bits) + (x % sym->freq) + sym->start;
//    return;

    // The extra >>32 has already been added to RansEncSymbolInit
    uint32_t q = (uint32_t) (((uint64_t)x * sym->rcp_freq) >> sym->rcp_shift);
    *r = x + sym->bias + q * sym->cmpl_freq;

//    assert(((x / sym->freq) << sym->scale_bits) + (x % sym->freq) + sym->start == *r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
seta %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movw -0x1c(%rbp), %cx
movw %cx, -0x2(%rax)
movl -0x24(%rbp), %ecx
shll $0x3, %ecx
movl -0x1c(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq -0x24(%rbp), %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
imulq %rcx, %rax
movq -0x18(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
movl %ecx, %ecx
shrq %cl, %rax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x8(%rax), %ecx
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rdx
movzwl 0xc(%rdx), %edx
imull %edx, %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_word.h
// Function: RansEncFlush
static inline void RansEncFlush(RansState* r, uint8_t** pptr)
{
    uint32_t x = *r;
    uint8_t* ptr = *pptr;

    ptr -= 4;
    ptr[0] = (uint8_t) (x >> 0);
    ptr[1] = (uint8_t) (x >> 8);
    ptr[2] = (uint8_t) (x >> 16);
    ptr[3] = (uint8_t) (x >> 24);

    *pptr = ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
shrl $0x0, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x14(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x14(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static16_int.h
// Function: decode_freq
static inline int decode_freq(uint8_t *cp, uint8_t *cp_end, uint32_t *F,
                              uint32_t *fsum) {
    if (cp == cp_end)
        return 0;

    uint8_t *op = cp;
    cp += decode_alphabet(cp, cp_end, F);

    int j, tot = 0;
    for (j = 0; j < 256; j++) {
        if (F[j]) {
            cp += var_get_u32(cp, cp_end, (unsigned int *)&F[j]);
            tot += F[j];
        }
    }

    *fsum = tot;
    return cp - op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x8fa8e
movl $0x0, -0x4(%rbp)
jmp 0x8fb3d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x92ba0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jge 0x8fb26
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x8fb19
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movslq -0x34(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
callq 0x92440
movl %eax, %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x8fb1b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x8fac5
movl -0x38(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static16_int.h
// Function: normalise_freq_shift
static inline void normalise_freq_shift(uint32_t *F, uint32_t size,
                                        uint32_t max_tot) {
    if (size == 0 || size == max_tot)
        return;

    int shift = 0, i;
    while (size < max_tot)
        size*=2, shift++;

    for (i = 0; i < 256; i++)
        F[i] <<= shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x8fb6c
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jne 0x8fb6e
jmp 0x8fbc6
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x8fb90
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8fb75
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x8fbc6
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movl (%rax,%rdx,4), %edx
shll %cl, %edx
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8fb97
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_word.h
// Function: RansDecInit
static inline void RansDecInit(RansState* r, uint8_t** pptr)
{
    uint32_t x;
    uint8_t* ptr = *pptr;

    x  = ptr[0] << 0;
    x |= ptr[1] << 8;
    x |= ptr[2] << 16;
    x |= ((uint32_t)ptr[3]) << 24;
    ptr += 4;

    *pptr = ptr;
    *r = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x3(%rax), %eax
shll $0x18, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_word.h
// Function: RansDecRenorm
static inline void RansDecRenorm(RansState* r, uint8_t** pptr) {
    //       q4        q40
    // clang 730/608   717/467
    // gcc8  733/588   737/458
    uint32_t  x   = *r;
    uint8_t  *ptr = *pptr;
    __asm__ ("movzwl (%0),  %%eax\n\t"
             "mov    %1,    %%edx\n\t"
             "shl    $0x10, %%edx\n\t"
             "or     %%eax, %%edx\n\t"
             "xor    %%eax, %%eax\n\t"
             "cmp    $0x8000,%1\n\t"
             "cmovb  %%edx, %1\n\t"
             "lea    2(%0), %%rax\n\t"
             "cmovb  %%rax, %0\n\t"
             : "=r" (ptr), "=r" (x)
             : "0"  (ptr), "1"  (x)
             : "eax", "edx"
             );
    *pptr = (uint8_t *)ptr;
    *r = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %esi
movzwl (%rcx), %eax
movl %esi, %edx
shll $0x10, %edx
orl %eax, %edx
xorl %eax, %eax
cmpl $0x8000, %esi           # imm = 0x8000
cmovbl %edx, %esi
leaq 0x2(%rcx), %rax
cmovbq %rax, %rcx
movl %esi, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_word.h
// Function: RansDecRenormSafe
static inline void RansDecRenormSafe(RansState* r, uint8_t** pptr, uint8_t *ptr_end)
{
    uint32_t x = *r;
    if (x >= RANS_BYTE_L || *pptr+1 >= ptr_end) return;
    uint16_t y = (*pptr)[0] + ((*pptr)[1]<<8);
    x = (x << 16) | y;
    (*pptr) += 2;
    *r = x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x8000, -0x1c(%rbp)    # imm = 0x8000
jae 0x8fd23
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
cmpq -0x18(%rbp), %rax
jb 0x8fd25
jmp 0x8fd69
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movw %ax, -0x1e(%rbp)
movl -0x1c(%rbp), %eax
shll $0x10, %eax
movzwl -0x1e(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static4x16pr.c
// Function: htscodecs_tls_cpu_init
static void htscodecs_tls_cpu_init(void) {
    unsigned int eax = 0, ebx = 0, ecx = 0, edx = 0;
    // These may be unused, depending on HAVE_* config.h macros

    int level = __get_cpuid_max(0, NULL);
    __cpuid_count(0, 0, eax, ebx, ecx, edx);
    is_amd = (ecx == 0x444d4163);
    if (level >= 1) {
        __cpuid_count(1, 0, eax, ebx, ecx, edx);
#if defined(bit_SSSE3)
        have_ssse3 = ecx & bit_SSSE3;
#endif
#if defined(bit_POPCNT)
        have_popcnt = ecx & bit_POPCNT;
#endif
#if defined(bit_SSE4_1)
        have_sse4_1 = ecx & bit_SSE4_1;
#endif
    }
    if (level >= 7) {
        __cpuid_count(7, 0, eax, ebx, ecx, edx);
#if defined(bit_AVX2)
        have_avx2 = ebx & bit_AVX2;
#endif
#if defined(bit_AVX512F)
        have_avx512f = ebx & bit_AVX512F;
#endif
    }

    if (!have_popcnt) have_avx512f = have_avx2 = have_sse4_1 = 0;
    if (!have_ssse3)  have_sse4_1 = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x92df0
movl %eax, -0x14(%rbp)
xorl %ecx, %ecx
movl %ecx, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x18(%rbp)
movl %eax, %esi
movl -0x18(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x444d4163, -0xc(%rbp) # imm = 0x444D4163
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x82635(%rip)     # 0x11288c
cmpl $0x1, -0x14(%rbp)
jl 0x902aa
movl $0x1, %eax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x1c(%rbp)
movl %eax, %esi
movl -0x1c(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl $0x200, %eax            # imm = 0x200
movl %eax, 0x82602(%rip)     # 0x112890
movl -0xc(%rbp), %eax
andl $0x800000, %eax         # imm = 0x800000
movl %eax, 0x825f8(%rip)     # 0x112894
movl -0xc(%rbp), %eax
andl $0x80000, %eax          # imm = 0x80000
movl %eax, 0x825ee(%rip)     # 0x112898
cmpl $0x7, -0x14(%rbp)
jl 0x902ed
movl $0x7, %eax
xorl %ecx, %ecx
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %esi, -0x20(%rbp)
movl %eax, %esi
movl -0x20(%rbp), %eax
movl %esi, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0x20, %eax
movl %eax, 0x825bd(%rip)     # 0x11289c
movl -0x8(%rbp), %eax
andl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x825b3(%rip)     # 0x1128a0
cmpl $0x0, 0x825a0(%rip)     # 0x112894
jne 0x90314
movl $0x0, 0x82598(%rip)     # 0x112898
movl $0x0, 0x82592(%rip)     # 0x11289c
movl $0x0, 0x8258c(%rip)     # 0x1128a0
cmpl $0x0, 0x82575(%rip)     # 0x112890
jne 0x90327
movl $0x0, 0x82571(%rip)     # 0x112898
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static16_int.h
// Function: encode_alphabet
static inline int encode_alphabet(uint8_t *cp, uint32_t *F) {
    uint8_t *op = cp;
    int rle, j;

    for (rle = j = 0; j < 256; j++) {
        if (F[j]) {
            // j
            if (rle) {
                rle--;
            } else {
                *cp++ = j;
                if (!rle && j && F[j-1])  {
                    for(rle=j+1; rle<256 && F[rle]; rle++)
                        ;
                    rle -= j+1;
                    *cp++ = rle;
                }
                //fprintf(stderr, "%d: %d %d\n", j, rle, N[j]);
            }
        }
    }
    *cp++ = 0;
    
    return cp - op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jge 0x92b81
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x92b71
cmpl $0x0, -0x1c(%rbp)
je 0x92ad5
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92b6f
movl -0x20(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
cmpl $0x0, -0x1c(%rbp)
jne 0x92b6d
cmpl $0x0, -0x20(%rbp)
je 0x92b6d
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x92b6d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
movb %al, -0x21(%rbp)
jge 0x92b33
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x92b3c
jmp 0x92b49
jmp 0x92b3e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92b13
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x92b6f
jmp 0x92b71
jmp 0x92b73
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x92aa2
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static16_int.h
// Function: encode_freq_d
static inline int encode_freq_d(uint8_t *cp, uint32_t *F0, uint32_t *F) {
    uint8_t *op = cp;
    int j, dz;

    for (dz = j = 0; j < 256; j++) {
        if (F0[j]) {
            if (F[j] != 0) {
                if (dz) {
                    // Replace dz zeros with zero + dz-1 run length
                    cp -= dz-1;
                    *cp++ = dz-1;
                }
                dz = 0;
                cp += var_put_u32(cp, NULL, F[j]);
            } else {
                //fprintf(stderr, "2: j=%d F0[j]=%d, F[j]=%d, dz=%d\n", j, F0[j], F[j], dz);
                dz++;
                *cp++ = 0;
            }
        }
    }
    
    if (dz) {
        cp -= dz-1;
        *cp++ = dz-1;
    }

    return cp - op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x100, -0x24(%rbp)     # imm = 0x100
jge 0x93e7d
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x93e6d
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x93e50
cmpl $0x0, -0x28(%rbp)
je 0x93e1f
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %edx
xorl %eax, %eax
movl %eax, %esi
callq 0x91410
movl %eax, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x93e6b
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x0, (%rax)
jmp 0x93e6d
jmp 0x93e6f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x93dba
cmpl $0x0, -0x28(%rbp)
je 0x93eb5
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movslq %ecx, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movl -0x28(%rbp), %eax
subl $0x1, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)