// File: /workspace/github_cpp_makefile_star2_O3/bobverity[P]MavericK/readIn.cpp
// Function: checkOptions(globals&)
void checkOptions(globals &globals) {
    
    /*
     The following checks are carried out (in this order):
     - fixLabels_on=true if producing any Qmatrix output
     - popCol_on=true if producing Qmatrix_pop files
     - admix_on=true if
        - producing Qmatrix_gene files
        - producing ML admixture freqs
     - outputQmatrix_?_on=true if outputQmatrixError_?_on=true
     - mainRepeats>1 if producing QmatrixError files
     - EMalgorithm_on=true if
        - producing model comp stats
        - producing ML output
     - (Kmax-Kmin)>=2 and mainRepeats>1 if outputEvanno_on=true
     - if using exhaustive approach, check that number of partitions required to sum over is reasonable. Otherwise throw warning
     - ensure that alpha and alphaPropSD vectors are of length 1 or (Kmax-Kmin+1). If former then duplicate value as needed.
     */
    
    // force fixLabels_on=true if producing any Qmatrix output
    if (!globals.fixLabels_on && (globals.outputQmatrix_ind_on || globals.outputQmatrix_pop_on || globals.outputQmatrix_gene_on)) {
        cerrAndLog("\nError: the label switching problem must be solved in order to produce Qmatrix output. Either set fixLabels_on to true, or turn off all Qmatrix output.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force popCol_on=true if producing Qmatrix_pop files
    if (!globals.popCol_on && globals.outputQmatrix_pop_on) {
        cerrAndLog("\nError: unable to produce population level Qmatrix, as population data not currently being used. Either read in population data (by setting popCol_on to true), or stop producing population level Qmatrix output (by setting outputQmatrix_pop_on to false and outputQmatrixError_pop_on to false).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force admix_on=true if producing Qmatrix_gene files
    if (!globals.admix_on && globals.outputQmatrix_gene_on) {
        cerrAndLog("\nError: admixture model must be turned on in order to produce gene level Qmatrix. Either switch to the admixture model (by setting admix_on to true) or stop producing gene level Qmatrix output (by setting outputQmatrix_gene_on and outputQmatrixError_gene_on to false).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force admix_on=true if producing maximum likelihood admixture frequencies
    if (!globals.admix_on && globals.outputMaxLike_admixFreqs_on) {
        cerrAndLog("\nError: admixture model must be turned on in order to produce maximum likelihood admixture frequency output. Either switch to the admixture model (by setting admix_on to true) or stop producing maximum likelihood admixture frequency output (by setting outputMaxLike_admixFreqs_on to false).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force outputQmatrix_?_on=true if outputQmatrixError_?_on=true for all Qmatrix types
    if ((globals.outputQmatrixError_ind_on && !globals.outputQmatrix_ind_on) || (globals.outputQmatrixError_pop_on && !globals.outputQmatrix_pop_on) || (globals.outputQmatrixError_gene_on && !globals.outputQmatrix_gene_on)) {
        cerrAndLog("\nError: if outputQmatrixError options are turned on then the corresponding outputQmatrix options must also be turned on.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force mainRepeats>1 if outputQmatrixError_?_on=true for all Qmatrix types
    if (globals.mainRepeats==1 && (globals.outputQmatrixError_ind_on || globals.outputQmatrixError_pop_on || globals.outputQmatrixError_gene_on)) {
        cerrAndLog("\nError: mainRepeats must be greater than 1 when any outputQmatrixError options are turned on.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force EMalgorithm_on=true if producing model comparison statistics
    if (!globals.EMalgorithm_on && globals.outputComparisonStatistics_on) {
        cerrAndLog("\nError: EM algorithm must be turned on in order to compute model comparison statistics. Either turn on the EM algorithm (by setting EMalgorithm_on to true) or stop producing model comparison statistics (by setting outputComparisonStatistics_on to false).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force EMalgorithm_on=true if producing maximum likelihood output
    if (!globals.EMalgorithm_on && (globals.outputMaxLike_alleleFreqs_on || globals.outputMaxLike_admixFreqs_on)) {
        cerrAndLog("\nError: EM algorithm must be turned on in order to produce maximum likelihood output files. Either turn on the EM algorithm (by setting EMalgorithm_on to true) or stop producing maximum likelihood output (by setting outputMaxLike_alleleFreqs_on and outputMaxLike_admixFreqs_on to false).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // force (Kmax-Kmin)>=2 and mainRepeats>1 if outputEvanno_on=true
    if ((globals.Kmax-globals.Kmin)<2 && globals.outputEvanno_on) {
        cerrAndLog("\nError: Kmax must be at least 2 greater than Kmin when calculating Evanno's delta K.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    if (globals.mainRepeats==1 && globals.outputEvanno_on) {
        cerrAndLog("\nError: mainRepeats must be greater than 1 when calculating Evanno's delta K.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // if using exhaustive approach, check that number of partitions required to sum over is reasonable. Otherwise throw warning
    if (globals.exhaustive_on && !globals.suppressWarning1_on) {
        
        // calculate number of partitions. Number of ways of splitting n elements into i groups is given by the Stirling number of the second kind {n, i}. Number of ways of splitting n elements into UP TO K groups is given by sum_{i=1}^k {n, i}. Calculate this for all K that will be explored under current settings. The total number of partitions (in log space) is given by log_partitions.
        double log_partitions = log(double(0));
        for (int K=globals.Kmin; K<=globals.Kmax; K++) {
            vector<double> StirlingNumbers = globals.admix_on ? StirlingSecond(sum(globals.ploidy_vec)*globals.loci) : StirlingSecond(globals.n);
            for (int i=0; (i<K) & (i<int(StirlingNumbers.size())); i++) {
                log_partitions = logSum(log_partitions,StirlingNumbers[i]);
            }
        }
        
        // if very large then error
        if (log_partitions>180) {
            cerrAndLog("\nWarning: for this combination of data and parameters the number of partitions explored in the exhaustive approach is greater than the number of protons in the observable universe, and the program is unlikely to finish within your lifetime. Either turn off the exhaustive approach, or to override this warning and continue with the analysis insert the optional parameter \"suppressWarning1_on\" with value \"true\" in the parameters file.\n", globals.outputLog_on, globals.outputLog_fileStream);
            exit(1);
        }
        if (log_partitions>log(double(1e7))) {
            cerrAndLog("\nWarning: for this combination of data and parameters the number of partitions explored in the exhaustive approach is extremely large (greater than 1e7 in total), and the program may take a very long time to execute. Either turn off the exhaustive approach, or to override this warning and continue with the analysis insert the optional parameter \"suppressWarning1_on\" with value \"true\" in the parameters file.\n", globals.outputLog_on, globals.outputLog_fileStream);
            exit(1);
        }
        
    }
    
    // ensure that alpha and alphaPropSD vectors are of length 1 or (Kmax-Kmin+1). If former then duplicate value as needed.
    if (int(globals.alpha.size())==1) {
        globals.alpha = vector<double>(globals.Kmax-globals.Kmin+1, globals.alpha[0]);
    } else if (int(globals.alpha.size())!=(globals.Kmax-globals.Kmin+1)) {
        cerrAndLog("\nWarning: alpha must contain either a single value to apply to all K, or a comma-separated list of values of length (Kmax-Kmin+1) to apply to each K individually.\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    if (int(globals.alphaPropSD.size())==1) {
        globals.alphaPropSD = vector<double>(globals.Kmax-globals.Kmin+1, globals.alphaPropSD[0]);
    } else if (int(globals.alphaPropSD.size())!=(globals.Kmax-globals.Kmin+1)) {
        cerrAndLog("\nWarning: alphaPropSD must contain either a single value to apply to all K, or a comma-separated list of values of length (Kmax-Kmin+1).\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, %rbx
cmpb $0x0, 0x2c4f(%rdi)
jne 0x2da23
cmpb $0x0, 0x2c3e(%rbx)
jne 0x2ddb6
cmpb $0x0, 0x2c3f(%rbx)
jne 0x2ddb6
cmpb $0x1, 0x2c40(%rbx)
je 0x2ddb6
cmpb $0x0, 0x2ba1(%rbx)
jne 0x2da39
cmpb $0x1, 0x2c3f(%rbx)
je 0x2def6
cmpb $0x0, 0x2bd0(%rbx)
jne 0x2da5c
cmpb $0x1, 0x2c40(%rbx)
je 0x2df46
cmpb $0x1, 0x2c4c(%rbx)
je 0x2df96
movb 0x2c41(%rbx), %al
cmpb $0x1, %al
jne 0x2da73
cmpb $0x1, 0x2c3e(%rbx)
jne 0x2de06
movb 0x2c42(%rbx), %dl
cmpb $0x1, %dl
jne 0x2da8b
cmpb $0x1, 0x2c3f(%rbx)
jne 0x2de06
movb 0x2c43(%rbx), %sil
cmpb $0x1, %sil
jne 0x2daa5
cmpb $0x0, 0x2c40(%rbx)
je 0x2de06
movl 0x2c0c(%rbx), %ecx
cmpl $0x1, %ecx
setne %dil
orb %dl, %al
orb %sil, %al
xorb $0x1, %al
orb %dil, %al
je 0x2de56
cmpb $0x0, 0x2c30(%rbx)
jne 0x2daf2
cmpb $0x1, 0x2c49(%rbx)
je 0x2dfe6
cmpb $0x0, 0x2c4b(%rbx)
jne 0x2dea6
cmpb $0x1, 0x2c4c(%rbx)
je 0x2dea6
movl 0x2bcc(%rbx), %eax
movl %eax, %edx
subl 0x2bc8(%rbx), %edx
cmpl $0x1, %edx
jg 0x2db12
cmpb $0x1, 0x2c4a(%rbx)
je 0x2e036
cmpl $0x1, %ecx
jne 0x2db24
cmpb $0x1, 0x2c4a(%rbx)
je 0x2e086
cmpb $0x1, 0x2c08(%rbx)
jne 0x2dc62
cmpb $0x0, 0x2c4e(%rbx)
jne 0x2dc62
xorpd %xmm0, %xmm0
callq 0x3290
movslq 0x2bc8(%rbx), %r15
movl 0x2bcc(%rbx), %eax
cmpl %eax, %r15d
jg 0x2dc46
leaq 0x10(%rsp), %r14
cmpb $0x1, 0x2bd0(%rbx)
movsd %xmm0, 0x8(%rsp)
jne 0x2dba1
movq 0x2cd0(%rbx), %rax
movq 0x2cd8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x2dba9
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %esi, %esi
addl (%rax,%rdx,4), %esi
incq %rdx
cmpq %rdx, %rcx
jne 0x2db94
jmp 0x2dbab
movl 0x2d18(%rbx), %esi
jmp 0x2dbb2
xorl %esi, %esi
imull 0x2d1c(%rbx), %esi
movq %r14, %rdi
callq 0x1b096
movq 0x10(%rsp), %rdi
testq %r15, %r15
jle 0x2dc13
movq 0x18(%rsp), %rax
subq %rdi, %rax
shrq $0x3, %rax
testl %eax, %eax
movsd 0x8(%rsp), %xmm0
jle 0x2dc19
movl $0x1, %r12d
movsd -0x8(%rdi,%r12,8), %xmm1
callq 0x1a75d
movq 0x10(%rsp), %rdi
cmpq %r15, %r12
jge 0x2dc19
movq 0x18(%rsp), %rax
subq %rdi, %rax
shrq $0x3, %rax
leaq 0x1(%r12), %rcx
cltq
cmpq %rax, %r12
movq %rcx, %r12
jl 0x2dbe0
jmp 0x2dc19
movsd 0x8(%rsp), %xmm0
testq %rdi, %rdi
je 0x2dc2f
movsd %xmm0, 0x8(%rsp)
callq 0x3310
movsd 0x8(%rsp), %xmm0
leaq 0x1(%r15), %rcx
movslq 0x2bcc(%rbx), %rax
cmpq %rax, %r15
movq %rcx, %r15
jl 0x2db62
ucomisd 0x926a(%rip), %xmm0     # 0x36eb8
ja 0x2e164
ucomisd 0x9264(%rip), %xmm0     # 0x36ec0
ja 0x2e1b1
movabsq $0x7fffffff8, %r15      # imm = 0x7FFFFFFF8
movq 0x2bd8(%rbx), %rdx
movq 0x2be0(%rbx), %rcx
subq %rdx, %rcx
movq %rcx, %rsi
andq %r15, %rsi
cmpq $0x8, %rsi
jne 0x2dcf1
subl 0x2bc8(%rbx), %eax
incl %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x5b2e
movq 0x2bd8(%rbx), %rdi
movapd (%r14), %xmm0
movupd %xmm0, 0x2bd8(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x2be8(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x2dd05
callq 0x3310
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2dd05
callq 0x3310
jmp 0x2dd05
shrq $0x3, %rcx
subl 0x2bc8(%rbx), %eax
incl %eax
cmpl %ecx, %eax
jne 0x2e0d6
movq 0x2bf0(%rbx), %rdx
movq 0x2bf8(%rbx), %rax
subq %rdx, %rax
andq %rax, %r15
cmpq $0x8, %r15
jne 0x2dd8d
movl 0x2bcc(%rbx), %eax
subl 0x2bc8(%rbx), %eax
incl %eax
movslq %eax, %rsi
leaq 0x10(%rsp), %r14
leaq 0x7(%rsp), %rcx
movq %r14, %rdi
callq 0x5b2e
movq 0x2bf0(%rbx), %rdi
movapd (%r14), %xmm0
movupd %xmm0, 0x2bf0(%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x2c00(%rbx)
xorpd %xmm0, %xmm0
movapd %xmm0, (%r14)
movq $0x0, 0x10(%r14)
testq %rdi, %rdi
je 0x2dda7
callq 0x3310
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2dda7
callq 0x3310
jmp 0x2dda7
shrq $0x3, %rax
movl 0x2bcc(%rbx), %ecx
subl 0x2bc8(%rbx), %ecx
incl %ecx
cmpl %eax, %ecx
jne 0x2e11d
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9d2b(%rip), %rsi      # 0x37af4
leaq 0x9dbc(%rip), %rdx      # 0x37b8c
leaq 0x1c8(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x1c8(%rsp), %rdi
jmp 0x2e1f3
leaq 0x158(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa0cc(%rip), %rsi      # 0x37ee5
leaq 0xa13e(%rip), %rdx      # 0x37f5e
leaq 0x148(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x148(%rsp), %rdi
jmp 0x2e1f3
leaq 0x138(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa0f6(%rip), %rsi      # 0x37f5f
leaq 0xa14d(%rip), %rdx      # 0x37fbd
leaq 0x128(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x128(%rsp), %rdi
jmp 0x2e1f3
leaq 0xf8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa205(%rip), %rsi      # 0x380be
leaq 0xa31e(%rip), %rdx      # 0x381de
leaq 0xe8(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0xe8(%rsp), %rdi
jmp 0x2e1f3
leaq 0x1b8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9c84(%rip), %rsi      # 0x37b8d
leaq 0x9da2(%rip), %rdx      # 0x37cb2
leaq 0x1a8(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x1a8(%rsp), %rdi
jmp 0x2e1f3
leaq 0x198(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9d5a(%rip), %rsi      # 0x37cb3
leaq 0x9e60(%rip), %rdx      # 0x37dc0
leaq 0x188(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x188(%rsp), %rdi
jmp 0x2e1f3
leaq 0x178(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9e18(%rip), %rsi      # 0x37dc1
leaq 0x9f34(%rip), %rdx      # 0x37ee4
leaq 0x168(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x168(%rsp), %rdi
jmp 0x2e1f3
leaq 0x118(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9fc5(%rip), %rsi      # 0x37fbe
leaq 0xa0bd(%rip), %rdx      # 0x380bd
leaq 0x108(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x108(%rsp), %rdi
jmp 0x2e1f3
leaq 0xd8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa196(%rip), %rsi      # 0x381df
leaq 0xa1e4(%rip), %rdx      # 0x38234
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0xc8(%rsp), %rdi
jmp 0x2e1f3
leaq 0xb8(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa19c(%rip), %rsi      # 0x38235
leaq 0xa1e3(%rip), %rdx      # 0x38283
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0xa8(%rsp), %rdi
jmp 0x2e1f3
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa4ee(%rip), %rsi      # 0x385d4
leaq 0xa58a(%rip), %rdx      # 0x38677
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x48(%rsp), %rdi
jmp 0x2e1f3
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa54b(%rip), %rsi      # 0x38678
leaq 0xa5cd(%rip), %rdx      # 0x38701
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x28(%rsp), %rdi
jmp 0x2e1f3
leaq 0x98(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa10d(%rip), %rsi      # 0x38284
leaq 0xa2b9(%rip), %rdx      # 0x38437
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x88(%rsp), %rdi
jmp 0x2e1f3
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa277(%rip), %rsi      # 0x38438
leaq 0xa40b(%rip), %rdx      # 0x385d3
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x6d9c
movzbl 0x2c3c(%rbx), %esi
addq $0x970, %rbx            # imm = 0x970
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d808
leaq 0x68(%rsp), %rdi
callq 0x3150
movl $0x1, %edi
callq 0x33d0
movq %rax, %rbx
movq 0x68(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x88(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0xa8(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0xc8(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x108(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x168(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x188(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x1a8(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0xe8(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x128(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x148(%rsp), %rdi
jmp 0x2e2b9
movq %rax, %rbx
movq 0x1c8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x2e2cd
jmp 0x2e2d2
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2e2d2
callq 0x3310
movq %rbx, %rdi
callq 0x3580