// File: /workspace/github_cpp_makefile_star2_O3/myudelson[P]hmm-scalable/InputUtilSt.cpp
// Function: InputUtilSt::readBin(char const*, task*)
bool InputUtilSt::readBin(const char *fn, struct task *task) {
    char c, v/*version*/;
    NDAT i;
    NDAT nread;
    FILE *fid = fopen(fn,"rb");
    
    // version
    nread = (NDAT)fread (&v, sizeof(char), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading version data from %s\n",fn);
        return false;
    }
    if( v > bin_input_file_verstion) { // we will handle earlier versions
        fprintf(stderr,"Wrong version of the data file. Expected %d, actual %d\n",(int)bin_input_file_verstion, (int)v);
        return false;
    }
    
    // N
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of rows from %s\n",fn);
        return false;
    }
    task->N = (NDAT)i;
    
    // Nst
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of rows (stacked) from %s\n",fn);
        return false;
    }
    task->Nst = (NDAT)i;
    
    // N_null
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of rows with null skills from %s\n",fn);
        return false;
    }
    task->N_null = (NDAT)i;
    
    // nO
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of observations from %s\n",fn);
        return false;
    }
    task->nO = (NPAR)i;
    
    // nG
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of groups (students) from %s\n",fn);
        return false;
    }
    task->nG = (NCAT)i;
    
    // nI
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of items from %s\n",fn);
        return false;
    }
    task->nI = (NCAT)i;
    
    // nK
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of skills from %s\n",fn);
        return false;
    }
    task->nK = (NCAT)i;
    
    // nZ
    nread = (NDAT)fread (&i, sizeof(NDAT), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading number of slices from %s\n",fn);
        return false;
    }
    task->nZ = (NPAR)i;
    if(task->nZ<1) {
        fprintf(stderr,"Number of slices should be at least 1\n");
        return true;
    }
    
    // multiskill
    nread = (NDAT)fread (&c, sizeof(char), (size_t)1, fid);
    if(nread != 1) {
        fprintf(stderr,"Error reading multiskill flag from %s\n",fn);
        return false;
    }
    task->multiskill = (NPAR)c;
    
    
    // dat_obs
//    StripedArray<NPAR> *striped_dat_obs = new StripedArray<NPAR>(fid, task->N);
//    task->dat_obs = striped_dat_obs->toArray();
    task->dat_obs = StripedArray<NPAR>::fromFileToArray(fid, task->N);
    task->dat_obs_stacked = init1D<NPAR>(task->Nst);
    task->dat_predict = initToValue2D<NUMBER>(task->N, task->nO, 0);
//    delete striped_dat_obs;

    
//    if(v==1) { // older NCAT of unsigned short
//        StripedArray<short> *dat_group_legacy = NULL;
//        StripedArray<short> *dat_skill_legacy = NULL;
//        StripedArray<short*> *dat_multiskill_legacy = NULL;
//        dat_group_legacy = new StripedArray<short>(fid, task->N);
//        for(t=0; t<task->N; t++)
//            task->dat_group[t] = (NCAT)dat_group_legacy->get(t);
//        if(task->multiskill == 0) {
//            dat_skill_legacy = new StripedArray<short>(fid, task->N);
//            for(t=0; t<task->N; t++)
//                task->dat_skill[t] = (NCAT)dat_skill_legacy->get(t);
//            delete dat_skill_legacy;
//        } else {
//            task->dat_multiskill = new StripedArray<NCAT*>(task->N,true);
//            nread = readMultiSkill(fid, param, v);
//            delete dat_multiskill_legacy;
//        }
//        delete dat_group_legacy;
//    } else {
        // dat_group
//        StripedArray<NCAT> *striped_dat_group = new StripedArray<NCAT>(fid, task->N);
//        task->dat_group = striped_dat_group->toArray();
//        delete striped_dat_group;
        task->dat_group = StripedArray<NCAT>::fromFileToArray(fid, task->N);
