// File: /workspace/github_cpp_makefile_star2_O2/bobverity[P]MavericK/readIn.cpp
// Function: readData(globals&)
void readData(globals &globals) {
    
    cout << "Loading data file...\n";
    writeToFile("Data properties\n", globals.outputLog_on, globals.outputLog_fileStream);
    
    // open file stream
    globals.data_fileStream = safe_ifstream(globals.data_filePath, globals.outputLog_on, globals.outputLog_fileStream);
    
    // read in raw data file as matrix of strings. Skip header line if necessary
    vector< vector<string> > rawEntries;
    vector<string> rawEntries_line;
    string line1;
    int row=0;
    while (safe_getline(globals.data_fileStream, line1))
    {
        if (line1.size()==0)
            continue;
        row++;
        if (row==1 && globals.headerRow_on)
            continue;
        rawEntries_line.clear();
        istringstream ss(line1);
        string line2;
        while (getline(ss, line2, '\t'))
        {
            string line3 = istringstream(line2).str();
            rawEntries_line.push_back(line3);
        }
        rawEntries.push_back(rawEntries_line);
    }
    
    // close file stream
    globals.data_fileStream.close();
    
    // if no data then abort
    if (rawEntries.size()==0) {
        cerrAndLog("\nError: data file appears to be empty\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // check same number of values in each row
    int cols = int(rawEntries[0].size());
    for (int i=0; i<int(rawEntries.size()); i++) {
        int row = globals.headerRow_on ? i+2 : i+1;
        if (rawEntries[i].size()!=cols) {
            cerrAndLog("\nError: row "+to_string((long long)row)+string(" in data file does not contain ")+to_string((long long)cols)+string(" entries\n"), globals.outputLog_on, globals.outputLog_fileStream);
            exit(1);
        }
    }
    
    // check that number of columns is compatible with data format options
    int minCols = 2;
    minCols = globals.popCol_on ? minCols+1 : minCols;
    minCols = globals.ploidyCol_on ? minCols+1 : minCols;
    if (cols<minCols) {
        cerrAndLog("\nError: data file must contain at least "+to_string((long long)minCols)+string(" columns under current settings\n"), globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // find which columns in data file correspond to special values
    int pop_startRead = -1;
    int ploidy_startRead = -1;
    int data_startRead = 1;
    if (globals.ploidyCol_on) {
        ploidy_startRead = 1;
        data_startRead++;
    }
    if (globals.popCol_on) {
        pop_startRead = 1;
        if (ploidy_startRead!=-1)
            ploidy_startRead++;
        data_startRead++;
    }
    
    // print these to screen and file
    if (globals.headerRow_on)
        coutAndLog("  row 1 = header line\n", globals.outputLog_on, globals.outputLog_fileStream);
    coutAndLog("  column 1 = individual labels\n", globals.outputLog_on, globals.outputLog_fileStream);
    if (pop_startRead!=-1)
        coutAndLog("  column "+to_string((long long)pop_startRead+1)+" = population of origin\n", globals.outputLog_on, globals.outputLog_fileStream);
    if (ploidy_startRead!=-1)
        coutAndLog("  column "+to_string((long long)ploidy_startRead+1)+" = ploidy\n", globals.outputLog_on, globals.outputLog_fileStream);
    
    // split rawData into special columns and data matrix
    vector<string> indLabels_raw, pop_raw, ploidy_raw;
    vector< vector<string> > rawData;
    vector<string> rawData_line;
    for (int i=0; i<int(rawEntries.size()); i++) {
        rawData_line.clear();
        for (int j=0; j<int(rawEntries[i].size()); j++) {
            
            // read in individual labels
            if (j==0)
                indLabels_raw.push_back(rawEntries[i][j]);
            
            // read in population labels
            if (j==pop_startRead)
                pop_raw.push_back(rawEntries[i][j]);
            
            // read in ploidy for each individual
            if (j==ploidy_startRead)
                ploidy_raw.push_back(rawEntries[i][j]);
            
            // read in data
            if (j>=data_startRead)
                rawData_line.push_back(rawEntries[i][j]);
            
        }
        rawData.push_back(rawData_line);
    }
    
    // finally define number of loci
    globals.loci = int(rawData[0].size());
    
    // convert ploidy labels into integer format
    vector<int> ploidy_raw_int(rawEntries.size(),globals.ploidy);
    if (globals.ploidyCol_on) {
        for (int i=0; i<int(ploidy_raw.size()); i++) {
            double param_double=0;
            istringstream(ploidy_raw[i]) >> param_double;
            if (my_round(double(param_double))==param_double && my_round(double(param_double))>=0) {
                ploidy_raw_int[i] = int(param_double);
            } else {
                cerrAndLog("\nError: all ploidy values in data file must be positive integers\n", globals.outputLog_on, globals.outputLog_fileStream);
                exit(1);
            }
        }
    }
    
    // check that ploidy values make sense. Ploidy must be either defined on the first row of an individual (ploidy_format==1), or defined equally for all rows of an individual (ploidy_format==2).
    int thisPloidy=0, countDown=0, ploidy_format=0;
    bool ploidyError = false;
    for (int i=0; i<int(rawEntries.size()); i++) {
        // if new individual
        if (countDown==0) {
            if (ploidy_raw_int[i]!=0) {
                thisPloidy = ploidy_raw_int[i];
                countDown = thisPloidy-1;
            } else {
                ploidyError = true;
            }
        } else {
            if (ploidy_raw_int[i]==0) {
                if (ploidy_format==0 || ploidy_format==1) {
                    ploidy_format = 1;
                    countDown--;
                } else {
                    ploidyError = true;
                }
            } else if (ploidy_raw_int[i]==thisPloidy) {
                if (ploidy_format==0 || ploidy_format==2) {
                    ploidy_format = 2;
                    countDown--;
                } else {
                    ploidyError = true;
                }
            } else {
                ploidyError = true;
            }
        }
        if (ploidyError) {
            cerrAndLog("\nError: when reading ploidy for each individual from file (using the ploidyCol_on=true option) the data file must contain a ploidy value on the first row of each individual, or alternatively the same ploidy value for all rows of an individual\n", globals.outputLog_on, globals.outputLog_fileStream);
            exit(1);
        }
    }
    if (countDown!=0) {
        cerrAndLog("\nError: data file does not contain sufficient rows to account for ploidy values (also check that headerRow_on is specified correctly)\n", globals.outputLog_on, globals.outputLog_fileStream);
        exit(1);
    }
    
    // similarly for pop values. Pop values must be either defined on the first row of an individual (pop_format==1), or defined equally for all rows of an individual (pop_format==2).
    if (globals.popCol_on) {
        countDown=0;
        string thisPop;
        int pop_format=0;
        bool popError = false;
        for (int i=0; i<int(rawEntries.size()); i++) {
            // if new individual
            if (countDown==0) {
                thisPop = pop_raw[i];
                countDown = ploidy_raw_int[i]-1;
            // if not new individual
            } else {
                if (pop_raw[i]=="") {
                    if (pop_format==0 || pop_format==1) {
                        pop_format = 1;
                        countDown--;
                    } else {
                        popError = true;
                    }
                } else if (pop_raw[i]==thisPop) {
                    if (pop_format==0 || pop_format==2) {
                        pop_format = 2;
                        countDown--;
                    } else {
                        popError = true;
                    }
                } else {
                    popError = true;
                }
            }
            if (popError) {
                cerrAndLog("\nError: when reading population of origin for each individual from file (using the popCol_on=true option) the data file must contain a population value on the first row of each individual, or alternatively the same population value for all rows of an individual\n", globals.outputLog_on, globals.outputLog_fileStream);
                exit(1);
            }
        }
    }
    
    // find all unique alleles, and count number of missing values
    globals.J = vector<int>(globals.loci);
    globals.uniqueAlleles = vector< vector<string> >(globals.loci,vector<string>());
    int missingDataCount = 0;
    for (int j=0; j<globals.loci; j++) {
        for (int i=0; i<int(rawData.size()); i++) {
            if (rawData[i][j]==globals.missingData) {
                missingDataCount++;
            } else {
                if (find(globals.uniqueAlleles[j].begin(), globals.uniqueAlleles[j].end(), rawData[i][j]) == globals.uniqueAlleles[j].end()) {
                    globals.uniqueAlleles[j].push_back(rawData[i][j]);
                }
            }
        }
        globals.J[j] = int(globals.uniqueAlleles[j].size());
    }
    
    // reformat data into simple list: data[individual][locus][gene copy]. Recode values to simple list of integers, with 0 meaning missing data. Keep record of missing data elements in data_missing (1=missing, 0=present). Store indLabels_vec, pop_vec, ploidy_vec and missing_vec values.
    countDown=0;
    int ind=-1, gene_copy=0;
    for (int i=0; i<int(rawEntries.size()); i++) {
        // if new individual
        if (countDown==0) {
            ind++;
            globals.indLabels_vec.push_back(indLabels_raw[i]);
            if (globals.popCol_on) {
                globals.pop_vec.push_back(pop_raw[i]);
            } else {
                globals.pop_vec.push_back("NA");
            }
            globals.ploidy_vec.push_back(ploidy_raw_int[i]);
            globals.missing_vec.push_back(0);
            countDown = globals.ploidy_vec[ind]-1;
            gene_copy = 0;
            
            globals.data.push_back(vector< vector<int> >(globals.loci,vector<int>(globals.ploidy_vec[ind])));
            for (int l=0; l<globals.loci; l++) {
                if (rawData[i][l]==globals.missingData) {
                    globals.data[ind][l][gene_copy] = 0;
                    globals.missing_vec[ind]++;
                } else {
                    globals.data[ind][l][gene_copy] = whichFirst(globals.uniqueAlleles[l],rawData[i][l])+1;
                }
            }
        // if not new individual
        } else {
            countDown--;
            gene_copy++;
            for (int l=0; l<globals.loci; l++) {
                if (rawData[i][l]==globals.missingData) {
                    globals.data[ind][l][gene_copy] = 0;
                    globals.missing_vec[ind]++;
                } else {
                    globals.data[ind][l][gene_copy] = whichFirst(globals.uniqueAlleles[l],rawData[i][l])+1;
                }
            }
        }
    }
    
    // finally define number of individuals and gene copies
    globals.n = int(globals.indLabels_vec.size());
    globals.geneCopies = sum(globals.ploidy_vec)*globals.loci;
    
    // check that there is at least one allele at every locus
    for (int l=0; l<globals.loci; l++) {
        bool tmp = true;
        for (int i=0; i<globals.n; i++) {
            for (int p=0; p<globals.ploidy_vec[i]; p++) {
                if (globals.data[i][l][p]!=0)
                    tmp = false;
            }
        }
        if (tmp) {
            coutAndLog("\nError: there must be at least one non-missing observation at every locus\n", globals.outputLog_on, globals.outputLog_fileStream);
            exit(1);
        }
    }
    
    // find number of unique populations and store pop index of each individual
    if (globals.popCol_on) {
        globals.pop_index = vector<int>(globals.n);
        for (int i=0; i<globals.n; i++) {
            if (find(globals.uniquePops.begin(), globals.uniquePops.end(), globals.pop_vec[i]) == globals.uniquePops.end()) {
                globals.uniquePops.push_back(globals.pop_vec[i]);
                globals.pop_index[i] = int(globals.uniquePops.size())-1;
            } else {
                globals.pop_index[i] = int(find(globals.uniquePops.begin(), globals.uniquePops.end(), globals.pop_vec[i]) - globals.uniquePops.begin());
            }
        }
        globals.uniquePop_counts = vector<int>(globals.uniquePops.size());
        for (int i=0; i<globals.n; i++) {
            globals.uniquePop_counts[globals.pop_index[i]]++;
        }
    }
    
    // print basic properties to screen and file
    if (globals.popCol_on)
        coutAndLog("  unique populations = "+to_string((long long)globals.uniquePops.size())+string("\n"), globals.outputLog_on, globals.outputLog_fileStream);
    
    coutAndLog("  individuals = "+to_string((long long)globals.n)+string("\n"), globals.outputLog_on, globals.outputLog_fileStream);
    coutAndLog("  loci = "+to_string((long long)globals.loci)+string("\n"), globals.outputLog_on, globals.outputLog_fileStream);
    
    stringstream alleles;
    alleles << "  alleles per locus = {" << globals.J[0];
    for (int l=1; l<globals.loci; l++) {
        alleles << "," << globals.J[l];
    }
    alleles << "}\n";
    coutAndLog(alleles.str(), globals.outputLog_on, globals.outputLog_fileStream);
    
    coutAndLog("  missing observations = "+to_string((long long)missingDataCount)+string(" of ")+to_string((long long)sum(globals.ploidy_vec)*globals.loci)+string("\n\n"), globals.outputLog_on, globals.outputLog_fileStream);    
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x898, %rsp            # imm = 0x898
movq %rdi, %r15
movq 0x14c9d(%rip), %rdi     # 0x33fb8
leaq 0x92d7(%rip), %rsi      # 0x285f9
callq 0x3350
leaq 0x92e1(%rip), %rsi      # 0x2860f
leaq 0x818(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movzbl 0x2c3c(%r15), %esi
leaq 0x970(%r15), %r14
leaq 0x818(%rsp), %rdi
movq %r14, %rdx
callq 0x1766c
leaq 0x818(%rsp), %rdi
callq 0x3170
leaq 0x2e0(%r15), %rsi
leaq 0x838(%rsp), %rbx
movq %rbx, %rdi
callq 0x3430
movzbl 0x2c3c(%r15), %edx
leaq 0x228(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x17702
movq %r14, 0x10(%rsp)
movq %r15, 0x8(%rsp)
leaq 0x768(%r15), %rbx
leaq 0x228(%rsp), %rsi
movq %rbx, %rdi
callq 0x34f0
leaq 0x228(%rsp), %rdi
callq 0x30e0
leaq 0x838(%rsp), %rdi
callq 0x3170
xorpd %xmm0, %xmm0
leaq 0x50(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x5b0(%rsp), %r12
andq $0x0, 0x10(%r12)
leaq 0x218(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movapd %xmm0, (%r12)
movb $0x0, (%rax)
xorl %eax, %eax
leaq 0x208(%rsp), %rbp
leaq 0x28(%rsp), %r14
leaq 0x430(%rsp), %r15
leaq 0xc0(%rsp), %r13
movl %eax, 0x18(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x17a2f
movq 0x8(%rsp), %rcx
movq 0x768(%rcx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x788(%rcx,%rax)
jne 0x1f54d
cmpq $0x0, 0x210(%rsp)
je 0x1f439
cmpl $0x0, 0x18(%rsp)
je 0x1f533
movq %r12, %rdi
callq 0x2195e
leaq 0x228(%rsp), %rdi
movq %rbp, %rsi
pushq $0x8
popq %rdx
callq 0x3520
incl 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
andq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
leaq 0x228(%rsp), %rdi
movq %r14, %rsi
pushq $0x9
popq %rdx
callq 0x35e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1f508
movq %r15, %rdi
movq %r14, %rsi
pushq $0x8
popq %rdx
callq 0x3520
movq %r13, %rdi
leaq 0x440(%rsp), %rsi
callq 0x34b0
movq %r15, %rdi
callq 0x3180
movq %r12, %rdi
movq %r13, %rsi
callq 0x218a6
movq %r13, %rdi
callq 0x3170
jmp 0x1f4ac
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0x21966
movq %r14, %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3180
movl 0x18(%rsp), %eax
jmp 0x1f435
movq 0x8(%rsp), %rax
cmpb $0x0, 0x2ba0(%rax)
pushq $0x1
popq %rax
jne 0x1f435
jmp 0x1f478
movq %rbx, %rdi
callq 0x3090
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
subq %rsi, %rax
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r12
je 0x20abb
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
addq $0x8, %rsi
shrq $0x5, %rcx
movslq %ecx, %rbx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rdx, %rax
je 0x1f70a
movq (%rsi), %rdi
subq -0x8(%rsi), %rdi
incq %rdx
sarq $0x5, %rdi
addq $0x18, %rsi
cmpq %rbx, %rdi
je 0x1f593
cmpb $0x0, 0x2ba0(%r12)
leal 0x1(%rdx), %eax
cmoveq %rdx, %rax
movl %eax, %esi
leaq 0xc0(%rsp), %rdi
callq 0x60a6
leaq 0x906e(%rip), %rsi      # 0x28647
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x6082
leaq 0x9062(%rip), %rsi      # 0x28654
leaq 0x1c8(%rsp), %rdi
leaq 0x1e8(%rsp), %rdx
callq 0x3130
leaq 0x430(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x1c8(%rsp), %rdx
callq 0x601b
leaq 0x1a8(%rsp), %rdi
movq %rbx, %rsi
callq 0x60a6
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rsi
leaq 0x1a8(%rsp), %rdx
callq 0x601b
leaq 0x901f(%rip), %rsi      # 0x28674
leaq 0x188(%rsp), %rdi
leaq 0x160(%rsp), %rdx
callq 0x3130
leaq 0x7d8(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x188(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x7d8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x7d8(%rsp), %rdi
callq 0x3170
leaq 0x188(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x1a8(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
leaq 0x1c8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0xc0(%rsp), %rdi
jmp 0x20aae
movzbl 0x2ba1(%r12), %eax
movzbl 0x2ba2(%r12), %ebx
movq %rax, 0x18(%rsp)
addl %ebx, %eax
addl $0x2, %eax
cmpl %ecx, %eax
jg 0x20aff
cmpb $0x1, 0x2ba0(%r12)
jne 0x1f77b
leaq 0x8f88(%rip), %rsi      # 0x286c8
leaq 0x798(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movzbl 0x2c3c(%r12), %esi
leaq 0x798(%rsp), %rdi
movq %r15, %rdx
callq 0x1768c
leaq 0x798(%rsp), %rdi
callq 0x3170
leaq 0x8f5d(%rip), %rsi      # 0x286df
leaq 0x778(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movzbl 0x2c3c(%r12), %esi
leaq 0x778(%rsp), %rdi
movq %r15, %rdx
callq 0x1768c
leaq 0x778(%rsp), %rdi
callq 0x3170
cmpq $0x0, 0x18(%rsp)
je 0x1f851
leaq 0x430(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x60a6
leaq 0x8f1f(%rip), %rsi      # 0x286ff
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x8f0d(%rip), %rdx      # 0x28709
leaq 0x758(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0xcf2e
movzbl 0x2c3c(%r12), %esi
leaq 0x758(%rsp), %rdi
movq %r15, %rdx
callq 0x1768c
leaq 0x758(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
movzbl %bl, %r14d
leal -0x1(%r14), %eax
movq 0x18(%rsp), %rcx
leal 0x1(%rcx), %ebx
orl %eax, %ebx
cmpl $-0x1, %ebx
je 0x1f8f4
leal 0x1(%rbx), %esi
leaq 0x430(%rsp), %rdi
callq 0x60a6
leaq 0x8e7c(%rip), %rsi      # 0x286ff
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x8e83(%rip), %rdx      # 0x28722
leaq 0x738(%rsp), %rdi
leaq 0x228(%rsp), %rsi
callq 0xcf2e
movzbl 0x2c3c(%r12), %esi
leaq 0x738(%rsp), %rdi
movq %r15, %rdx
callq 0x1768c
leaq 0x738(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
movq 0x18(%rsp), %rax
leaq (%r14,%rax), %r13
incq %r13
xorpd %xmm0, %xmm0
leaq 0x160(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0xf0(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x140(%rsp), %rax
andq $0x0, 0x10(%rax)
leaq 0x90(%rsp), %rcx
andq $0x0, 0x10(%rcx)
movapd %xmm0, (%rax)
movapd %xmm0, (%rcx)
leaq 0x120(%rsp), %rax
movapd %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movl %ebx, %r14d
xorl %r15d, %r15d
movq %r14, %rbx
shlq $0x5, %rbx
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x1fa68
leaq 0x120(%rsp), %rdi
callq 0x2195e
movq %r15, 0x20(%rsp)
imulq $0x18, %r15, %r12
pushq $-0x20
popq %r15
xorl %ebp, %ebp
movq 0x50(%rsp), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rax
subq %rsi, %rax
shrq $0x5, %rax
cltq
cmpq %rax, %rbp
jge 0x1fa46
leaq 0x160(%rsp), %rdi
testq %rbp, %rbp
je 0x1f9f4
movq 0x18(%rsp), %rax
xorb $0x1, %al
cmpq $0x1, %rbp
setne %cl
orb %al, %cl
jne 0x1f9f9
movq 0x50(%rsp), %rax
movq (%rax,%r12), %rsi
addq $0x20, %rsi
leaq 0xf0(%rsp), %rdi
callq 0x218a6
cmpq %rbp, %r14
jne 0x1fa17
movq 0x50(%rsp), %rax
movq (%rax,%r12), %rsi
addq %rbx, %rsi
leaq 0x140(%rsp), %rdi
callq 0x218a6
cmpq %r13, %rbp
jb 0x1fa3a
movq 0x50(%rsp), %rax
movq (%rax,%r12), %rax
leaq (%rax,%r15), %rsi
addq $0x20, %rsi
leaq 0x120(%rsp), %rdi
callq 0x218a6
incq %rbp
addq $0x20, %r15
jmp 0x1f9a0
leaq 0x90(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x21966
movq 0x20(%rsp), %r15
incq %r15
jmp 0x1f966
movq 0x90(%rsp), %rcx
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
shrq $0x5, %rdx
movq 0x8(%rsp), %r13
movl %edx, 0x2d1c(%r13)
leaq 0x2ba4(%r13), %rdx
leaq 0x108(%rsp), %rdi
leaq 0x228(%rsp), %rcx
movq %rax, %rsi
callq 0x5f08
cmpb $0x1, 0x2ba2(%r13)
jne 0x1fb71
xorl %r15d, %r15d
leaq 0x228(%rsp), %rbx
pushq $0x8
popq %rbp
leaq 0x430(%rsp), %r14
xorl %r12d, %r12d
movq 0x140(%rsp), %rsi
movq 0x148(%rsp), %rax
subq %rsi, %rax
shrq $0x5, %rax
cltq
cmpq %rax, %r12
jge 0x1fb71
andq $0x0, 0x430(%rsp)
addq %r15, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x3520
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3180
movsd 0x430(%rsp), %xmm0
callq 0x14cb8
cvtsi2sd %eax, %xmm1
movsd 0x430(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x20a28
jp 0x20a28
callq 0x14cb8
testl %eax, %eax
js 0x20a28
cvttsd2si 0x430(%rsp), %eax
movq 0x108(%rsp), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
addq $0x20, %r15
jmp 0x1facd
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rcx
movq %rcx, %rax
subq %rsi, %rax
cqto
pushq $0x18
popq %rdi
idivq %rdi
movq 0x108(%rsp), %rdx
xorl %edi, %edi
testl %eax, %eax
cmovlel %edi, %eax
pushq $0x1
popq %r8
pushq $0x2
popq %r9
xorl %ebp, %ebp
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpq %rdi, %rax
je 0x1fbf6
movl (%rdx,%rdi,4), %ebx
testl %r10d, %r10d
je 0x1fbd1
testl %ebx, %ebx
je 0x1fbdd
cmpl %ebp, %ebx
jne 0x209e1
movl %ebp, %ebx
andl $-0x3, %r11d
movl %r9d, %r11d
je 0x1fbec
jmp 0x209e1
movl %ebx, %r10d
testl %ebx, %ebx
jne 0x1fbec
jmp 0x209e1
movl %ebp, %ebx
cmpl $0x2, %r11d
movl %r8d, %r11d
jae 0x209e1
decl %r10d
incq %rdi
movl %ebx, %ebp
jmp 0x1fba8
testl %r10d, %r10d
jne 0x20bac
cmpb $0x1, 0x2ba1(%r13)
jne 0x1fce8
leaq 0x238(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r15d, %r15d
leaq 0x228(%rsp), %rbx
leaq 0x7c89(%rip), %r14      # 0x278bc
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %ebp, %ebp
subq %rsi, %rcx
movq %rcx, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cltq
cmpq %rax, %r13
jge 0x1fcd6
movq 0xf0(%rsp), %rsi
addq %r15, %rsi
testl %r12d, %r12d
je 0x1fc80
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1687c
testb %al, %al
je 0x1fc96
cmpl $0x2, %ebp
pushq $0x1
popq %rbp
jb 0x1fcbd
jmp 0x20a6c
movq %rbx, %rdi
callq 0x31f0
movq 0x108(%rsp), %rax
movl (%rax,%r13,4), %r12d
jmp 0x1fcbd
movq 0xf0(%rsp), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x21882
testb %al, %al
je 0x20a6c
andl $-0x3, %ebp
pushq $0x2
popq %rbp
jne 0x20a6c
decl %r12d
incq %r13
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rcx
addq $0x20, %r15
jmp 0x1fc3b
leaq 0x228(%rsp), %rdi
callq 0x3170
movq 0x8(%rsp), %r13
movslq 0x2d1c(%r13), %rsi
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x5f7c
leaq 0x2d20(%r13), %rdi
leaq 0x228(%rsp), %rbx
movq %rdi, 0xb0(%rsp)
movq %rbx, %rsi
callq 0x6266
movq %rbx, %rdi
callq 0x61d0
movslq 0x2d1c(%r13), %rsi
xorpd %xmm0, %xmm0
leaq 0x430(%rsp), %rdx
movapd %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x228(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x21992
leaq 0x2d38(%r13), %r14
leaq 0x228(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22054
movq %rbx, %rdi
movq %r14, %rbx
callq 0x11260
leaq 0x430(%rsp), %rdi
callq 0x995e
leaq 0x2ba8(%r13), %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
movl $0x0, 0x7c(%rsp)
movslq 0x2d1c(%r13), %rcx
cmpq %rcx, %r14
jge 0x1fe78
movq %r14, %r12
shlq $0x5, %r12
imulq $0x18, %r14, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x90(%rsp), %rcx
movq 0x98(%rsp), %rax
subq %rcx, %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %rbp
jge 0x1fe4c
movq (%rcx,%r13), %rdi
addq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x21882
testb %al, %al
je 0x1fdff
incl 0x7c(%rsp)
jmp 0x1fe40
movq (%rbx), %rax
movq (%rax,%r15), %rdi
movq 0x8(%rax,%r15), %rsi
movq 0x90(%rsp), %rax
movq (%rax,%r13), %rdx
addq %r12, %rdx
callq 0x220a5
movq (%rbx), %rdi
cmpq 0x8(%rdi,%r15), %rax
jne 0x1fe40
addq %r15, %rdi
movq 0x90(%rsp), %rax
movq (%rax,%r13), %rsi
addq %r12, %rsi
callq 0x218a6
incq %rbp
addq $0x18, %r13
jmp 0x1fdc2
movq (%rbx), %rax
movq 0x8(%rax,%r15), %rcx
subq (%rax,%r15), %rcx
shrq $0x5, %rcx
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movl %ecx, (%rax,%r14,4)
incq %r14
movq 0x8(%rsp), %r13
jmp 0x1fda2
leaq 0x2d00(%r13), %rax
movq %rax, 0x20(%rsp)
leaq 0x2ce8(%r13), %rax
movq %rax, 0xb8(%rsp)
leaq 0x2c58(%r13), %rax
movq %rax, 0x180(%rsp)
leaq 0x2c70(%r13), %rax
movq %rax, 0x80(%rsp)
leaq 0x2cd0(%r13), %rax
movq %rax, 0xa8(%rsp)
pushq $-0x1
popq %rax
movl %eax, 0x48(%rsp)
xorl %r14d, %r14d
xorl %edi, %edi
xorl %r8d, %r8d
movq 0x10(%rsp), %r13
movq %rbx, 0xe0(%rsp)
movq 0x58(%rsp), %rax
subq 0x50(%rsp), %rax
cqto
pushq $0x18
popq %rsi
idivq %rsi
cltq
cmpq %rax, %r14
jge 0x20276
testl %edi, %edi
movq %r14, 0xe8(%rsp)
je 0x20033
movl %edi, 0x78(%rsp)
incl %r8d
movslq 0x48(%rsp), %r15
movl %r8d, 0x88(%rsp)
movslq %r8d, %rax
movq %rax, 0x70(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %ebp, %ebp
movslq %ecx, %rax
cmpq %rax, %rbp
jge 0x20026
movq 0x90(%rsp), %rax
imulq $0x18, 0xe8(%rsp), %rbx
movq (%rax,%rbx), %rdi
addq %r12, %rdi
movq 0x18(%rsp), %rsi
callq 0x21882
testb %al, %al
je 0x1ff8d
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x18, %r15, %rcx
movq (%rax,%rcx), %rax
movq (%rax,%r14), %rax
movq 0x70(%rsp), %rcx
andl $0x0, (%rax,%rcx,4)
movq 0xb8(%rsp), %rax
movq (%rax), %rax
incl (%rax,%r15,4)
jmp 0x2000b
movq 0xe0(%rsp), %rax
movq (%rax), %rsi
addq %r14, %rsi
leaq 0x688(%rsp), %rdi
callq 0x21a38
movq 0x90(%rsp), %rax
movq (%rax,%rbx), %rsi
addq %r12, %rsi
leaq 0x858(%rsp), %rbx
movq %rbx, %rdi
callq 0x3430
movq %rbx, %r13
leaq 0x688(%rsp), %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x219e8
incl %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x18, %r15, %rdx
movq (%rcx,%rdx), %rcx
movq (%rcx,%r14), %rcx
movq 0x70(%rsp), %rdx
movl %eax, (%rcx,%rdx,4)
movq %r13, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x995e
incq %rbp
movq 0x8(%rsp), %rax
movl 0x2d1c(%rax), %ecx
addq $0x20, %r12
addq $0x18, %r14
jmp 0x1ff2d
movl 0x88(%rsp), %r8d
jmp 0x2025b
movq %r14, %r15
shlq $0x5, %r15
movq 0x160(%rsp), %rsi
addq %r15, %rsi
movq 0x180(%rsp), %rdi
callq 0x218a6
movq 0x8(%rsp), %rbx
leaq 0x228(%rsp), %r12
leaq 0x430(%rsp), %r13
cmpb $0x1, 0x2ba1(%rbx)
jne 0x2008a
addq 0xf0(%rsp), %r15
movq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0x218a6
jmp 0x200b4
movq %r12, %rdi
leaq 0x995f(%rip), %rsi      # 0x299f3
movq %r13, %rdx
callq 0x3130
movq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0x22190
movq %r12, %rdi
callq 0x3170
leaq (,%r14,4), %rsi
addq 0x108(%rsp), %rsi
movq 0xa8(%rsp), %rdi
callq 0x5f5e
andl $0x0, 0x228(%rsp)
movq 0xb8(%rsp), %rdi
movq %r12, %rsi
callq 0x16e6e
movl 0x48(%rsp), %eax
incl %eax
movl %eax, 0x48(%rsp)
movslq %eax, %rcx
movq 0x2cd0(%rbx), %rax
movq %rcx, 0x88(%rsp)
movl (%rax,%rcx,4), %ebp
movslq 0x2d1c(%rbx), %rbx
movslq %ebp, %rsi
movq %r13, %rdi
leaq 0x28(%rsp), %rdx
callq 0x5f7c
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
leaq 0xc0(%rsp), %rcx
callq 0x9908
movl %ebp, 0x78(%rsp)
movq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x2226e
movq %r12, %rdi
callq 0x98e6
movq %r13, %rdi
callq 0x61d0
imulq $0x18, %r14, %r14
imulq $0x18, 0x88(%rsp), %rax
movq %rax, 0x70(%rsp)
xorl %r13d, %r13d
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x8(%rsp), %rax
movslq 0x2d1c(%rax), %rcx
cmpq %rcx, %r15
jge 0x20258
movq 0x90(%rsp), %rax
movq (%rax,%r14), %rdi
addq %rbp, %rdi
movq 0x18(%rsp), %rsi
callq 0x21882
testb %al, %al
je 0x201d2
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x70(%rsp), %rcx
movq (%rax,%rcx), %rax
movq (%rax,%r13), %rax
andl $0x0, (%rax)
movq 0xb8(%rsp), %rax
movq (%rax), %rax
movq 0x88(%rsp), %rcx
incl (%rax,%rcx,4)
jmp 0x20248
movq 0xe0(%rsp), %rax
movq (%rax), %rsi
addq %r13, %rsi
leaq 0x6a0(%rsp), %rdi
callq 0x21a38
movq 0x90(%rsp), %rax
movq (%rax,%r14), %rsi
addq %rbp, %rsi
leaq 0x878(%rsp), %r12
movq %r12, %rdi
callq 0x3430
leaq 0x6a0(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x219e8
incl %eax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x70(%rsp), %rdx
movq (%rcx,%rdx), %rcx
movq (%rcx,%r13), %rcx
movl %eax, (%rcx)
movq %r12, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x995e
incq %r15
addq $0x20, %rbp
addq $0x18, %r13
jmp 0x20170
xorl %r8d, %r8d
movl 0x78(%rsp), %edi
decl %edi
movq 0xe8(%rsp), %r14
incq %r14
movq 0x10(%rsp), %r13
jmp 0x1fedc
movq 0x8(%rsp), %rbx
movq 0x2c60(%rbx), %rax
subq 0x2c58(%rbx), %rax
shrq $0x5, %rax
movl %eax, 0x2d18(%rbx)
movq 0xa8(%rsp), %rdi
callq 0x50fb
movl 0x2d1c(%rbx), %ecx
imull %ecx, %eax
movl %eax, 0x2d50(%rbx)
movl 0x2d18(%rbx), %eax
movslq %eax, %rsi
movq 0x2cd0(%rbx), %rdx
movq 0x2d00(%rbx), %rdi
xorl %r8d, %r8d
testl %esi, %esi
movl $0x0, %r9d
cmovgl %esi, %r9d
testl %ecx, %ecx
cmovlel %r8d, %ecx
xorl %r10d, %r10d
cmpq %rcx, %r10
je 0x20385
movb $0x1, %r11b
imulq $0x18, %r10, %rbx
xorl %r14d, %r14d
cmpq %r9, %r14
je 0x20335
movl (%rdx,%r14,4), %r15d
imulq $0x18, %r14, %r12
addq %rdi, %r12
testl %r15d, %r15d
cmovlel %r8d, %r15d
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x2032b
movq (%r12), %rbp
movq (%rbp,%rbx), %rbp
cmpl $0x0, (%rbp,%r13,4)
sete %bpl
andb %bpl, %r11b
incq %r13
jmp 0x2030b
incq %r14
movq 0x10(%rsp), %r13
jmp 0x202f1
incq %r10
testb $0x1, %r11b
je 0x202de
leaq 0x86ac(%rip), %rsi      # 0x289f1
leaq 0x668(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x668(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x1768c
leaq 0x668(%rsp), %rdi
jmp 0x20aae
movq 0x8(%rsp), %rcx
movb 0x2ba1(%rcx), %cl
testb %cl, %cl
je 0x204fe
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x5f7c
movq 0x8(%rsp), %r15
leaq 0x2cb8(%r15), %rbx
leaq 0x228(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6266
movq %r14, %rdi
callq 0x61d0
leaq 0x2c88(%r15), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rsp), %rbp
movslq 0x2d18(%rbp), %rax
cmpq %rax, %r12
jge 0x20480
movq 0x2c88(%rbp), %rdi
movq 0x2c90(%rbp), %rsi
movq 0x2c70(%rbp), %rdx
addq %r15, %rdx
callq 0x220a5
movq 0x2c90(%rbp), %rsi
cmpq %rsi, %rax
je 0x2043e
movq (%r14), %rdi
movq 0x80(%rsp), %rax
movq (%rax), %rdx
addq %r15, %rdx
callq 0x220a5
subq (%r14), %rax
shrq $0x5, %rax
jmp 0x2046d
movq 0x80(%rsp), %rax
movq (%rax), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x218a6
movq 0x8(%rsp), %rcx
movq 0x2c90(%rcx), %rax
subq 0x2c88(%rcx), %rax
shrq $0x5, %rax
decl %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r12,4)
incq %r12
addq $0x20, %r15
jmp 0x203e6
movq 0x2c90(%rbp), %rsi
subq 0x2c88(%rbp), %rsi
sarq $0x5, %rsi
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x5f7c
leaq 0x2ca0(%rbp), %rdi
leaq 0x228(%rsp), %rbx
movq %rbx, %rsi
callq 0x6266
movq %rbx, %rdi
callq 0x61d0
movq 0x2ca0(%rbp), %rcx
movq 0x2cb8(%rbp), %rdx
xorl %esi, %esi
movq 0x8(%rsp), %rax
movslq 0x2d18(%rax), %rax
cmpq %rax, %rsi
jge 0x204f3
movslq (%rdx,%rsi,4), %rax
incl (%rcx,%rax,4)
incq %rsi
jmp 0x204d6
movq 0x8(%rsp), %rcx
movb 0x2ba1(%rcx), %cl
testb $0x1, %cl
je 0x205cd
movq 0x8(%rsp), %rax
movq 0x2c90(%rax), %rsi
subq 0x2c88(%rax), %rsi
sarq $0x5, %rsi
leaq 0x430(%rsp), %rdi
callq 0x60a6
leaq 0x850a(%rip), %rsi      # 0x28a3c
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x736d(%rip), %rsi      # 0x278bb
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x3130
leaq 0x648(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rbx
movzbl 0x2c3c(%rbx), %esi
leaq 0x648(%rsp), %rdi
movq %r13, %rdx
callq 0x1768c
leaq 0x648(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
movl 0x2d18(%rbx), %eax
movslq %eax, %rsi
leaq 0x430(%rsp), %rdi
callq 0x60a6
leaq 0x8470(%rip), %rsi      # 0x28a54
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x72bb(%rip), %rsi      # 0x278bb
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x3130
leaq 0x628(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rbx
movzbl 0x2c3c(%rbx), %esi
leaq 0x628(%rsp), %rdi
movq %r13, %rdx
callq 0x1768c
leaq 0x628(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
movslq 0x2d1c(%rbx), %rsi
leaq 0x430(%rsp), %rdi
callq 0x60a6
leaq 0x83d1(%rip), %rsi      # 0x28a65
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x720b(%rip), %rsi      # 0x278bb
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x3130
leaq 0x608(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x608(%rsp), %rdi
movq %r13, %rdx
callq 0x1768c
leaq 0x608(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3250
leaq 0x238(%rsp), %rbx
leaq 0x832a(%rip), %rsi      # 0x28a6f
movq %rbx, %rdi
callq 0x3350
movq 0xb0(%rsp), %rcx
movq (%rcx), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x3570
pushq $0x1
popq %r15
leaq 0x6ad3(%rip), %r14      # 0x27240
movq 0x8(%rsp), %rax
movslq 0x2d1c(%rax), %rax
cmpq %rax, %r15
jge 0x207a5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3350
movq 0xb0(%rsp), %rcx
movq (%rcx), %rcx
movl (%rcx,%r15,4), %esi
movq %rax, %rdi
callq 0x3570
incq %r15
jmp 0x2076d
leaq 0x82db(%rip), %rsi      # 0x28a87
movq %rbx, %rdi
callq 0x3350
leaq 0x240(%rsp), %rsi
leaq 0x5e8(%rsp), %rdi
callq 0x34b0
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x5e8(%rsp), %rdi
movq %r13, %rdx
callq 0x1768c
leaq 0x5e8(%rsp), %rdi
callq 0x3170
movslq 0x7c(%rsp), %rsi
leaq 0x1c8(%rsp), %rdi
callq 0x60a6
leaq 0x827f(%rip), %rsi      # 0x28a8a
leaq 0xc0(%rsp), %rdi
leaq 0x1c8(%rsp), %rdx
callq 0x6082
leaq 0x7315(%rip), %rsi      # 0x27b3c
leaq 0x1a8(%rsp), %rdi
leaq 0x4f(%rsp), %rdx
callq 0x3130
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
leaq 0x1a8(%rsp), %rdx
callq 0x601b
movq 0xa8(%rsp), %rdi
callq 0x50fb
cltq
movq 0x8(%rsp), %rcx
movslq 0x2d1c(%rcx), %rsi
imulq %rax, %rsi
leaq 0x188(%rsp), %rdi
callq 0x60a6
leaq 0x430(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x188(%rsp), %rdx
callq 0x601b
leaq 0x701a(%rip), %rsi      # 0x278ba
leaq 0x1e8(%rsp), %rdi
leaq 0x4e(%rsp), %rdx
callq 0x3130
leaq 0x5c8(%rsp), %rdi
leaq 0x430(%rsp), %rsi
leaq 0x1e8(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x5c8(%rsp), %rdi
movq %r13, %rdx
callq 0x1768c
leaq 0x5c8(%rsp), %rdi
callq 0x3170
leaq 0x1e8(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
callq 0x3170
leaq 0x188(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x1a8(%rsp), %rdi
callq 0x3170
leaq 0xc0(%rsp), %rdi
callq 0x3170
leaq 0x1c8(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3290
leaq 0x108(%rsp), %rdi
callq 0x61d0
leaq 0x120(%rsp), %rdi
callq 0x995e
leaq 0x90(%rsp), %rdi
callq 0x11260
leaq 0x140(%rsp), %rdi
callq 0x995e
leaq 0xf0(%rsp), %rdi
callq 0x995e
leaq 0x160(%rsp), %rdi
callq 0x995e
leaq 0x208(%rsp), %rdi
callq 0x3170
leaq 0x5b0(%rsp), %rdi
callq 0x995e
leaq 0x50(%rsp), %rdi
callq 0x11260
addq $0x898, %rsp            # imm = 0x898
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7d87(%rip), %rsi      # 0x2876f
leaq 0x6f8(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x6f8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x6f8(%rsp), %rdi
jmp 0x20aae
leaq 0x7cfe(%rip), %rsi      # 0x2872d
leaq 0x718(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x718(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x718(%rsp), %rdi
jmp 0x20aae
leaq 0x7e77(%rip), %rsi      # 0x288ea
leaq 0x6b8(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x6b8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x6b8(%rsp), %rdi
callq 0x3170
pushq $0x1
popq %rdi
callq 0x33e0
leaq 0x7b5e(%rip), %rsi      # 0x28620
leaq 0x7f8(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x7f8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x7f8(%rsp), %rdi
jmp 0x20aae
movl %eax, %esi
leaq 0x430(%rsp), %rdi
callq 0x60a6
leaq 0x7b69(%rip), %rsi      # 0x2867e
leaq 0x228(%rsp), %rdi
leaq 0x430(%rsp), %rdx
callq 0x6082
leaq 0x7b76(%rip), %rsi      # 0x286a7
leaq 0x28(%rsp), %rdi
leaq 0xc0(%rsp), %rdx
callq 0x3130
leaq 0x7b8(%rsp), %rdi
leaq 0x228(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x601b
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x7b8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x7b8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3170
leaq 0x430(%rsp), %rdi
jmp 0x20aae
leaq 0x7cb0(%rip), %rsi      # 0x28863
leaq 0x6d8(%rsp), %rdi
leaq 0x228(%rsp), %rdx
callq 0x3130
movq 0x8(%rsp), %rax
movzbl 0x2c3c(%rax), %esi
leaq 0x6d8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x176c7
leaq 0x6d8(%rsp), %rdi
jmp 0x20aae
movq %rax, %rbx
leaq 0x7b8(%rsp), %rdi
callq 0x3170
jmp 0x20c1a
movq %rax, %rbx
leaq 0x7d8(%rsp), %rdi
callq 0x3170
jmp 0x20c27
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x20cfa
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x3170
jmp 0x20c3e
jmp 0x20d01
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x3170
jmp 0x20c75
movq %rax, %rbx
leaq 0x6d8(%rsp), %rdi
jmp 0x20f36
jmp 0x20d13
movq %rax, %rbx
leaq 0x7f8(%rsp), %rdi
jmp 0x20f4b
movq %rax, %rbx
leaq 0x1a8(%rsp), %rdi
callq 0x3170
jmp 0x20d35
jmp 0x21045
movq %rax, %rbx
leaq 0x648(%rsp), %rdi
jmp 0x20e11
jmp 0x20e18
jmp 0x20e27
jmp 0x20e39
jmp 0x21045
jmp 0x21045
jmp 0x21045
movq %rax, %rbx
leaq 0x758(%rsp), %rdi
jmp 0x20cfa
jmp 0x20d01
jmp 0x20d13
jmp 0x21006
jmp 0x21006
movq %rax, %rbx
leaq 0x798(%rsp), %rdi
jmp 0x20f4b
jmp 0x21006
jmp 0x21006
movq %rax, %rbx
leaq 0x738(%rsp), %rdi
callq 0x3170
jmp 0x20d04
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x3170
jmp 0x20d16
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
jmp 0x20f4b
jmp 0x21006
jmp 0x20fe1
jmp 0x21006
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x3170
jmp 0x20ec1
movq %rax, %rbx
leaq 0x5c8(%rsp), %rdi
callq 0x3170
jmp 0x20d5c
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
callq 0x3170
jmp 0x20d6e
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x3170
jmp 0x20d80
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x3170
jmp 0x20d92
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x1a8(%rsp), %rdi
callq 0x3170
leaq 0xc0(%rsp), %rdi
callq 0x3170
leaq 0x1c8(%rsp), %rdi
callq 0x3170
jmp 0x21011
movq %rax, %rbx
jmp 0x20d9c
movq %rax, %rbx
jmp 0x20da9
movq %rax, %rbx
jmp 0x20db6
jmp 0x2100e
movq %rax, %rbx
leaq 0x5e8(%rsp), %rdi
jmp 0x20dbe
jmp 0x21045
movq %rax, %rbx
leaq 0x608(%rsp), %rdi
jmp 0x20e11
jmp 0x20e18
jmp 0x20e27
jmp 0x20e39
jmp 0x21045
movq %rax, %rbx
leaq 0x628(%rsp), %rdi
callq 0x3170
jmp 0x20e1b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
jmp 0x20e2a
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x3170
jmp 0x20e3c
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
jmp 0x20f36
jmp 0x21045
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
jmp 0x2103c
jmp 0x21045
jmp 0x21057
movq %rax, %rbx
leaq 0x778(%rsp), %rdi
jmp 0x20f4b
jmp 0x21006
jmp 0x21006
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x30e0
jmp 0x20e97
movq %rax, %rbx
leaq 0x838(%rsp), %rdi
jmp 0x20eac
movq %rax, %rbx
leaq 0x818(%rsp), %rdi
callq 0x3170
jmp 0x210bf
movq %rax, %rbx
jmp 0x210bf
movq %rax, %rbx
leaq 0x1c8(%rsp), %rdi
callq 0x3170
jmp 0x20ee5
movq %rax, %rbx
leaq 0x6b8(%rsp), %rdi
callq 0x3170
jmp 0x20f07
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
jmp 0x20f43
jmp 0x2100e
jmp 0x20f04
jmp 0x21045
jmp 0x20f04
jmp 0x21045
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
jmp 0x20f36
movq %rax, %rbx
leaq 0x668(%rsp), %rdi
jmp 0x20f36
movq %rax, %rbx
leaq 0x718(%rsp), %rdi
jmp 0x20f36
movq %rax, %rbx
leaq 0x6f8(%rsp), %rdi
callq 0x3170
jmp 0x21048
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x3170
jmp 0x2109b
jmp 0x21045
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x98e6
jmp 0x20f6f
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x61d0
jmp 0x21048
jmp 0x21045
jmp 0x21045
jmp 0x21045
jmp 0x21045
jmp 0x21045
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x3180
jmp 0x21048
jmp 0x21045
jmp 0x21045
jmp 0x21006
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x3170
jmp 0x20fe4
movq %rax, %rbx
leaq 0x430(%rsp), %rdi
callq 0x3180
jmp 0x20fe4
jmp 0x20fe1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x228(%rsp), %rdi
callq 0x3180
jmp 0x2109b
jmp 0x21045
jmp 0x21045
jmp 0x21057
movq %rax, %rbx
jmp 0x2109b
movq %rax, %rbx
leaq 0x228(%rsp), %rdi
callq 0x3290
jmp 0x21048
movq %rax, %rbx
leaq 0x6a0(%rsp), %rdi
jmp 0x2103c
jmp 0x21045
jmp 0x21045
movq %rax, %rbx
leaq 0x688(%rsp), %rdi
callq 0x995e
jmp 0x21048
jmp 0x21045
movq %rax, %rbx
leaq 0x108(%rsp), %rdi
callq 0x61d0
jmp 0x2105a
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x995e
leaq 0x90(%rsp), %rdi
callq 0x11260
leaq 0x140(%rsp), %rdi
callq 0x995e
leaq 0xf0(%rsp), %rdi
callq 0x995e
leaq 0x160(%rsp), %rdi
callq 0x995e
leaq 0x208(%rsp), %rdi
callq 0x3170
leaq 0x5b0(%rsp), %rdi
callq 0x995e
leaq 0x50(%rsp), %rdi
callq 0x11260
movq %rbx, %rdi
callq 0x35a0