// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/vcf.c
// Function: vcf_parse_format_fill5
static int vcf_parse_format_fill5(kstring_t *s, const bcf_hdr_t *h, bcf1_t *v,
                                  const char *p, const char *q, fmt_aux_t *fmt) {
    static int extreme_val_warned = 0;
    int n_sample_ori = -1;
    // At beginning of the loop t points to the first char of a format
    const char *t = q + 1;
    int m = 0;   // m: sample id
    const int nsamples = bcf_hdr_nsamples(h);
    const char *end = s->s + s->l;

    int ver = bcf_get_version(h, NULL);

    while ( t<end )
    {
        // can we skip some samples?
        if ( h->keep_samples )
        {
            n_sample_ori++;
            if ( !bit_array_test(h->keep_samples,n_sample_ori) )
            {
                while ( *t && t<end ) t++;
                t++;
                continue;
            }
        }
        if ( m == nsamples ) break;

        int j = 0; // j-th format field, m-th sample
        while ( t < end )
        {
            fmt_aux_t *z = &fmt[j++];
            const int htype = z->y>>4&0xf;
            if (!z->buf) {
                hts_log_error("Memory allocation failure for FORMAT field type %d at %s:%"PRIhts_pos,
                              z->y>>4&0xf, bcf_seqname_safe(h,v), v->pos+1);
                v->errcode |= BCF_ERR_LIMITS;
                return -1;
            }

            if ( z->size==-1 )
            {
                // this field is to be ignored, it's either too big or a duplicate
                while ( *t != ':' && *t ) t++;
            }
            else if (htype == BCF_HT_STR) {
                int l;
                if (z->is_gt) {
                    // Genotypes.
                    //([/|])?<val>)([|/]<val>)+... where <val> is [0-9]+ or ".".
                    int32_t is_phased = 0;
                    uint32_t *x = (uint32_t*)(z->buf + z->size * (size_t)m);
                    uint32_t unreadable = 0;
                    uint32_t max = 0;
                    int overflow = 0, ploidy = 0, anyunphased = 0, \
                        phasingprfx = 0, unknown1 = 0;

                    /* with prefixed phasing, it is explicitly given for 1st one
                    with non-prefixed, set based on ploidy and phasing of other
                    alleles. */
                    if (ver >= VCF44 && (*t == '|' || *t == '/')) {
                        // cache prefix and phasing status
                        is_phased = *t++ == '|';
                        phasingprfx = 1;
                    }

                    for (l = 0;; ++t) {
                        ploidy++;
                        if (*t == '.') {
                            ++t, x[l++] = is_phased;
                            if (l==1) {   //for 1st allele only
                                unknown1 = 1;
                            }
                        } else {
                            const char *tt = t;
                            uint32_t val;
                            // Or "v->n_allele < 10", but it doesn't
                            // seem to be any faster and this feels safer.
                            if (*t >= '0' && *t <= '9' &&
                                !(t[1] >= '0' && t[1] <= '9')) {
                                val = *t++ - '0';
                            } else {
                                val = hts_str2uint(t, (char **)&t,
                                                   sizeof(val) * CHAR_MAX - 2,
                                                   &overflow);
                                unreadable |= tt == t;
                            }
                            if (max < val) max = val;
                            x[l++] = (val + 1) << 1 | is_phased;
                        }
                        anyunphased |= (ploidy != 1) && !is_phased;
                        is_phased = (*t == '|');
                        if (*t != '|' && *t != '/') break;
                    }
                    if (ver >= VCF44 && !phasingprfx) {
                        /* no explicit phasing for 1st allele, set based on
                         other alleles and ploidy */
                        if (ploidy == 1) {  //implicitly phased
                            if (!unknown1) {
                                x[0] |= 1;
                            }
                        } else {            //set by other unphased alleles
                            x[0] |= (anyunphased)? 0 : 1;
                        }
                    }
                    // Possibly check max against v->n_allele instead?
                    if (overflow || max > (INT32_MAX >> 1) - 1) {
                        hts_log_error("Couldn't read GT data: value too large at %s:%"PRIhts_pos, bcf_seqname_safe(h,v), v->pos+1);
                        return -1;
                    }
                    if (unreadable) {
                        hts_log_error("Couldn't read GT data: value not a number or '.' at %s:%"PRIhts_pos, bcf_seqname_safe(h,v), v->pos+1);
                        return -1;
                    }
                    if ( !l ) x[l++] = 0;   // An empty field, insert missing value
                    for (; l < z->size>>2; ++l)
                        x[l] = bcf_int32_vector_end;

                } else {
                    // Otherwise arbitrary strings
                    char *x = (char*)z->buf + z->size * (size_t)m;
                    for (l = 0; *t != ':' && *t; ++t)
                        x[l++] = *t;
                    if (z->size > l)
                        memset(&x[l], 0, (z->size-l) * sizeof(*x));
                }

            } else if (htype == BCF_HT_INT) {
                // One or more integers in an array
                int32_t *x = (int32_t*)(z->buf + z->size * (size_t)m);
                int l;
                for (l = 0;; ++t) {
                    if (*t == '.') {
                        x[l++] = bcf_int32_missing, ++t; // ++t to skip "."
                    } else {
                        int overflow = 0;
                        char *te;
                        long int tmp_val = hts_str2int(t, &te, sizeof(tmp_val)*CHAR_BIT, &overflow);
                        if ( te==t || overflow || tmp_val<BCF_MIN_BT_INT32 || tmp_val>BCF_MAX_BT_INT32 )
                        {
                            if ( !extreme_val_warned )
                            {
                                hts_log_warning("Extreme FORMAT/%s value encountered and set to missing at %s:%"PRIhts_pos,
                                                h->id[BCF_DT_ID][fmt[j-1].key].key, bcf_seqname_safe(h,v), v->pos+1);
                                extreme_val_warned = 1;
                            }
                            tmp_val = bcf_int32_missing;
                        }
                        x[l++] = tmp_val;
                        t = te;
                    }
                    if (*t != ',') break;
                }
                if ( !l )
                    x[l++] = bcf_int32_missing;
                for (; l < z->size>>2; ++l)
                    x[l] = bcf_int32_vector_end;

            } else if (htype == BCF_HT_REAL) {
                // One of more floating point values in an array
                float *x = (float*)(z->buf + z->size * (size_t)m);
                int l;
                for (l = 0;; ++t) {
                    if (*t == '.' && !isdigit_c(t[1])) {
                        bcf_float_set_missing(x[l++]), ++t; // ++t to skip "."
                    } else {
                        int overflow = 0;
                        char *te;
                        float tmp_val = hts_str2dbl(t, &te, &overflow);
                        if ( (te==t || overflow) && !extreme_val_warned )
                        {
                            hts_log_warning("Extreme FORMAT/%s value encountered at %s:%"PRIhts_pos, h->id[BCF_DT_ID][fmt[j-1].key].key, bcf_seqname(h,v), v->pos+1);
                            extreme_val_warned = 1;
                        }
                        x[l++] = tmp_val;
                        t = te;
                    }
                    if (*t != ',') break;
                }
                if ( !l )
                    // An empty field, insert missing value
                    bcf_float_set_missing(x[l++]);
                for (; l < z->size>>2; ++l)
                    bcf_float_set_vector_end(x[l]);
            } else {
                hts_log_error("Unknown FORMAT field type %d at %s:%"PRIhts_pos, htype, bcf_seqname_safe(h,v), v->pos+1);
                v->errcode |= BCF_ERR_TAG_INVALID;
                return -1;
            }

            if (*t == '\0') {
                break;
            }
            else if (*t == ':') {
                t++;
            }
            else {
                char buffer[8];
                hts_log_error("Invalid character %s in '%s' FORMAT field at %s:%"PRIhts_pos"",
                    hts_strprint(buffer, sizeof buffer, '\'', t, 1),
                    h->id[BCF_DT_ID][z->key].key, bcf_seqname_safe(h,v), v->pos+1);
                v->errcode |= BCF_ERR_CHAR;
                return -1;
            }
        }

        // fill end-of-vector values
        for (; j < v->n_fmt; ++j) {
            fmt_aux_t *z = &fmt[j];
            const int htype = z->y>>4&0xf;
            int l;

            if (z->size == -1) // this field is to be ignored
                continue;

            if (htype == BCF_HT_STR) {
                if (z->is_gt) {
                    int32_t *x = (int32_t*)(z->buf + z->size * (size_t)m);
                    if (z->size) x[0] = bcf_int32_missing;
                    for (l = 1; l < z->size>>2; ++l) x[l] = bcf_int32_vector_end;
                } else {
                    char *x = (char*)z->buf + z->size * (size_t)m;
                    if ( z->size ) {
                        x[0] = '.';
                        memset(&x[1], 0, (z->size-1) * sizeof(*x));
                    }
                }
            } else if (htype == BCF_HT_INT) {
                int32_t *x = (int32_t*)(z->buf + z->size * (size_t)m);
                x[0] = bcf_int32_missing;
                for (l = 1; l < z->size>>2; ++l) x[l] = bcf_int32_vector_end;
            } else if (htype == BCF_HT_REAL) {
                float *x = (float*)(z->buf + z->size * (size_t)m);
                bcf_float_set_missing(x[0]);
                for (l = 1; l < z->size>>2; ++l) bcf_float_set_vector_end(x[l]);
            }
        }

        m++; t++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0xffffffff, -0x3c(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3cc20
movl %eax, -0x5c(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x5499b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x53ba7
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x140(%rbp)
movl -0x3c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x140(%rbp), %rax
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x134(%rbp)
movl -0x3c(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl -0x134(%rbp), %eax
movl %edx, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x53ba5
jmp 0x53b55
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x141(%rbp)
je 0x53b7a
movq -0x48(%rbp), %rax
cmpq -0x58(%rbp), %rax
setb %al
movb %al, -0x141(%rbp)
movb -0x141(%rbp), %al
testb $0x1, %al
jne 0x53b86
jmp 0x53b94
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53b55
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53ada
jmp 0x53ba7
movl -0x4c(%rbp), %eax
cmpl -0x50(%rbp), %eax
jne 0x53bb4
jmp 0x5499b
movl $0x0, -0x60(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x58(%rbp), %rax
jae 0x546cc
movq -0x38(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x60(%rbp)
movslq %ecx, %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x6c(%rbp)
movq -0x68(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x53c6e
movq -0x68(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x148(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movl -0x148(%rbp), %ecx
movq %rax, %r8
movq -0x20(%rbp), %rax
movq (%rax), %r9
addq $0x1, %r9
movl $0x1, %edi
leaq 0xb5239(%rip), %rsi     # 0x108e7a
leaq 0xb5249(%rip), %rdx     # 0x108e91
movb $0x0, %al
callq 0x9d90
movq -0x20(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x8, %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x549a2
movq -0x68(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x53cc0
jmp 0x53c7a
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x149(%rbp)
je 0x53ca1
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x149(%rbp)
movb -0x149(%rbp), %al
testb $0x1, %al
jne 0x53cad
jmp 0x53cbb
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53c7a
jmp 0x545ea
cmpl $0x3, -0x6c(%rbp)
jne 0x5413d
movq -0x68(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5407c
movl $0x0, -0x74(%rbp)
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x84(%rbp)
movl $0x0, -0x88(%rbp)
movl $0x0, -0x8c(%rbp)
movl $0x0, -0x90(%rbp)
movl $0x0, -0x94(%rbp)
movl $0x0, -0x98(%rbp)
movl $0x0, -0x9c(%rbp)
cmpl $0x3d18a0, -0x5c(%rbp)  # imm = 0x3D18A0
jl 0x53d94
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x53d6a
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x53d94
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movsbl (%rax), %eax
cmpl $0x7c, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movl $0x1, -0x98(%rbp)
movl $0x0, -0x70(%rbp)
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x53def
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movl -0x74(%rbp), %edx
movq -0x80(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x70(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x1, -0x70(%rbp)
jne 0x53dea
movl $0x1, -0x9c(%rbp)
jmp 0x53ec4
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x53e49
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jg 0x53e49
movq -0x48(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jl 0x53e2c
movq -0x48(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x39, %eax
jle 0x53e49
movq -0x48(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x48(%rbp)
movsbl (%rax), %eax
subl $0x30, %eax
movl %eax, -0xac(%rbp)
jmp 0x53e87
movq -0x48(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x1fa, %edx            # imm = 0x1FA
leaq -0x8c(%rbp), %rcx
callq 0x45d80
movl %eax, -0xac(%rbp)
movq -0xa8(%rbp), %rax
cmpq -0x48(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
orl -0x84(%rbp), %eax
movl %eax, -0x84(%rbp)
movl -0x88(%rbp), %eax
cmpl -0xac(%rbp), %eax
jae 0x53ea1
movl -0xac(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0xac(%rbp), %edx
addl $0x1, %edx
shll %edx
orl -0x74(%rbp), %edx
movq -0x80(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x70(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
xorl %eax, %eax
cmpl $0x1, -0x90(%rbp)
movb %al, -0x14a(%rbp)
je 0x53ee4
cmpl $0x0, -0x74(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x14a(%rbp)
movb -0x14a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl -0x94(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x74(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x53f2a
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x53f2a
jmp 0x53f3d
jmp 0x53f2c
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53d9b
cmpl $0x3d18a0, -0x5c(%rbp)  # imm = 0x3D18A0
jl 0x53f8b
cmpl $0x0, -0x98(%rbp)
jne 0x53f8b
cmpl $0x1, -0x90(%rbp)
jne 0x53f6e
cmpl $0x0, -0x9c(%rbp)
jne 0x53f6c
movq -0x80(%rbp), %rax
movl (%rax), %ecx
orl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x53f89
movl -0x94(%rbp), %edx
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x80(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x53f8b
cmpl $0x0, -0x8c(%rbp)
jne 0x53fa0
cmpl $0x3ffffffe, -0x88(%rbp) # imm = 0x3FFFFFFE
jbe 0x53fe1
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movl $0x1, %edi
leaq 0xb4eb3(%rip), %rsi     # 0x108e7a
leaq 0xb4f00(%rip), %rdx     # 0x108ece
movb $0x0, %al
callq 0x9d90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x549a2
cmpl $0x0, -0x84(%rbp)
je 0x5402b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rax), %r8
addq $0x1, %r8
movl $0x1, %edi
leaq 0xb4e69(%rip), %rsi     # 0x108e7a
leaq 0xb4ee7(%rip), %rdx     # 0x108eff
movb $0x0, %al
callq 0x9d90
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x549a2
cmpl $0x0, -0x70(%rbp)
jne 0x5404a
movq -0x80(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x70(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x5404c
movl -0x70(%rbp), %eax
movq -0x68(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x54077
movq -0x80(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl $0x80000001, (%rax,%rcx,4) # imm = 0x80000001
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x5404c
jmp 0x54138
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0x70(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x14b(%rbp)
je 0x540cc
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x14b(%rbp)
movb -0x14b(%rbp), %al
testb $0x1, %al
jne 0x540d8
jmp 0x54104
movq -0x48(%rbp), %rax
movb (%rax), %dl
movq -0xb8(%rbp), %rax
movl -0x70(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x70(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x540a5
movq -0x68(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x70(%rbp), %eax
jle 0x54136
movq -0xb8(%rbp), %rdi
movslq -0x70(%rbp), %rax
addq %rax, %rdi
movq -0x68(%rbp), %rax
movl 0x8(%rax), %eax
subl -0x70(%rbp), %eax
movslq %eax, %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x4240
jmp 0x54138
jmp 0x545e8
cmpl $0x1, -0x6c(%rbp)
jne 0x5435c
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
movl $0x0, -0xc4(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x541b2
movq -0xc0(%rbp), %rax
movl -0xc4(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc4(%rbp)
movslq %ecx, %rcx
movl $0x80000000, (%rax,%rcx,4) # imm = 0x80000000
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x542cf
movl $0x0, -0xc8(%rbp)
movq -0x48(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movl $0x40, %edx
leaq -0xc8(%rbp), %rcx
callq 0x52630
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x54213
cmpl $0x0, -0xc8(%rbp)
jne 0x54213
cmpq $-0x7ffffff8, -0xd8(%rbp) # imm = 0x80000008
jl 0x54213
cmpq $0x7fffffff, -0xd8(%rbp) # imm = 0x7FFFFFFF
jle 0x5429d
cmpl $0x0, 0xd65a6(%rip)     # 0x12a7c0
jne 0x54292
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movl -0x60(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x158(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movq -0x158(%rbp), %rcx
movq %rax, %r8
movq -0x20(%rbp), %rax
movq (%rax), %r9
addq $0x1, %r9
movl $0x3, %edi
leaq 0xb4c00(%rip), %rsi     # 0x108e7a
leaq 0xb4cb9(%rip), %rdx     # 0x108f3a
movb $0x0, %al
callq 0x9d90
movl $0x1, 0xd652e(%rip)     # 0x12a7c0
movq $-0x80000000, -0xd8(%rbp) # imm = 0x80000000
movq -0xd8(%rbp), %rax
movl %eax, %edx
movq -0xc0(%rbp), %rax
movl -0xc4(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0xc4(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0xd0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x542dd
jmp 0x542f0
jmp 0x542df
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x54173
cmpl $0x0, -0xc4(%rbp)
jne 0x5431b
movq -0xc0(%rbp), %rax
movl -0xc4(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc4(%rbp)
movslq %ecx, %rcx
movl $0x80000000, (%rax,%rcx,4) # imm = 0x80000000
jmp 0x5431d
movl -0xc4(%rbp), %eax
movq -0x68(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x54357
movq -0xc0(%rbp), %rax
movslq -0xc4(%rbp), %rcx
movl $0x80000001, (%rax,%rcx,4) # imm = 0x80000001
movl -0xc4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc4(%rbp)
jmp 0x5431d
jmp 0x545e6
cmpl $0x2, -0x6c(%rbp)
jne 0x54581
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x68(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0xe0(%rbp)
movl $0x0, -0xe4(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x543ed
movq -0x48(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0x54e60
cmpl $0x0, %eax
jne 0x543ed
movq -0xe0(%rbp), %rdi
movl -0xe4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xe4(%rbp)
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl 0xd1269(%rip), %esi     # 0x125640
callq 0x40e90
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x544e2
movl $0x0, -0xe8(%rbp)
movq -0x48(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x528b0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xf4(%rbp)
movq -0xf0(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0x54430
cmpl $0x0, -0xe8(%rbp)
je 0x544af
cmpl $0x0, 0xd6389(%rip)     # 0x12a7c0
jne 0x544af
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movl -0x60(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x160(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x49c60
movq -0x160(%rbp), %rcx
movq %rax, %r8
movq -0x20(%rbp), %rax
movq (%rax), %r9
addq $0x1, %r9
movl $0x3, %edi
leaq 0xb49e3(%rip), %rsi     # 0x108e7a
leaq 0xb4add(%rip), %rdx     # 0x108f7b
movb $0x0, %al
callq 0x9d90
movl $0x1, 0xd6311(%rip)     # 0x12a7c0
movss -0xf4(%rbp), %xmm0
movq -0xe0(%rbp), %rax
movl -0xe4(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xe4(%rbp)
movslq %ecx, %rcx
movss %xmm0, (%rax,%rcx,4)
movq -0xf0(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
je 0x544f0
jmp 0x54503
jmp 0x544f2
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x54392
cmpl $0x0, -0xe4(%rbp)
jne 0x54538
movq -0xe0(%rbp), %rdi
movl -0xe4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xe4(%rbp)
cltq
shlq $0x2, %rax
addq %rax, %rdi
movl 0xd110d(%rip), %esi     # 0x125640
callq 0x40e90
jmp 0x5453a
movl -0xe4(%rbp), %eax
movq -0x68(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x5457f
movq -0xe0(%rbp), %rdi
movslq -0xe4(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl 0xd10db(%rip), %esi     # 0x125644
callq 0x40e90
movl -0xe4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe4(%rbp)
jmp 0x5453a
jmp 0x545e4
movl -0x6c(%rbp), %eax
movl %eax, -0x164(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movl -0x164(%rbp), %ecx
movq %rax, %r8
movq -0x20(%rbp), %rax
movq (%rax), %r9
addq $0x1, %r9
movl $0x1, %edi
leaq 0xb48c3(%rip), %rsi     # 0x108e7a
leaq 0xb49eb(%rip), %rdx     # 0x108fa9
movb $0x0, %al
callq 0x9d90
movq -0x20(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x549a2
jmp 0x545e6
jmp 0x545e8
jmp 0x545ea
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x545fb
jmp 0x546cc
movq -0x48(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x54618
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x546c5
leaq -0xfc(%rbp), %rdi
movq -0x48(%rbp), %rcx
movl $0x8, %esi
movl $0x27, %edx
movl $0x1, %r8d
callq 0x38530
movq %rax, -0x178(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x68(%rbp), %rcx
movslq (%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43520
movq -0x178(%rbp), %rcx
movq -0x170(%rbp), %r8
movq %rax, %r9
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x1, %rax
movl $0x1, %edi
leaq 0xb47e6(%rip), %rsi     # 0x108e7a
leaq 0xb4935(%rip), %rdx     # 0x108fd0
movq %rax, (%rsp)
movb $0x0, %al
callq 0x9d90
movq -0x20(%rbp), %rax
movl 0xcc(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xcc(%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x549a2
jmp 0x546c7
jmp 0x53bbb
jmp 0x546ce
movl -0x60(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x20, %rcx
andq $0xff, %rcx
cmpl %ecx, %eax
jge 0x54981
movq -0x38(%rbp), %rax
movslq -0x60(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movl 0x18(%rax), %eax
shrl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x10c(%rbp)
movq -0x108(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x5472a
jmp 0x54973
cmpl $0x3, -0x10c(%rbp)
jne 0x54844
movq -0x108(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x547d8
movq -0x108(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x108(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x118(%rbp)
movq -0x108(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5478f
movq -0x118(%rbp), %rax
movl $0x80000000, (%rax)     # imm = 0x80000000
movl $0x1, -0x110(%rbp)
movl -0x110(%rbp), %eax
movq -0x108(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x547d6
movq -0x118(%rbp), %rax
movslq -0x110(%rbp), %rcx
movl $0x80000001, (%rax,%rcx,4) # imm = 0x80000001
movl -0x110(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0x54799
jmp 0x5483f
movq -0x108(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x108(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x120(%rbp)
movq -0x108(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5483d
movq -0x120(%rbp), %rax
movb $0x2e, (%rax)
movq -0x120(%rbp), %rdi
addq $0x1, %rdi
movq -0x108(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
movslq %eax, %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x4240
jmp 0x5483f
jmp 0x54971
cmpl $0x1, -0x10c(%rbp)
jne 0x548d2
movq -0x108(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x108(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rax
movl $0x80000000, (%rax)     # imm = 0x80000000
movl $0x1, -0x110(%rbp)
movl -0x110(%rbp), %eax
movq -0x108(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x548cd
movq -0x128(%rbp), %rax
movslq -0x110(%rbp), %rcx
movl $0x80000001, (%rax,%rcx,4) # imm = 0x80000001
movl -0x110(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0x54890
jmp 0x5496f
cmpl $0x2, -0x10c(%rbp)
jne 0x5496d
movq -0x108(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x108(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movslq -0x4c(%rbp), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rdi
movl 0xd0d2c(%rip), %esi     # 0x125640
callq 0x40e90
movl $0x1, -0x110(%rbp)
movl -0x110(%rbp), %eax
movq -0x108(%rbp), %rcx
movl 0x8(%rcx), %ecx
sarl $0x2, %ecx
cmpl %ecx, %eax
jge 0x5496b
movq -0x130(%rbp), %rdi
movslq -0x110(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl 0xd0cef(%rip), %esi     # 0x125644
callq 0x40e90
movl -0x110(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0x54923
jmp 0x5496d
jmp 0x5496f
jmp 0x54971
jmp 0x54973
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x546ce
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x53ada
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nop