//    }
    
    // dat_item
//    StripedArray<NCAT> *striped_dat_item = new StripedArray<NCAT>(fid, task->N);
//    task->dat_item = striped_dat_item->toArray();
//    delete striped_dat_item;
    task->dat_item = StripedArray<NCAT>::fromFileToArray(fid, task->N);
    
    // dat_skill
    if(task->multiskill == 0) {
//        StripedArray<NCAT> *striped_dat_skill = new StripedArray<NCAT>(fid, task->N);
//        task->dat_skill = striped_dat_skill->toArray();
//        delete striped_dat_skill;
        task->dat_skill = StripedArray<NCAT>::fromFileToArray(fid, task->N);
    } else {
//            task->dat_multiskill = new StripedArray< NCAT* >(task->N,true);
//            nread = readMultiSkill(fid, param, v);
//        StripedArray<NCAT> *striped_dat_skill_stacked = new StripedArray<NCAT>(fid, task->Nst);
//        task->dat_skill_stacked = striped_dat_skill_stacked->toArray();
//        StripedArray<NCAT> *striped_dat_skill_rcount = new StripedArray<NCAT>(fid, task->N);
//        task->dat_skill_rcount = striped_dat_skill_rcount->toArray();
//        StripedArray<NCAT> *striped_dat_skill_rix = new StripedArray<NCAT>(fid, task->N);
//        task->dat_skill_rix = striped_dat_skill_rix->toArray();
//        delete striped_dat_skill_stacked;
//        delete striped_dat_skill_rcount;
//        delete striped_dat_skill_rix;
        task->dat_skill_stacked = StripedArray<NCAT>::fromFileToArray(fid, task->Nst);
        task->dat_skill_rcount = StripedArray<NCAT>::fromFileToArray(fid, task->N);
        task->dat_skill_rix = StripedArray<NCAT>::fromFileToArray(fid, task->N);
    }
    // dat_slices, only of nZ > 1
    if(task->nZ > 1) {
        NDAT szZ = (task->multiskill == 0)?task->N:task->Nst;
//        StripedArray<NPAR> *striped_dat_slice = new StripedArray<NPAR>(fid, szZ);
//        task->dat_slice = striped_dat_slice->toArray();
//        delete striped_dat_slice;
        task->dat_slice = StripedArray<NPAR>::fromFileToArray(fid, szZ);
    }
        
    string str;
    task->map_group_fwd = new map<string,NCAT>();
    task->map_group_bwd = new map<NCAT,string>();
    task->map_skill_fwd = new map<string,NCAT>();
    task->map_skill_bwd = new map<NCAT,string>();
    task->map_step_fwd = new map<string,NCAT>();
    task->map_step_bwd = new map<NCAT,string>();
    // voc_group
    for(NCAT g=0; g<task->nG; g++) {
        str = readString(fid);
        task->map_group_fwd->insert(pair<string,NCAT>(str, g));
        task->map_group_bwd->insert(pair<NCAT,string>(g, str));
    }
    
    // voc_skill
    for(NCAT k=0; k<task->nK; k++) {
        str = readString(fid);
        task->map_skill_fwd->insert(pair<string,NCAT>(str, k));
        task->map_skill_bwd->insert(pair<NCAT,string>(k, str));
    }
    
    // voc_item
    for(NCAT i=0; i<task->nI; i++) {
        str = readString(fid);
        task->map_step_fwd->insert(pair<string,NCAT>(str, i));
        task->map_step_bwd->insert(pair<NCAT,string>(i, str));
    }
    
    // build dat_obs_stacked
    NDAT co = 0;
    if(task->multiskill!=0) {
        for(NDAT t=0;t<task->N;t++) {
            for(NDAT tt=0; tt<task->dat_skill_rcount[t]; tt++) {
                task->dat_obs_stacked[c] = task->dat_obs[t];
                co++;
            }
        }
    } else {
        memcpy( task->dat_obs_stacked, task->dat_obs , sizeof(NPAR)*(size_t)task->N );
    }

    //
    // create connectivities: skill-skill, student-skill
    //
    createConnectivities(task);

    fclose(fid);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x98f5(%rip), %rsi      # 0x12fd2
