// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/bcf_sr_sort.c
// Function: bcf_sr_sort_set
static int bcf_sr_sort_set(bcf_srs_t *readers, sr_sort_t *srt, const char *chr, hts_pos_t min_pos)
{
    if ( !srt->grp_str2int )
    {
        // first time here, initialize
        if ( !srt->pair )
        {
            if ( readers->collapse==COLLAPSE_NONE ) readers->collapse = BCF_SR_PAIR_EXACT;
            bcf_sr_set_opt(readers, BCF_SR_PAIR_LOGIC, readers->collapse);
        }
        bcf_sr_init_scores(srt);
        srt->grp_str2int = khash_str2int_init();
        srt->var_str2int = khash_str2int_init();
    }
    int k;
    khash_t(str2int) *hash;
    hash = srt->grp_str2int;
    for (k=0; k < kh_end(hash); k++)
        if ( kh_exist(hash,k) ) free((char*)kh_key(hash,k));
    hash = srt->var_str2int;
    for (k=0; k < kh_end(hash); k++)
        if ( kh_exist(hash,k) ) free((char*)kh_key(hash,k));
    kh_clear(str2int, srt->grp_str2int);
    kh_clear(str2int, srt->var_str2int);
    srt->ngrp = srt->nvar = srt->nvset = 0;

    grp_t grp;
    memset(&grp,0,sizeof(grp_t));

    // group VCFs into groups, each with a unique combination of variants in the duplicate lines
    int ireader,ivar,irec,igrp,ivset,iact;
    for (ireader=0; ireader<readers->nreaders; ireader++) srt->vcf_buf[ireader].nrec = 0;
    for (iact=0; iact<srt->nactive; iact++) // process each of the active readers, ie which still have a record to process
    {
        ireader = srt->active[iact];
        bcf_sr_t *reader = &readers->readers[ireader];
        int rid   = bcf_hdr_name2id(reader->header, chr);
        grp.nvar  = 0;
        hts_expand(int,reader->nbuffer,srt->moff,srt->off);
        srt->noff  = 0;
        srt->str.l = 0;
        for (irec=1; irec<=reader->nbuffer; irec++)
        {
            bcf1_t *line = reader->buffer[irec];
            if ( line->rid!=rid || line->pos!=min_pos ) break;

            if ( srt->str.l ) kputc(';',&srt->str);
            srt->off[srt->noff++] = srt->str.l;
            size_t beg  = srt->str.l;
            int end_pos = -1;
            if ( srt->pair & BCF_SR_PAIR_ID )
            {
                kputs(line->d.id,&srt->str);
                kputc(':',&srt->str);
            }
            for (ivar=1; ivar<line->n_allele; ivar++)
            {
                if ( ivar>1 ) kputc(',',&srt->str);
                kputs(line->d.allele[0],&srt->str);
                kputc('>',&srt->str);
                kputs(line->d.allele[ivar],&srt->str);

                // If symbolic allele, check also the END tag in case there are multiple events,
                // such as <DEL>s, starting at the same positions
                if ( line->d.allele[ivar][0]=='<' )
                {
                    if ( end_pos==-1 )
                    {
                        bcf_info_t *end_info = bcf_get_info(reader->header,line,"END");
                        if ( end_info )
                            end_pos = (int)end_info->v1.i;  // this is only to create a unique id, we don't mind a potential int64 overflow
                        else
                            end_pos = 0;
                    }
                    if ( end_pos )
                    {
                        kputc('/',&srt->str);
                        kputw(end_pos, &srt->str);
                    }
                }
            }
            if ( line->n_allele==1 )
            {
                kputs(line->d.allele[0],&srt->str);
                kputsn(">.",2,&srt->str);
            }

            // Create new variant or attach to existing one. But careful, there can be duplicate
            // records with the same POS,REF,ALT (e.g. in dbSNP-b142). In such case, use a
            // hash table (srt->var_str2int) and a counter (var_idx) to ensure they are
            // treated as separate variants, while still allowing them to be matched
            // between readers.
            char *var_str = beg + srt->str.s;
            int ret, var_idx = 0, var_end = srt->str.l;
            while ( 1 )
            {
                ret = khash_str2int_get(srt->var_str2int, var_str, &ivar);
                if ( ret==-1 ) break;

                var_t *var = &srt->var[ivar];
                if ( var->vcf[var->nvcf-1] != ireader ) break;

                srt->str.l = var_end;
                kputw(var_idx, &srt->str);
                var_str = beg + srt->str.s;
                var_idx++;
            }
            if ( ret==-1 )
            {
                // the variant is not present, insert
                ivar = srt->nvar++;
                hts_expand0(var_t,srt->nvar,srt->mvar,srt->var);
                srt->var[ivar].nvcf = 0;
                khash_str2int_set(srt->var_str2int, strdup(var_str), ivar);
                free(srt->var[ivar].str);   // possible left-over from the previous position
            }
            var_t *var = &srt->var[ivar];
            var->nalt = line->n_allele - 1;
            var->type = bcf_get_variant_types(line);
            srt->str.s[var_end] = 0;
            if ( ret==-1 )
                var->str = strdup(var_str);

            int mvcf = var->mvcf;
            var->nvcf++;
            hts_expand0(int*, var->nvcf, var->mvcf, var->vcf);
            if ( mvcf != var->mvcf ) var->rec = (bcf1_t **) realloc(var->rec,sizeof(bcf1_t*)*var->mvcf);
            var->vcf[var->nvcf-1] = ireader;
            var->rec[var->nvcf-1] = line;

            grp.nvar++;
            hts_expand(var_t,grp.nvar,grp.mvar,grp.var);
            grp.var[grp.nvar-1] = ivar;
        }
        char *grp_key = grp_create_key(srt);
        int ret = khash_str2int_get(srt->grp_str2int, grp_key, &igrp);
        if ( ret==-1 )
        {
            igrp = srt->ngrp++;
            hts_expand0(grp_t, srt->ngrp, srt->mgrp, srt->grp);
            free(srt->grp[igrp].var);
            srt->grp[igrp] = grp;
            srt->grp[igrp].key = grp_key;
            khash_str2int_set(srt->grp_str2int, grp_key, igrp);
            memset(&grp,0,sizeof(grp_t));
        }
        else
            free(grp_key);
        srt->grp[igrp].nvcf++;
    }
    free(grp.var);

    // initialize bitmask - which groups is the variant present in
    for (ivar=0; ivar<srt->nvar; ivar++)
    {
        if ( kbs_resize(&srt->var[ivar].mask, srt->ngrp) < 0 )
        {
            fprintf(stderr, "[%s:%d %s] kbs_resize failed\n", __FILE__,__LINE__,__func__);
            exit(1);
        }
        kbs_clear(srt->var[ivar].mask);
    }
    for (igrp=0; igrp<srt->ngrp; igrp++)
    {
        for (ivar=0; ivar<srt->grp[igrp].nvar; ivar++)
        {
            int i = srt->grp[igrp].var[ivar];
            kbs_insert(srt->var[i].mask, igrp);
        }
    }

    // create the initial list of variant sets
    for (ivar=0; ivar<srt->nvar; ivar++)
    {
        ivset = srt->nvset++;
        hts_expand0(varset_t, srt->nvset, srt->mvset, srt->vset);

        varset_t *vset = &srt->vset[ivset];
        vset->nvar = 1;
        hts_expand0(var_t, vset->nvar, vset->mvar, vset->var);
        vset->var[vset->nvar-1] = ivar;
        var_t *var  = &srt->var[ivar];
        vset->cnt   = var->nvcf;
        if ( kbs_resize(&vset->mask, srt->ngrp) < 0 )
        {
            fprintf(stderr, "[%s:%d %s] kbs_resize failed\n", __FILE__,__LINE__,__func__);
            exit(1);
        }
        kbs_clear(vset->mask);
        kbs_bitwise_or(vset->mask, var->mask);

        int type = 0;
        if ( var->type==VCF_REF ) type |= SR_REF;
        else
        {
            if ( var->type & VCF_SNP ) type |= SR_SNP;
            if ( var->type & VCF_MNP ) type |= SR_SNP;
            if ( var->type & VCF_INDEL ) type |= SR_INDEL;
            if ( var->type & VCF_OTHER ) type |= SR_OTHER;
        }
        var->type = type;
    }
#if DEBUG_VSETS
    debug_vsets(srt);
#endif

    // initialize the pairing matrix
    hts_expand(int, srt->ngrp*srt->nvset, srt->mpmat, srt->pmat);
    hts_expand(int, srt->nvset, srt->mcnt, srt->cnt);
    memset(srt->pmat, 0, sizeof(*srt->pmat)*srt->ngrp*srt->nvset);
    for (ivset=0; ivset<srt->nvset; ivset++)
    {
        varset_t *vset = &srt->vset[ivset];
        for (igrp=0; igrp<srt->ngrp; igrp++) srt->pmat[ivset*srt->ngrp+igrp] = 0;
        srt->cnt[ivset] = vset->cnt;
    }

    // pair the lines
    while ( srt->nvset )
    {
#if DEBUG_VSETS
    fprintf(stderr,"\n");
    debug_vsets(srt);
#endif

        int imax = 0;
        for (ivset=1; ivset<srt->nvset; ivset++)
            if ( srt->cnt[imax] < srt->cnt[ivset] ) imax = ivset;

        int ipair = -1;
        uint32_t max_score = 0;
        for (ivset=0; ivset<srt->nvset; ivset++)
        {
            if ( kbs_logical_and(srt->vset[imax].mask,srt->vset[ivset].mask) ) continue;   // cannot be merged
            uint32_t score = pairing_score(srt, imax, ivset);
            // fprintf(stderr,"score: %d %d, logic=%d \t..\t %u\n", imax,ivset,srt->pair,score);
            if ( max_score < score ) { max_score = score; ipair = ivset; }
        }

        // merge rows creating a new variant set this way
        if ( ipair!=-1 && ipair!=imax )
        {
            imax = merge_vsets(srt, imax, ipair);
            continue;
        }

        push_vset(srt, imax);
    }

    srt->chr = chr;
    srt->pos = min_pos;

    return 0;  // FIXME: check for errs in this function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jne 0xdfd4e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c0(%rax)
jne 0xdfd1f
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xdfd09
movq -0x8(%rbp), %rax
movl $0x40, (%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movl $0x1, %esi
movb $0x0, %al
callq 0x37cb0
movq -0x10(%rbp), %rdi
callq 0xe1520
callq 0xe1710
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x160(%rax)
callq 0xe1710
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xdfdb7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x24(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xdfdaa
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
jmp 0xdfdac
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdfd64
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jae 0xdfe20
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
sarl $0x4, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x24(%rbp), %ecx
andl $0xf, %ecx
shll %ecx
shrl %cl, %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0xdfe13
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x45a0
jmp 0xdfe15
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdfdcd
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0xe1720
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
callq 0xe1720
movq -0x10(%rbp), %rax
movl $0x0, 0x110(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x100(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x128(%rax)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4240
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x30(%rcx), %eax
jge 0xdfeb4
movq -0x10(%rbp), %rax
movq 0x150(%rax), %rax
movslq -0x54(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xdfe81
movl $0x0, -0x68(%rbp)
movl -0x68(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c4(%rcx), %eax
jge 0xe0867
movq -0x10(%rbp), %rax
movq 0x1d0(%rax), %rax
movslq -0x68(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x54(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x54(%rbp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xe17a0
movl %eax, -0x74(%rbp)
movl $0x0, -0x48(%rbp)
movq -0x70(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x188(%rcx), %eax
jle 0xdff94
movq -0x70(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jl 0xdff41
movq -0x70(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x10c(%rbp)
jmp 0xdff4e
movl $0x1, %eax
movl %eax, -0x10c(%rbp)
jmp 0xdff4e
movl -0x10c(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x188(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x190, %r9             # imm = 0x190
movl $0x4, %ecx
xorl %r8d, %r8d
leaq 0x38dd3(%rip), %rax     # 0x118d4f
movq %rcx, %rdx
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x188(%rax)
jmp 0xdff96
movq -0x10(%rbp), %rax
movl $0x0, 0x18c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x170(%rax)
movl $0x1, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
movq -0x70(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jg 0xe06a9
movq -0x70(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x5c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x74(%rbp), %eax
jne 0xdfff7
movq -0x80(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
je 0xdfffc
jmp 0xe06a9
movq -0x10(%rbp), %rax
cmpq $0x0, 0x170(%rax)
je 0xe001f
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
movl $0x3b, %edi
callq 0xe17d0
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x190(%rax), %rax
movq -0x10(%rbp), %rsi
movl 0x18c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x18c(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movq %rax, -0x88(%rbp)
movl $0xffffffff, -0x8c(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x1c0(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0xe00af
movq -0x80(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe1850
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
movl $0x3a, %edi
callq 0xe17d0
movl $0x1, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x80(%rbp), %rcx
movq 0x18(%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
cmpl %ecx, %eax
jge 0xe01fb
cmpl $0x1, -0x58(%rbp)
jle 0xe00ef
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
movl $0x2c, %edi
callq 0xe17d0
movq -0x80(%rbp), %rax
movq 0x88(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe1850
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
movl $0x3e, %edi
callq 0xe17d0
movq -0x80(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe1850
movq -0x80(%rbp), %rax
movq 0x88(%rax), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x3c, %eax
jne 0xe01eb
cmpl $-0x1, -0x8c(%rbp)
jne 0xe01b5
movq -0x70(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x80(%rbp), %rsi
leaq 0x33c98(%rip), %rdx     # 0x113e18
callq 0x58380
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
je 0xe01a9
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x8c(%rbp)
jmp 0xe01b3
movl $0x0, -0x8c(%rbp)
jmp 0xe01b5
cmpl $0x0, -0x8c(%rbp)
je 0xe01e9
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
movl $0x2f, %edi
callq 0xe17d0
movl -0x8c(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe18b0
jmp 0xe01eb
jmp 0xe01ed
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xe00b6
movq -0x80(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpl $0x1, %eax
jne 0xe024c
movq -0x80(%rbp), %rax
movq 0x88(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe1850
movq -0x10(%rbp), %rdx
addq $0x170, %rdx            # imm = 0x170
leaq 0x38b1d(%rip), %rdi     # 0x118d5f
movl $0x2, %esi
callq 0xe1930
movq -0x88(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x180(%rcx), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq 0x170(%rax), %rax
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rdi
movq -0xa0(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0xe19e0
movl %eax, -0xa4(%rbp)
cmpl $-0x1, -0xa4(%rbp)
jne 0xe02af
jmp 0xe0346
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xb8(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x54(%rbp), %eax
je 0xe02f1
jmp 0xe0346
movslq -0xac(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x170(%rax)
movl -0xa8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq $0x170, %rsi            # imm = 0x170
callq 0xe18b0
movq -0x88(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x180(%rcx), %rax
movq %rax, -0xa0(%rbp)
movl -0xa8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa8(%rbp)
jmp 0xe0280
cmpl $-0x1, -0xa4(%rbp)
jne 0xe0465
movq -0x10(%rbp), %rcx
movl 0x100(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x100(%rcx)
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0x100(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x104(%rcx), %eax
jle 0xe03f8
movq -0x10(%rbp), %rax
cmpl $0x1, 0x100(%rax)
jl 0xe03a0
movq -0x10(%rbp), %rax
movl 0x100(%rax), %eax
movl %eax, -0x110(%rbp)
jmp 0xe03ad
movl $0x1, %eax
movl %eax, -0x110(%rbp)
jmp 0xe03ad
movl -0x110(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x104(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x108, %r9             # imm = 0x108
movl $0x4, %edx
movl $0x30, %ecx
movl $0x1, %r8d
leaq 0x3896c(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x104(%rax)
jmp 0xe03fa
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x168(%rax), %rax
movq %rax, -0x118(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x4930
movq -0x118(%rbp), %rdi
movq %rax, %rsi
movl -0x58(%rbp), %edx
callq 0xe1a70
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
movq -0x80(%rbp), %rax
movq 0x18(%rax), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %ecx
subl $0x1, %ecx
movq -0xc0(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x80(%rbp), %rdi
callq 0x55f10
movl %eax, %ecx
movq -0xc0(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rax
movslq -0xac(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $-0x1, -0xa4(%rbp)
jne 0xe04f0
movq -0xa0(%rbp), %rdi
callq 0x4930
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, (%rax)
movq -0xc0(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0xc4(%rbp)
movq -0xc0(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0xc0(%rbp), %rax
movl 0x10(%rax), %eax
movq -0xc0(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jle 0xe059d
movq -0xc0(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jl 0xe0545
movq -0xc0(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x11c(%rbp)
jmp 0xe0552
movl $0x1, %eax
movl %eax, -0x11c(%rbp)
jmp 0xe0552
movl -0x11c(%rbp), %eax
movslq %eax, %rdi
movq -0xc0(%rbp), %rax
movslq 0x14(%rax), %rsi
movq -0xc0(%rbp), %r9
addq $0x18, %r9
movl $0x4, %edx
movl $0x8, %ecx
movl $0x1, %r8d
leaq 0x387c7(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0xc0(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0xe059f
movl -0xc4(%rbp), %eax
movq -0xc0(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0xe05de
movq -0xc0(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0xc0(%rbp), %rax
movslq 0x14(%rax), %rsi
shlq $0x3, %rsi
callq 0x4840
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movq %rcx, 0x20(%rax)
movl -0x54(%rbp), %edx
movq -0xc0(%rbp), %rax
movq 0x18(%rax), %rax
movq -0xc0(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x80(%rbp), %rdx
movq -0xc0(%rbp), %rax
movq 0x20(%rax), %rax
movq -0xc0(%rbp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jle 0xe0686
cmpl $0x1, -0x48(%rbp)
jl 0xe0644
movl -0x48(%rbp), %eax
movl %eax, -0x120(%rbp)
jmp 0xe0651
movl $0x1, %eax
movl %eax, -0x120(%rbp)
jmp 0xe0651
movl -0x120(%rbp), %eax
movslq %eax, %rdi
movslq -0x44(%rbp), %rsi
leaq -0x50(%rbp), %r9
addq $0x10, %r9
movl $0x4, %edx
movl $0x30, %ecx
xorl %r8d, %r8d
leaq 0x386d5(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, -0x44(%rbp)
jmp 0xe0688
movl -0x58(%rbp), %edx
movq -0x40(%rbp), %rax
movl -0x48(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0xdffba
movq -0x10(%rbp), %rdi
callq 0xe1ae0
movq %rax, -0xd0(%rbp)
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
movq -0xd0(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0xe19e0
movl %eax, -0xd4(%rbp)
cmpl $-0x1, -0xd4(%rbp)
jne 0xe082e
movq -0x10(%rbp), %rcx
movl 0x128(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x128(%rcx)
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x12c(%rcx), %eax
jle 0xe078c
movq -0x10(%rbp), %rax
cmpl $0x1, 0x128(%rax)
jl 0xe0734
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movl %eax, -0x124(%rbp)
jmp 0xe0741
movl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0xe0741
movl -0x124(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x12c(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x140, %r9             # imm = 0x140
movl $0x4, %edx
movl $0x20, %ecx
movl $0x1, %r8d
leaq 0x385d8(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x12c(%rax)
jmp 0xe078e
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x45a0
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movq -0x48(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0xd0(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0x60(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x160(%rax), %rdi
movq -0xd0(%rbp), %rsi
movl -0x60(%rbp), %edx
callq 0xe1a70
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x4240
jmp 0xe083a
movq -0xd0(%rbp), %rdi
callq 0x45a0
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
jmp 0xdfebb
movq -0x40(%rbp), %rdi
callq 0x45a0
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x100(%rcx), %eax
jge 0xe091b
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
movslq -0x58(%rbp), %rax
imulq $0x30, %rax, %rax
addq %rax, %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movslq 0x128(%rax), %rsi
callq 0xe1d00
cmpl $0x0, %eax
jge 0xe08ee
movq 0x51710(%rip), %rax     # 0x131fd0
movq (%rax), %rdi
leaq 0x38498(%rip), %rsi     # 0x118d62
leaq 0x383f5(%rip), %rdx     # 0x118cc6
movl $0x1ef, %ecx            # imm = 0x1EF
leaq 0x38472(%rip), %r8      # 0x118d4f
movb $0x0, %al
callq 0x46f0
movl $0x1, %edi
callq 0x45d0
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0xe1d30
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xe0877
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x128(%rcx), %eax
jge 0xe09c1
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x140(%rcx), %rcx
movslq -0x60(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xe09b1
movq -0x10(%rbp), %rax
movq 0x140(%rax), %rax
movslq -0x60(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x58(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xd8(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0xd8(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movl -0x60(%rbp), %esi
callq 0xe1d60
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xe093c
jmp 0xe09b3
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xe0922
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x100(%rcx), %eax
jge 0xe0cd8
movq -0x10(%rbp), %rcx
movl 0x110(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x110(%rcx)
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x114(%rcx), %eax
jle 0xe0a80
movq -0x10(%rbp), %rax
cmpl $0x1, 0x110(%rax)
jl 0xe0a28
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
movl %eax, -0x128(%rbp)
jmp 0xe0a35
movl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0xe0a35
movl -0x128(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x114(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x148, %r9             # imm = 0x148
movl $0x4, %edx
movl $0x20, %ecx
movl $0x1, %r8d
leaq 0x382e4(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x114(%rax)
jmp 0xe0a82
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0x64(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movl $0x1, (%rax)
movq -0xe0(%rbp), %rax
movl (%rax), %eax
movq -0xe0(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0xe0b36
movq -0xe0(%rbp), %rax
cmpl $0x1, (%rax)
jl 0xe0ade
movq -0xe0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x12c(%rbp)
jmp 0xe0aeb
movl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0xe0aeb
movl -0x12c(%rbp), %eax
movslq %eax, %rdi
movq -0xe0(%rbp), %rax
movslq 0x4(%rax), %rsi
movq -0xe0(%rbp), %r9
addq $0x8, %r9
movl $0x4, %edx
movl $0x30, %ecx
movl $0x1, %r8d
leaq 0x3822e(%rip), %rax     # 0x118d4f
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0xe0b38
movl -0x58(%rbp), %edx
movq -0xe0(%rbp), %rax
movq 0x8(%rax), %rax
movq -0xe0(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rax
movslq -0x58(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0xe0(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0xe0(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movslq 0x128(%rax), %rsi
callq 0xe1d00
cmpl $0x0, %eax
jge 0xe0bde
movq 0x51420(%rip), %rax     # 0x131fd0
movq (%rax), %rdi
leaq 0x381a8(%rip), %rsi     # 0x118d62
leaq 0x38105(%rip), %rdx     # 0x118cc6
movl $0x20b, %ecx            # imm = 0x20B
leaq 0x38182(%rip), %r8      # 0x118d4f
movb $0x0, %al
callq 0x46f0
movl $0x1, %edi
callq 0x45d0
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xe1d30
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0xe8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0xe1da0
movl $0x0, -0xec(%rbp)
movq -0xe8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xe0c34
movl -0xec(%rbp), %eax
orl $0x1, %eax
movl %eax, -0xec(%rbp)
jmp 0xe0cba
movq -0xe8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xe0c55
movl -0xec(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xec(%rbp)
movq -0xe8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xe0c76
movl -0xec(%rbp), %eax
orl $0x2, %eax
movl %eax, -0xec(%rbp)
movq -0xe8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0xe0c97
movl -0xec(%rbp), %eax
orl $0x4, %eax
movl %eax, -0xec(%rbp)
movq -0xe8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xe0cb8
movl -0xec(%rbp), %eax
orl $0x8, %eax
movl %eax, -0xec(%rbp)
jmp 0xe0cba
movl -0xec(%rbp), %ecx
movq -0xe8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0xe09c8
jmp 0xe0cda
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x110(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x118(%rcx), %eax
jle 0xe0d89
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x110(%rcx), %eax
cmpl $0x1, %eax
jl 0xe0d36
movq -0x10(%rbp), %rax
movl 0x128(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x110(%rcx), %eax
movl %eax, -0x130(%rbp)
jmp 0xe0d43
movl $0x1, %eax
movl %eax, -0x130(%rbp)
jmp 0xe0d43
movl -0x130(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x118(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x120, %r9             # imm = 0x120
movl $0x4, %ecx
xorl %r8d, %r8d
leaq 0x37fde(%rip), %rax     # 0x118d4f
movq %rcx, %rdx
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x118(%rax)
jmp 0xe0d8b
jmp 0xe0d8d
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x130(%rcx), %eax
jle 0xe0e15
movq -0x10(%rbp), %rax
cmpl $0x1, 0x110(%rax)
jl 0xe0dc2
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
movl %eax, -0x134(%rbp)
jmp 0xe0dcf
movl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0xe0dcf
movl -0x134(%rbp), %eax
movslq %eax, %rdi
movq -0x10(%rbp), %rax
movslq 0x130(%rax), %rsi
movq -0x10(%rbp), %r9
addq $0x138, %r9             # imm = 0x138
movl $0x4, %ecx
xorl %r8d, %r8d
leaq 0x37f52(%rip), %rax     # 0x118d4f
movq %rcx, %rdx
movq %rax, (%rsp)
callq 0x16180
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x130(%rax)
jmp 0xe0e17
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x128(%rax), %rdx
shlq $0x2, %rdx
movq -0x10(%rbp), %rax
movslq 0x110(%rax), %rax
imulq %rax, %rdx
xorl %esi, %esi
callq 0x4240
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x110(%rcx), %eax
jge 0xe0eef
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0x64(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0xf8(%rbp)
movl $0x0, -0x60(%rbp)
movl -0x60(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x128(%rcx), %eax
jge 0xe0ec5
movq -0x10(%rbp), %rax
movq 0x120(%rax), %rax
movl -0x64(%rbp), %ecx
movq -0x10(%rbp), %rdx
imull 0x128(%rdx), %ecx
addl -0x60(%rbp), %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0xe0e85
movq -0xf8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movslq -0x64(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xe0e4e
jmp 0xe0ef1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x110(%rax)
je 0xe1068
movl $0x0, -0xfc(%rbp)
movl $0x1, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x110(%rcx), %eax
jge 0xe0f61
movq -0x10(%rbp), %rax
movq 0x138(%rax), %rax
movslq -0xfc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movq 0x138(%rcx), %rcx
movslq -0x64(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xe0f54
movl -0x64(%rbp), %eax
movl %eax, -0xfc(%rbp)
jmp 0xe0f56
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xe0f13
movl $0xffffffff, -0x100(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x104(%rbp)
movl $0x0, -0x64(%rbp)
movl -0x64(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x110(%rcx), %eax
jge 0xe101d
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0xfc(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x148(%rax), %rax
movslq -0x64(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rsi
callq 0xe1df0
cmpl $0x0, %eax
je 0xe0fd2
jmp 0xe100f
movq -0x10(%rbp), %rdi
movl -0xfc(%rbp), %esi
movl -0x64(%rbp), %edx
callq 0xe1e60
movl %eax, -0x108(%rbp)
movl -0x104(%rbp), %eax
cmpl -0x108(%rbp), %eax
jae 0xe100d
movl -0x108(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x100(%rbp)
jmp 0xe100f
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0xe0f7c
cmpl $-0x1, -0x100(%rbp)
je 0xe1054
movl -0x100(%rbp), %eax
cmpl -0xfc(%rbp), %eax
je 0xe1054
movq -0x10(%rbp), %rdi
movl -0xfc(%rbp), %esi
movl -0x100(%rbp), %edx
callq 0xe2150
movl %eax, -0xfc(%rbp)
jmp 0xe0ef1
movq -0x10(%rbp), %rdi
movl -0xfc(%rbp), %esi
callq 0xe2350
jmp 0xe0ef1
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1a8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x1b0(%rax)
xorl %eax, %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)