callq 0x2230
movq %rax, %r12
leaq 0x6(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9e3b
movsbl 0x6(%rsp), %ecx
cmpl $0x4, %ecx
jge 0x9e51
movq %rsp, %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9e75
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x8f8(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9e8b
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x8fc(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9ea1
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x914(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9eb4
movq %rsp, %rdi
movb (%rdi), %al
movb %al, 0x901(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9ec7
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x904(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9eda
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x90c(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9eed
movq %rsp, %rdi
movl (%rdi), %eax
movl %eax, 0x908(%rbx)
movl $0x4, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9f00
movb (%rsp), %al
movb %al, 0x910(%rbx)
testb %al, %al
jle 0x9f13
leaq 0x7(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r12, %rcx
callq 0x22d0
cmpl $0x1, %eax
jne 0x9f1d
movsbq 0x7(%rsp), %r15
movb %r15b, 0x920(%rbx)
movl 0x8f8(%rbx), %esi
movq %r12, %rdi
callq 0xa720
movq %rax, 0x880(%rbx)
movslq 0x8fc(%rbx), %rdi
movl $0x1, %esi
callq 0x2110
movq %rax, 0x888(%rbx)
movl 0x8f8(%rbx), %edi
movsbl 0x901(%rbx), %esi
xorps %xmm0, %xmm0
callq 0xa47e
movq %rax, 0x8c8(%rbx)
movl 0x8f8(%rbx), %esi
movq %r12, %rdi
callq 0xa760
movq %rax, 0x890(%rbx)
movl 0x8f8(%rbx), %esi
movq %r12, %rdi
callq 0xa760
movq %rax, 0x8b8(%rbx)
cmpb $0x0, 0x920(%rbx)
je 0x9927
movl 0x8fc(%rbx), %esi
movq %r12, %rdi
callq 0xa760
movq %rax, 0x8a0(%rbx)
movl 0x8f8(%rbx), %esi
movq %r12, %rdi
callq 0xa760
movq %rax, 0x8a8(%rbx)
movl $0x8b0, %r14d           # imm = 0x8B0
jmp 0x992d
movl $0x898, %r14d           # imm = 0x898
movl 0x8f8(%rbx), %esi
movq %r12, %rdi
callq 0xa760
movq %rax, (%rbx,%r14)
cmpb $0x2, 0x910(%rbx)
jl 0x996a
xorl %eax, %eax
cmpb $0x0, 0x920(%rbx)
setne %al
movl 0x8f8(%rbx,%rax,4), %esi
movq %r12, %rdi
callq 0xa720
movq %rax, 0x8c0(%rbx)
movq %r12, 0x50(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x928(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x930(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x948(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x950(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x938(%rbx)
movl $0x30, %edi
callq 0x21c0
movq %rax, %rcx
addq $0x8, %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x940(%rbx)
cmpl $0x0, 0x904(%rbx)
leaq 0x18(%rsp), %r13
jle 0x9ba6
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq 0x50(%rsp), %rsi
callq 0x8268
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x2260
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9afa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x928(%rbx), %rbp
movq %r13, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x78e6
movl %r14d, 0x28(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xa90c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9b42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x930(%rbx), %rbp
movl %r14d, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x78e6
movq %rbp, %rdi
movq %r12, %rsi
callq 0xaad6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9b96
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
incl %r14d
cmpl 0x904(%rbx), %r14d
jl 0x9ac9
cmpl $0x0, 0x908(%rbx)
jle 0x9c98
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq 0x50(%rsp), %rsi
callq 0x8268
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x2260
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9bec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x948(%rbx), %rbp
movq %r13, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x78e6
movl %r14d, 0x28(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xa90c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9c34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x950(%rbx), %rbp
movl %r14d, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x78e6
movq %rbp, %rdi
movq %r12, %rsi
callq 0xaad6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9c88
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
incl %r14d
cmpl 0x908(%rbx), %r14d
jl 0x9bbb
cmpl $0x0, 0x90c(%rbx)
jle 0x9d8a
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq 0x50(%rsp), %rsi
callq 0x8268
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x2260
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9cde
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x938(%rbx), %rbp
movq %r13, 0x8(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x78e6
movl %r14d, 0x28(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xa90c
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9d26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq 0x940(%rbx), %rbp
movl %r14d, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x78e6
movq %rbp, %rdi
movq %r12, %rsi
callq 0xaad6
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9d7a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
incl %r14d
cmpl 0x90c(%rbx), %r14d
jl 0x9cad
cmpb $0x0, 0x920(%rbx)
je 0x9de9
movl 0x8f8(%rbx), %edx
testl %edx, %edx
movq 0x50(%rsp), %r14
jle 0x9e08
movq 0x8a8(%rbx), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rax,4)
jle 0x9ddc
xorl %edx, %edx
movq 0x880(%rbx), %rcx
movq 0x888(%rbx), %rsi
movb (%rcx,%rax), %cl
movb %cl, (%rsi,%r15)
incl %edx
movq 0x8a8(%rbx), %rcx
cmpl (%rcx,%rax,4), %edx
jl 0x9db3
movl 0x8f8(%rbx), %edx
incq %rax
movslq %edx, %rsi
cmpq %rsi, %rax
jl 0x9dab
jmp 0x9e08
movq 0x880(%rbx), %rsi
movq 0x888(%rbx), %rdi
movslq 0x8f8(%rbx), %rdx
callq 0x2180
movq 0x50(%rsp), %r14
movq %rbx, %rdi
callq 0x94a8
movq %r14, %rdi
callq 0x21b0
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x9e34
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21d0
movb $0x1, %bl
jmp 0x9f3a
movq 0xe196(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x9189(%rip), %rsi      # 0x12fd5
jmp 0x9f2e
movq 0xe180(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x9197(%rip), %rsi      # 0x12ff9
xorl %ebx, %ebx
movl $0x3, %edx
xorl %eax, %eax
callq 0x22b0
jmp 0x9f3a
movq 0xe15c(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x91ab(%rip), %rsi      # 0x13031
jmp 0x9f2e
movq 0xe146(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x91bb(%rip), %rsi      # 0x13057
jmp 0x9f2e
movq 0xe130(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x91d5(%rip), %rsi      # 0x13087
jmp 0x9f2e
movq 0xe11d(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x91f9(%rip), %rsi      # 0x130be
jmp 0x9f2e
movq 0xe10a(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x9214(%rip), %rsi      # 0x130ec
jmp 0x9f2e
movq 0xe0f7(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x9234(%rip), %rsi      # 0x1311f
jmp 0x9f2e
movq 0xe0e4(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x9248(%rip), %rsi      # 0x13146
jmp 0x9f2e
movq 0xe0d1(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x925d(%rip), %rsi      # 0x1316e
jmp 0x9f2e
callq 0x2945
jmp 0x9e34
movq 0xe0b4(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
leaq 0x928f(%rip), %rsi      # 0x131bd
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9f7b
jmp 0x9f7b
jmp 0x9f7b
jmp 0x9f7b
jmp 0x9f67
jmp 0x9f7b
jmp 0x9f80
jmp 0x9f7b
jmp 0x9f7b
jmp 0x9f67
jmp 0x9f7b
jmp 0x9f80
jmp 0x9f7b
jmp 0x9f7b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9f9f
movq 0x18(%rsp), %rsi
jmp 0x9f97
movq %rax, %rbx
jmp 0x9f9f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x9f9f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21d0
leaq 0x40(%rsp), %rax
movq 0x30(%rsp), %rdi
cmpq %rax, %rdi
je 0x9fbb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2370
nop