// File: /workspace/github_cpp_makefile_star2_O1/nanjiangshu[P]calSOV/calSOV.cpp
// Function: main
int main(int argc, char** argv)/*{{{*/
{
    bool isNonOptionArg = false;

    if(argc < 2) 
    {
        PrintHelp(argv);
        return 0;
    }
    int i,j;
    char outfile[MAX_PATH+1] = "";
    char fileListFile[MAX_PATH+1] ="";
    const char control_option[] = ""; //options which control the program, and does not take parameters
    //bool isAll = false;
    //bool isQuiet = false;
    //bool isSingle = false;
    bool isOutputQ3 = true;
    int fileFormat = 1;
    char chkFstFolder[MAX_PATH+1] ="";
    
    set <string> ::iterator iss;
    set <string> fileList_set;

    char infile [MAX_PATH+1] = "";
    int linesize;
    int maxline = 300;
    Array1D <char> line_1darray(maxline+1);
    char *line = line_1darray.array1D;
    i = 1;
    while(i < argc)/*{{{*/
    {
        if(argv[i][0] == '-' && !isNonOptionArg) //options
        {
            isNonOptionArg = false;
            if(IsInCharSet(argv[i][1], control_option))//if argv[i][1] is in control_option, it might be used as -aqs
            {
                for(j = 1 ; j < int(strlen(argv[i])); j++)
                {
                    switch (argv[i][j])
                    {
                        default : fprintf(stderr,"Invalid option, non-control option '%c' can be used together with contorl-option\n", argv[i][j]); return -1;
                    }
                }
                i ++;
            }
            else if(strcmp(argv[i],"-h") == 0 ||strcmp(argv[i],"--help")==0 )
            {
                PrintHelp(argv); 
                return 0;
            }
            else if(strcmp(argv[i],"-H") == 0 )
            {
                PrintVerboseHelp();
                return 0;
            }
            else if( (strcmp(argv[i],"-o") == 0) || (strcmp(argv[i], "--out") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, outfile)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-l") == 0) || (strcmp(argv[i], "--list") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, fileListFile)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-chkfstdir") == 0) || (strcmp(argv[i], "--chkfstdir") == 0))  
            {
                if( ( i = option_parser_filename(argc, argv, i, chkFstFolder)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i],"-q3") == 0) || (strcmp(argv[i], "--isOutQ3") == 0))  
            {
                char tmpstr[MAX_PATH+1] ="";
                if( ( i = option_parser_filename(argc, argv, i, tmpstr)) == -1)
                    return -1;
                if (strncasecmp(tmpstr,"yes", 1) == 0)
                {
                    isOutputQ3 = true;
                }
                else
                {
                    isOutputQ3 = false;
                }
            }
            else if( (strcmp(argv[i],"-polypara") == 0) || (strcmp(argv[i], "--polypara") == 0))  
            {
                if (!IsNumeric(argv[i+1]) || !IsNumeric(argv[i+2]) || !IsNumeric(argv[i+3]) )
                {
                    fprintf(stderr,"Error! Option -polypara should be followed by three floating values\n");
                }
                else
                {
                    poly_a1 = atof(argv[i+1]);
                    poly_a2 = atof(argv[i+2]);
                    poly_a3 = atof(argv[i+3]);
                }
                i = i + 4;
            }
            else if( (strcmp(argv[i], "-f") == 0) || strcmp(argv[i], "--format") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, fileFormat, true, 0, 4)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-max") == 0) || strcmp(argv[i], "--max-length") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, maxSeqLength, true, 0, MAX_INT)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-statq3") == 0) )  
            {
                isStatQ3Conf = true;
                i ++;
            }
            else if( (strcmp(argv[i], "-proof") == 0) )  
            {
                isProofReading = true;
                i ++;
            }
            else if( (strcmp(argv[i], "-proofmethod") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, method_ProofReading, true, 0, 10)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-selconf") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, typeConfidence, true, 0, 1)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-binwidth") == 0) )  
            {
                if( ( i = option_parser_numeric(argc, argv, i, binWidth, true, 0.0, 100.0)) == -1)
                    return -1;
            }
            else if( (strcmp(argv[i], "-m") == 0) || strcmp(argv[i], "--method") == 0)  
            {
                if( ( i = option_parser_numeric(argc, argv, i, method_HSR, true, 0, 4)) == -1)
                    return -1;
            }
            else if (strcmp(argv[i], "--") == 0)//next item is non option argument
            {
                isNonOptionArg = true;
                i ++;
                continue;
            }
            else
            {
                fprintf(stderr,"Error! Invalid argument '%s'\n", argv[i]);
                return -1;
            }
        }
        else //non-option argument
        {
            fileList_set.insert(argv[i]);
            i ++;
        }
    }/*}}}*/
    if (isStatQ3Conf)
    {
        if (strcmp(chkFstFolder, "") == 0)
        {
            fprintf (stderr,"chkFstFolder not set, since -q3stat is enabled. Exit!\n");
            return -1;
        }
    }

    double halfBinWidth = binWidth/2;

    if (strcmp(fileListFile , "") != 0)
    {
        FILE *fpList=fopen(fileListFile, "r");
        checkfilestream(fpList, fileListFile,"r", false);
        if (fpList != NULL)
        {
            while((linesize=fgetline(fpList, line, maxline)) != EOF)
            {
                fileList_set.insert(line);
            }
            fclose(fpList);
        }
    }
    FILE *fpout = NULL;
    if(strcmp(outfile,"") == 0 || strcasecmp(outfile, "stdout") == 0)
    {
        fpout = stdout;
    }
    else
    {
        fpout = fopen(outfile, "w");
        checkfilestream(fpout, outfile,"w");
    }
    /*add code here*/

    /*============================= main procedure goes here ================ */


    if(fileList_set.size()> 0 )
    {
        /*print out the header annotation*/
        fprintf(fpout,"%-10s %8s %6s %6s %6s %7s %7s %6s %6s %6s ", "Item", "All(SOV)", "H(SOV)", "S(SOV)", "R(SOV)", "numAll", "numH", "numS", "numR", "seqLen");
        if(isOutputQ3)
        {
            fprintf(fpout,"%7s %6s %6s %6s %7s %6s %6s %6s", "All(Q3)", "H(Q3)", "S(Q3)", "R(Q3)", "numAll", "numH", "numS", "numR");
        }
        fprintf(fpout,"\n");
    }
    Array1D <char> aaSeq_1darray(maxSeqLength);
    Array1D <char> obsSec_1darray(maxSeqLength);
    Array1D <char> predSec_1darray(maxSeqLength);
    aaSeq_1darray.Init('-');
    obsSec_1darray.Init('-');
    predSec_1darray.Init('-');
    char *aaSeq = aaSeq_1darray.array1D;
    char *obsSec = obsSec_1darray.array1D;
    char *predSec = predSec_1darray.array1D;


    Array1D <double> q3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> sovHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numQ3CorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> numSOVCorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> numSOVHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumQ3CorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalQ3HSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalNumSOVCorrectHSR_1darray(NUM_HSR_STATE+1);
    Array1D <int> totalNumSOVHSR_1darray(NUM_HSR_STATE+1);
    Array1D <double> totalSOVHSR_1darray(NUM_HSR_STATE+1);

    q3HSR_1darray.Init(0);
    sovHSR_1darray.Init(0);
    numQ3CorrectHSR_1darray.Init(0);
    numQ3HSR_1darray.Init(0);
    numSOVCorrectHSR_1darray.Init(0);
    numSOVHSR_1darray.Init(0);
    totalNumQ3CorrectHSR_1darray.Init(0);
    totalNumQ3HSR_1darray.Init(0);
    totalQ3HSR_1darray.Init(0);
    totalNumSOVCorrectHSR_1darray.Init(0);
    totalNumSOVHSR_1darray.Init(0);
    totalSOVHSR_1darray.Init(0);


    double *q3HSR = q3HSR_1darray.array1D;
    double *sovHSR = sovHSR_1darray.array1D;

    int *numQ3CorrectHSR = numQ3CorrectHSR_1darray.array1D;
    int *numQ3HSR= numQ3HSR_1darray.array1D;   /*number of residues for each state when for analysis of Q3*/  
    double *numSOVCorrectHSR=numSOVCorrectHSR_1darray.array1D;
    int *numSOVHSR = numSOVHSR_1darray.array1D; /*number of residues for each state when for analysis of SOV*/

    int *totalNumQ3CorrectHSR = totalNumQ3CorrectHSR_1darray.array1D;
    int *totalNumQ3HSR = totalNumQ3HSR_1darray.array1D;
    double *totalQ3HSR = totalQ3HSR_1darray.array1D;

    double *totalNumSOVCorrectHSR = totalNumSOVCorrectHSR_1darray.array1D;
    int *totalNumSOVHSR = totalNumSOVHSR_1darray.array1D;
    double *totalSOVHSR = totalSOVHSR_1darray.array1D;

    /*variable for analysis of the q3 within each confidence bin*/
    Array1D <double> predConf_1darray(maxSeqLength);

    int numBin = 101;

    Array2D <int> statNumQ3CorrectHSR_2darray(numBin ,NUM_HSR_STATE+1);
    Array2D <int> statNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statQ3HSR_2darray(numBin,NUM_HSR_STATE+1);

    Array2D <int> statTotalNumQ3CorrectHSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <int> statTotalNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statTotalQ3HSR_2darray(numBin, NUM_HSR_STATE+1);

    Array2D <int> statAccumulateNumQ3CorrectHSR_2darray(numBin ,NUM_HSR_STATE+1);
    Array2D <int> statAccumulateNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statAccumulateQ3HSR_2darray(numBin,NUM_HSR_STATE+1);

    Array2D <int> statTotalAccumulateNumQ3CorrectHSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <int> statTotalAccumulateNumQ3HSR_2darray(numBin, NUM_HSR_STATE+1);
    Array2D <double> statTotalAccumulateQ3HSR_2darray(numBin, NUM_HSR_STATE+1);


    predConf_1darray.Init(0.0);

    statNumQ3CorrectHSR_2darray.Init(0);
    statNumQ3HSR_2darray.Init(0);
    statQ3HSR_2darray.Init(0.0);

    statTotalNumQ3CorrectHSR_2darray.Init(0);
    statTotalNumQ3HSR_2darray.Init(0);
    statTotalQ3HSR_2darray.Init(0);

    statAccumulateNumQ3CorrectHSR_2darray.Init(0);
    statAccumulateNumQ3HSR_2darray.Init(0);
    statAccumulateQ3HSR_2darray.Init(0.0);

    statTotalAccumulateNumQ3CorrectHSR_2darray.Init(0);
    statTotalAccumulateNumQ3HSR_2darray.Init(0);
    statTotalAccumulateQ3HSR_2darray.Init(0);

    double *predConf =predConf_1darray.array1D;

    int **statNumQ3CorrectHSR = statNumQ3CorrectHSR_2darray.array2D;
    int **statNumQ3HSR = statNumQ3HSR_2darray.array2D;
    double **statQ3HSR = statQ3HSR_2darray.array2D;

    int **statTotalNumQ3CorrectHSR = statTotalNumQ3CorrectHSR_2darray.array2D;
    int **statTotalNumQ3HSR = statTotalNumQ3HSR_2darray.array2D;
    double **statTotalQ3HSR = statTotalQ3HSR_2darray.array2D;

    int **statAccumulateNumQ3CorrectHSR = statAccumulateNumQ3CorrectHSR_2darray.array2D;
    int **statAccumulateNumQ3HSR = statAccumulateNumQ3HSR_2darray.array2D;
    double **statAccumulateQ3HSR = statAccumulateQ3HSR_2darray.array2D;

    int **statTotalAccumulateNumQ3CorrectHSR = statTotalAccumulateNumQ3CorrectHSR_2darray.array2D;
    int **statTotalAccumulateNumQ3HSR = statTotalAccumulateNumQ3HSR_2darray.array2D;
    double **statTotalAccumulateQ3HSR = statTotalAccumulateQ3HSR_2darray.array2D;


    int iBin = 0;
    int seqLength = 0;
    int totalLength = 0;     /*total number of residues for multiple files, even with those without structure definition*/

    char rtname [MAX_PATH+1] = "";
    char chkFstResFile [MAX_PATH+1] = "";

    for(iss = fileList_set.begin(); iss != fileList_set.end(); iss ++)
    {
        my_strcpy( infile, (*iss).c_str(), MAX_PATH-1);
        rootname(infile, rtname);
        seqLength = ReadInSecPredFile(infile, aaSeq, obsSec, predSec,predConf, typeConfidence, fileFormat);

        if (isProofReading)
        {
            ProofReading(predSec, seqLength, method_ProofReading);
        }
        /*multiply predConf by 100.0, to be percentages*/

        if (isStatQ3Conf)
        {
            sprintf(chkFstResFile, "%s/%s.txt", chkFstFolder, rtname);
            ReadConf(chkFstResFile, predConf, typeConfidence);
            for(i = 0; i < seqLength; i ++) { predConf[i] *= 100.0; }
        }

        CalSOV(obsSec, predSec, seqLength, numSOVCorrectHSR, numSOVHSR, sovHSR, NUM_HSR_STATE);
        fprintf(fpout,"%-10.10s %8.2f %6.2f %6.2f %6.2f %7d %7d %6d %6d %6d ", rtname,  sovHSR[3]*100.0,  sovHSR[0]*100.0, sovHSR[1]*100.0, sovHSR[2]*100.0, numSOVHSR[3],numSOVHSR[0], numSOVHSR[1],numSOVHSR[2], seqLength);
        /*print out the result*/
        if (isOutputQ3)
        {
            CalQ3(obsSec, predSec, seqLength, numQ3CorrectHSR, numQ3HSR, q3HSR, NUM_HSR_STATE);
            fprintf(fpout,"%7.2f %6.2f %6.2f %6.2f %7d %6d %6d %6d", q3HSR[3]*100.0,  q3HSR[0]*100.0,  q3HSR[1]*100.0, q3HSR[2]*100.0, numQ3HSR[3], numQ3HSR[0],numQ3HSR[1],numQ3HSR[2]);
        }
        fprintf(fpout,"\n");

        if (isStatQ3Conf) /*analyze Q3 at different confidence; 2009-08-02*/
        {
            CalQ3ConfBin(obsSec, predSec, predConf, seqLength, statNumQ3CorrectHSR, statNumQ3HSR, statQ3HSR, NUM_HSR_STATE, halfBinWidth);
            CalQ3ConfAccumulate(obsSec, predSec, predConf, seqLength, statAccumulateNumQ3CorrectHSR, statAccumulateNumQ3HSR, statAccumulateQ3HSR, NUM_HSR_STATE, halfBinWidth);
            for (i = 0; i< NUM_HSR_STATE+1; i ++)
            {
                for (iBin = 0; iBin <= 100; iBin ++)
                {
                    statTotalNumQ3CorrectHSR[iBin][i] += statNumQ3CorrectHSR[iBin][i];
                    statTotalNumQ3HSR[iBin][i] += statNumQ3HSR[iBin][i];

                    statTotalAccumulateNumQ3CorrectHSR[iBin][i] += statAccumulateNumQ3CorrectHSR[iBin][i];
                    statTotalAccumulateNumQ3HSR[iBin][i] += statAccumulateNumQ3HSR[iBin][i];
                }
            }

        }


        for (i = 0; i< NUM_HSR_STATE+1; i++)
        {
            totalNumSOVCorrectHSR[i] += numSOVCorrectHSR[i];
            totalNumSOVHSR[i] += numSOVHSR[i];

            totalNumQ3CorrectHSR[i] += numQ3CorrectHSR[i];
            totalNumQ3HSR[i] += numQ3HSR[i];

        }
        totalLength += seqLength;
        
    }
    /*output the summary results*/
    for (i = 0; i< NUM_HSR_STATE+1; i++)
    {
        totalSOVHSR[i] = totalNumSOVCorrectHSR[i] / double (totalNumSOVHSR[i]+1e-6);
        totalQ3HSR[i] = totalNumQ3CorrectHSR[i] / double (totalNumQ3HSR[i]+1e-6);
    }
    if (isStatQ3Conf)
    {
        for (i = 0; i< NUM_HSR_STATE+1; i++)
        {
            for (iBin = 0; iBin <= 100; iBin ++)
            {
                statTotalQ3HSR[iBin][i] = statTotalNumQ3CorrectHSR[iBin][i] / double (statTotalNumQ3HSR[iBin][i]+1e-6);
                statTotalAccumulateQ3HSR[iBin][i] = statTotalAccumulateNumQ3CorrectHSR[iBin][i] / double (statTotalAccumulateNumQ3HSR[iBin][i]+1e-6);
            }
        }
        /*print out*/
        fprintf(stdout,"# BinWidth = %f\n", binWidth);
        fprintf(stdout,"#%28s    %20s\n", "non-accumulate" , "accumulate");
        fprintf(stdout,"#%-7s %6s %7s %7s   %8s %7s %7s\n", "Conf" , "Q3", "numRes", "%numRes", "Q3", "numRes", "%numRes");

        double percentNumResBin =0.0;
        double percentNumResAccumulate = 0.0;
        for(iBin = 0; iBin <= 100; iBin ++)
        {
            percentNumResBin = statTotalNumQ3HSR[iBin][3]/(statTotalAccumulateNumQ3HSR[0][3]+1e-6)*100.0;
            percentNumResAccumulate = statTotalAccumulateNumQ3HSR[iBin][3]/(statTotalAccumulateNumQ3HSR[0][3]+1e-6)*100.0;
            
            fprintf(stdout,"%-8d %6.2f %7d %6.2f   %8.2f %7d %6.2f\n", iBin, statTotalQ3HSR[iBin][3]*100.0, statTotalNumQ3HSR[iBin][3],percentNumResBin,  statTotalAccumulateQ3HSR[iBin][3]*100.0, statTotalAccumulateNumQ3HSR[iBin][3], percentNumResAccumulate);
        }

    }

    fprintf(fpout,"%-10s %8.2f %6.2f %6.2f %6.2f %7d %7d %6d %6d %6d ", "Sum",  totalSOVHSR[3]*100.0,  totalSOVHSR[0]*100.0, totalSOVHSR[1]*100.0, totalSOVHSR[2]*100.0, totalNumSOVHSR[3],totalNumSOVHSR[0], totalNumSOVHSR[1],totalNumSOVHSR[2], totalLength);
    if (isOutputQ3)
    {
        fprintf(fpout,"%7.2f %6.2f %6.2f %6.2f %7d %6d %6d %6d", totalQ3HSR[3]*100.0,  totalQ3HSR[0]*100.0,  totalQ3HSR[1]*100.0, totalQ3HSR[2]*100.0, totalNumQ3HSR[3], totalNumQ3HSR[0],totalNumQ3HSR[1],totalNumQ3HSR[2]);
    }
    fprintf(fpout,"\n");

    /*============================= main procedure ends here ================ */



    if(fpout != NULL && fpout != stdout) fclose(fpout);

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xdd8, %rsp            # imm = 0xDD8
movq %rsi, %r14
movl %edi, 0x10(%rsp)
cmpl $0x1, %edi
jg 0x438b
movq %r14, %rdi
callq 0x25dc
xorl %ebx, %ebx
jmp 0x5d52
leaq 0x3e0(%rsp), %rdi
xorl %ebx, %ebx
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x9e0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movb $0x0, 0x7(%rsp)
movl $0x1, 0x84(%rsp)
leaq 0xbe0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x1b8(%rsp), %rax
movl $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x20(%rax)
leaq 0x7e0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movl $0x12d, %edi            # imm = 0x12D
callq 0x2030
movq %rax, 0x8(%rsp)
leaq 0x7(%rsp), %rax
movb (%rax), %bpl
movl 0x10(%rsp), %eax
movq %rax, 0x20(%rsp)
movb $0x1, 0x6(%rsp)
movl $0x1, %r13d
xorl %ebx, %ebx
movslq %r13d, %r13
movq (%r14,%r13,8), %r12
cmpb $0x2d, (%r12)
jne 0x46f9
testb $0x1, %bl
jne 0x46f9
movsbl 0x1(%r12), %r15d
leaq 0x7(%rsp), %rdi
callq 0x20e0
testl %eax, %eax
setg %cl
jle 0x449d
cmpb %r15b, %bpl
je 0x4765
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq -0x1(%rax), %rcx
xorl %edx, %edx
movq %rdx, %rsi
incq %rdx
cmpq %rsi, %rcx
je 0x4497
cmpb %r15b, %bpl
jne 0x4487
cmpq %rax, %rdx
setb %cl
testb %cl, %cl
jne 0x4765
movq %r12, %rdi
leaq 0x35a5(%rip), %rsi      # 0x7a54
callq 0x2230
testl %eax, %eax
je 0x49e6
movq %r12, %rdi
leaq 0x3591(%rip), %rsi      # 0x7a57
callq 0x2230
testl %eax, %eax
je 0x49e6
movq %r12, %rdi
leaq 0x3581(%rip), %rsi      # 0x7a5e
callq 0x2230
testl %eax, %eax
je 0x5d39
movq %r12, %rdi
leaq 0x356d(%rip), %rsi      # 0x7a61
callq 0x2230
testl %eax, %eax
je 0x4751
movq %r12, %rdi
leaq 0x3559(%rip), %rsi      # 0x7a64
callq 0x2230
testl %eax, %eax
je 0x4751
movq %r12, %rdi
leaq 0x3548(%rip), %rsi      # 0x7a6a
callq 0x2230
testl %eax, %eax
je 0x477b
movq %r12, %rdi
leaq 0x3534(%rip), %rsi      # 0x7a6d
callq 0x2230
testl %eax, %eax
je 0x477b
movq %r12, %rdi
leaq 0x3525(%rip), %rsi      # 0x7a75
callq 0x2230
testl %eax, %eax
je 0x478f
movq %r12, %rdi
leaq 0x350d(%rip), %rsi      # 0x7a74
callq 0x2230
testl %eax, %eax
je 0x478f
movq %r12, %rdi
leaq 0x3502(%rip), %rsi      # 0x7a80
callq 0x2230
testl %eax, %eax
je 0x47b7
movq %r12, %rdi
leaq 0x34ef(%rip), %rsi      # 0x7a84
callq 0x2230
testl %eax, %eax
je 0x47b7
movq %r12, %rdi
leaq 0x34e7(%rip), %rsi      # 0x7a93
callq 0x2230
testl %eax, %eax
je 0x480c
movq %r12, %rdi
leaq 0x34cf(%rip), %rsi      # 0x7a92
callq 0x2230
testl %eax, %eax
je 0x480c
movq %r12, %rdi
leaq 0x3508(%rip), %rsi      # 0x7ae2
callq 0x2230
testl %eax, %eax
je 0x4884
movq %r12, %rdi
leaq 0x34f4(%rip), %rsi      # 0x7ae5
callq 0x2230
testl %eax, %eax
je 0x4884
movq %r12, %rdi
leaq 0x34e6(%rip), %rsi      # 0x7aee
callq 0x2230
testl %eax, %eax
je 0x48b3
movq %r12, %rdi
leaq 0x34d4(%rip), %rsi      # 0x7af3
callq 0x2230
testl %eax, %eax
je 0x48b3
movq %r12, %rdi
leaq 0x34ca(%rip), %rsi      # 0x7b00
callq 0x2230
testl %eax, %eax
je 0x4912
movq %r12, %rdi
leaq 0x34bb(%rip), %rsi      # 0x7b08
callq 0x2230
testl %eax, %eax
je 0x491b
movq %r12, %rdi
leaq 0x34ab(%rip), %rsi      # 0x7b0f
callq 0x2230
testl %eax, %eax
je 0x4943
movq %r12, %rdi
leaq 0x34a1(%rip), %rsi      # 0x7b1c
callq 0x2230
testl %eax, %eax
je 0x496e
movq %r12, %rdi
leaq 0x3493(%rip), %rsi      # 0x7b25
callq 0x2230
testl %eax, %eax
je 0x4999
movq %r12, %rdi
leaq 0x3486(%rip), %rsi      # 0x7b2f
callq 0x2230
testl %eax, %eax
je 0x48e4
movq %r12, %rdi
leaq 0x3472(%rip), %rsi      # 0x7b32
callq 0x2230
testl %eax, %eax
je 0x48e4
movq %r12, %rdi
leaq 0x2fbc(%rip), %rsi      # 0x7693
callq 0x2230
testl %eax, %eax
jne 0x5da5
incq %r13
movb $0x1, %bl
cmpq 0x20(%rsp), %r13
jl 0x4444
jmp 0x49f3
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
leaq 0x5e0(%rsp), %rdx
callq 0x63ca
leaq 0x1b0(%rsp), %rdi
movq %r15, %rsi
callq 0x66e0
movq 0x1e0(%rsp), %rdi
leaq 0x1f0(%rsp), %rax
cmpq %rax, %rdi
je 0x4749
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x2180
incl %r13d
jmp 0x49cf
movl 0x10(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x3e0(%rsp), %rcx
jmp 0x47a1
movq %r12, %rdi
callq 0x20e0
cmpl $0x1, %eax
jle 0x4922
jmp 0x5dca
movl 0x10(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x9e0(%rsp), %rcx
jmp 0x47a1
movl 0x10(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0xbe0(%rsp), %rcx
callq 0x2954
cmpl $-0x1, %eax
je 0x5dc0
movl %eax, %r13d
jmp 0x49cd
movl $0x1f5, %edx            # imm = 0x1F5
leaq 0x1e0(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2100
movl 0x10(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x2954
movl %eax, %r13d
cmpl $-0x1, %eax
je 0x492a
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x3293(%rip), %rsi      # 0x7a8e
callq 0x2210
testl %eax, %eax
sete 0x6(%rsp)
jmp 0x4934
movq 0x8(%r14,%r13,8), %r15
movq %r15, %rdi
callq 0x2a40
testb %al, %al
je 0x49dc
movq 0x10(%r14,%r13,8), %r12
movq %r12, %rdi
callq 0x2a40
testb %al, %al
je 0x49dc
movq 0x18(%r14,%r13,8), %rbx
movq %rbx, %rdi
callq 0x2a40
testb %al, %al
je 0x49dc
movq %r15, %rdi
callq 0x21f0
movsd %xmm0, 0x6925(%rip)     # 0xb180
movq %r12, %rdi
callq 0x21f0
movsd %xmm0, 0x691d(%rip)     # 0xb188
movq %rbx, %rdi
callq 0x21f0
movsd %xmm0, 0x6915(%rip)     # 0xb190
addl $0x4, %r13d
jmp 0x49cd
subq $0x8, %rsp
movl 0x18(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x8c(%rsp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x4
callq 0x60b2
addq $0x10, %rsp
jmp 0x49c1
subq $0x8, %rsp
movl 0x18(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x68b0(%rip), %rcx      # 0xb178
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x7fffffff             # imm = 0x7FFFFFFF
callq 0x60b2
addq $0x10, %rsp
jmp 0x49c1
subq $0x8, %rsp
movl 0x18(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x6867(%rip), %rcx      # 0xb160
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x4
callq 0x60b2
addq $0x10, %rsp
jmp 0x49c1
movb $0x1, 0x688c(%rip)      # 0xb1a5
jmp 0x4922
movb $0x1, 0x688a(%rip)      # 0xb1ac
incl %r13d
jmp 0x49cd
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x18(%rsp)
cmpl $-0x1, %r13d
jne 0x49cd
jmp 0x5d6d
subq $0x8, %rsp
movl 0x18(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x6858(%rip), %rcx      # 0xb1b0
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0xa
callq 0x60b2
addq $0x10, %rsp
jmp 0x49c1
subq $0x8, %rsp
movl 0x18(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x6825(%rip), %rcx      # 0xb1a8
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x1
callq 0x60b2
addq $0x10, %rsp
jmp 0x49c1
xorpd %xmm0, %xmm0
movl 0x10(%rsp), %edi
movq %r14, %rsi
movl %r13d, %edx
leaq 0x67c2(%rip), %rcx      # 0xb170
movl $0x1, %r8d
movsd 0x2654(%rip), %xmm1     # 0x7010
callq 0x6240
movl %eax, %r13d
cmpl $-0x1, %eax
je 0x5dc0
xorl %ebx, %ebx
cmpl 0x10(%rsp), %r13d
jl 0x4441
jmp 0x49f3
callq 0x247d
jmp 0x487b
movq %r14, %rdi
callq 0x25dc
jmp 0x5d39
cmpb $0x1, 0x67ab(%rip)      # 0xb1a5
jne 0x4a0a
cmpb $0x0, 0xbe0(%rsp)
je 0x5d66
movsd 0x675e(%rip), %xmm0     # 0xb170
movsd %xmm0, 0x168(%rsp)
cmpb $0x0, 0x9e0(%rsp)
movq 0x8(%rsp), %r13
je 0x4ad6
leaq 0x3049(%rip), %rsi      # 0x7a7e
leaq 0x9e0(%rsp), %rdi
callq 0x21e0
testq %rax, %rax
je 0x5d79
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x2c50
cmpl $-0x1, %eax
leaq 0x1f0(%rsp), %rbp
je 0x4ace
leaq 0x1e0(%rsp), %r14
leaq 0x5e0(%rsp), %r15
leaq 0x1b0(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x63ca
movq %r12, %rdi
movq %r14, %rsi
callq 0x66e0
movq 0x1e0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ab9
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
movq %r13, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x2c50
cmpl $-0x1, %eax
jne 0x4a83
movq %rbx, %rdi
callq 0x2160
cmpb $0x0, 0x3e0(%rsp)
je 0x4b3d
leaq 0x30a9(%rip), %rsi      # 0x7b90
leaq 0x3e0(%rsp), %rdi
callq 0x21a0
testl %eax, %eax
je 0x4b3d
leaq 0x3098(%rip), %rsi      # 0x7b97
leaq 0x3e0(%rsp), %rdi
callq 0x21e0
movq %rax, %rbx
testq %rax, %rax
jne 0x4b47
movq 0x64bd(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x2c92(%rip), %rsi      # 0x77b7
leaq 0x306b(%rip), %rcx      # 0x7b97
leaq 0x3e0(%rsp), %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4b47
movq 0x647c(%rip), %rax      # 0xafc0
movq (%rax), %rbx
movq %rbx, 0x70(%rsp)
cmpq $0x0, 0x1d8(%rsp)
je 0x4c12
leaq 0x309b(%rip), %r10      # 0x7bfd
leaq 0x308f(%rip), %r12      # 0x7bf8
leaq 0x3083(%rip), %r15      # 0x7bf3
leaq 0x3077(%rip), %r14      # 0x7bee
leaq 0x3069(%rip), %rbx      # 0x7be7
leaq 0x305b(%rip), %r11      # 0x7be0
leaq 0x300d(%rip), %rsi      # 0x7b99
leaq 0x3031(%rip), %rdx      # 0x7bc4
leaq 0x302f(%rip), %rcx      # 0x7bc9
leaq 0x3031(%rip), %r8       # 0x7bd2
leaq 0x3031(%rip), %r9       # 0x7bd9
movq 0x70(%rsp), %r13
movq %r13, %rdi
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
callq 0x2240
addq $0x30, %rsp
testb $0x1, 0x6(%rsp)
je 0x4c05
leaq 0x3030(%rip), %rsi      # 0x7c04
leaq 0x3049(%rip), %rdx      # 0x7c24
leaq 0x304a(%rip), %rcx      # 0x7c2c
leaq 0x3049(%rip), %r8       # 0x7c32
leaq 0x3048(%rip), %r9       # 0x7c38
movq %r13, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
callq 0x2240
addq $0x20, %rsp
movl $0xa, %edi
movq %r13, %rsi
callq 0x2200
movl 0x6560(%rip), %ebp      # 0xb178
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x110(%rsp)
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x28(%rsp)
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x18(%rsp)
testq %rbp, %rbp
je 0x4c80
movq 0x110(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movq 0x28(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movq 0x18(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movl $0x20, %edi
callq 0x2030
movq %rax, 0x50(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x68(%rsp)
movl $0x10, %edi
callq 0x2030
movq %rax, %rbx
movl $0x10, %edi
movq %rax, 0x10(%rsp)
callq 0x2030
movq %rax, %r14
movl $0x20, %edi
movq %rax, 0x60(%rsp)
callq 0x2030
movq %rax, %r15
movl $0x10, %edi
movq %rax, 0x170(%rsp)
callq 0x2030
movq %rax, %r12
movl $0x10, %edi
movq %rax, 0x78(%rsp)
callq 0x2030
movq %rax, %r13
movl $0x10, %edi
movq %rax, 0x118(%rsp)
callq 0x2030
movq %rax, 0x38(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x48(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x58(%rsp)
movl $0x10, %edi
callq 0x2030
movq %rax, 0x40(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, %rcx
xorpd %xmm0, %xmm0
movq 0x50(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x68(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movupd %xmm0, (%rbx)
movupd %xmm0, (%r14)
movupd %xmm0, 0x10(%r15)
movupd %xmm0, (%r15)
movupd %xmm0, (%r12)
movupd %xmm0, (%r13)
movq 0x38(%rsp), %rax
movupd %xmm0, (%rax)
movq 0x48(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x58(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x40(%rsp), %rax
movupd %xmm0, (%rax)
movupd %xmm0, 0x10(%rcx)
movq %rcx, 0x108(%rsp)
movupd %xmm0, (%rcx)
leaq (,%rbp,8), %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r15
movabsq $0x400000065, %rbx      # imm = 0x400000065
movq %rbx, 0x100(%rsp)
movl $0x328, %edi            # imm = 0x328
movq %rax, 0x30(%rsp)
callq 0x2030
movsd 0x168(%rsp), %xmm0
mulsd 0x2215(%rip), %xmm0     # 0x7020
movsd %xmm0, 0x168(%rsp)
movq %rax, 0xf8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xf8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4e1f
movq %rbx, 0xf0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xe8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xe8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4e5b
movq %rbx, 0x160(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x158(%rsp)
xorl %r14d, %r14d
movl $0x20, %edi
callq 0x2030
movq 0x158(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4e97
movq %rbx, 0xe0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xd8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xd8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4ed3
movq %rbx, 0xd0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xc8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xc8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4f0f
movq %rbx, 0x150(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x148(%rsp)
xorl %r14d, %r14d
movl $0x20, %edi
callq 0x2030
movq 0x148(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4f4b
movq %rbx, 0xc0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xb8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xb8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4f87
movq %rbx, 0xb0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xa8(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xa8(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4fc3
movq %rbx, 0x140(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x138(%rsp)
xorl %r14d, %r14d
movl $0x20, %edi
callq 0x2030
movq 0x138(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4fff
movq %rbx, 0xa0(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x98(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0x98(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x503b
movq %rbx, 0x90(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x88(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0x88(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x5077
movq %rbx, 0x130(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x128(%rsp)
xorl %ebx, %ebx
movl $0x20, %edi
callq 0x2030
movq 0x128(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x65, %rbx
jne 0x50b2
testl %ebp, %ebp
je 0x50e2
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
cmpl $0x0, 0x100(%rsp)
je 0x512b
movq 0xf8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0x104(%rsp)
je 0x511c
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0x104(%rsp), %edi
cmpq %rdi, %rsi
jb 0x5106
incq %rcx
movl 0x100(%rsp), %edx
cmpq %rdx, %rcx
jb 0x50f6
cmpl $0x0, 0xf0(%rsp)
je 0x5174
movq 0xe8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xf4(%rsp)
je 0x5165
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xf4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x514f
incq %rcx
movl 0xf0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x513f
movl 0x160(%rsp), %ebx
testq %rbx, %rbx
je 0x51b5
movl 0x164(%rsp), %r15d
movq 0x158(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x51ad
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x519a
cmpl $0x0, 0xe0(%rsp)
je 0x51fe
movq 0xd8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xe4(%rsp)
je 0x51ef
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xe4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x51d9
incq %rcx
movl 0xe0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x51c9
cmpl $0x0, 0xd0(%rsp)
je 0x5247
movq 0xc8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xd4(%rsp)
je 0x5238
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xd4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x5222
incq %rcx
movl 0xd0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x5212
movl 0x150(%rsp), %ebx
testq %rbx, %rbx
je 0x5288
movl 0x154(%rsp), %r15d
movq 0x148(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x5280
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x526d
cmpl $0x0, 0xc0(%rsp)
je 0x52d1
movq 0xb8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xc4(%rsp)
je 0x52c2
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xc4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x52ac
incq %rcx
movl 0xc0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x529c
cmpl $0x0, 0xb0(%rsp)
je 0x531a
movq 0xa8(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xb4(%rsp)
je 0x530b
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xb4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x52f5
incq %rcx
movl 0xb0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x52e5
movl 0x140(%rsp), %ebx
testq %rbx, %rbx
je 0x535b
movl 0x144(%rsp), %r15d
movq 0x138(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x5353
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x5340
cmpl $0x0, 0xa0(%rsp)
je 0x53a4
movq 0x98(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0xa4(%rsp)
je 0x5395
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0xa4(%rsp), %edi
cmpq %rdi, %rsi
jb 0x537f
incq %rcx
movl 0xa0(%rsp), %edx
cmpq %rdx, %rcx
jb 0x536f
cmpl $0x0, 0x90(%rsp)
je 0x53ed
movq 0x88(%rsp), %rax
xorl %ecx, %ecx
cmpl $0x0, 0x94(%rsp)
je 0x53de
movq (%rax,%rcx,8), %rdx
xorl %esi, %esi
movl $0x0, (%rdx,%rsi,4)
incq %rsi
movl 0x94(%rsp), %edi
cmpq %rdi, %rsi
jb 0x53c8
incq %rcx
movl 0x90(%rsp), %edx
cmpq %rdx, %rcx
jb 0x53b8
movl 0x130(%rsp), %ebx
testq %rbx, %rbx
je 0x542e
movl 0x134(%rsp), %r15d
movq 0x128(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x5426
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x5413
movq 0xf8(%rsp), %r14
movq 0xe8(%rsp), %r12
movq 0x158(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0xd8(%rsp), %r15
movq 0xc8(%rsp), %rax
movq %rax, 0x180(%rsp)
movq 0x148(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0xb8(%rsp), %rbp
movq 0xa8(%rsp), %r13
movq 0x138(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x98(%rsp), %rbx
movq 0x88(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0x188(%rsp)
leaq 0x1e0(%rsp), %rdi
movq $0x0, 0x120(%rsp)
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x5e0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movq 0x1c8(%rsp), %rcx
leaq 0x1b8(%rsp), %rax
cmpq %rax, %rcx
je 0x58cc
movq $0x0, 0x120(%rsp)
movq %rcx, 0x1a8(%rsp)
movq 0x20(%rcx), %rsi
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x7e0(%rsp), %rdi
callq 0x2130
movb $0x0, 0x9d3(%rsp)
leaq 0x7e0(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x28d7
movl 0x5c4a(%rip), %r9d      # 0xb1a8
movl 0x84(%rsp), %eax
subq $0x8, %rsp
leaq 0x7e8(%rsp), %rdi
movq 0x118(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %r8
pushq %rax
callq 0x2e32
addq $0x10, %rsp
cmpb $0x1, 0x5c13(%rip)      # 0xb1ac
movq %rax, 0x20(%rsp)
jne 0x55b7
movl 0x5c0a(%rip), %edx      # 0xb1b0
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x3392
movq 0x20(%rsp), %rax
cmpb $0x1, 0x5be7(%rip)      # 0xb1a5
jne 0x562e
leaq 0x5e0(%rsp), %rdi
leaq 0x266f(%rip), %rsi      # 0x7c3e
leaq 0xbe0(%rsp), %rdx
leaq 0x1e0(%rsp), %rcx
xorl %eax, %eax
callq 0x2090
movl 0x5bbc(%rip), %edx      # 0xb1a8
leaq 0x5e0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3595
movq 0x20(%rsp), %rax
testl %eax, %eax
movsd 0x1a03(%rip), %xmm1     # 0x7010
movq 0x30(%rsp), %rdx
jle 0x562e
movl %eax, %esi
xorl %ecx, %ecx
movsd (%rdx,%rcx,8), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
cmpq %rcx, %rsi
jne 0x5618
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, %edx
movq 0x80(%rsp), %r8
movq 0x70(%rsp), %r9
pushq $0x3
callq 0x37c1
movq 0x30(%rsp), %r11
addq $0x10, %rsp
movq 0x68(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x19a3(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm4, %xmm2
movsd 0x10(%rax), %xmm3
mulsd %xmm4, %xmm3
movq 0x78(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
movq 0x70(%rsp), %rdi
leaq 0x259e(%rip), %rsi      # 0x7c48
leaq 0x1e0(%rsp), %rdx
movb $0x4, %al
pushq %r11
pushq %r10
callq 0x2240
addq $0x10, %rsp
testb $0x1, 0x6(%rsp)
je 0x574e
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x68(%rsp), %r8
movq 0x58(%rsp), %r9
pushq $0x3
callq 0x3f3c
addq $0x10, %rsp
movq 0x50(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x1905(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm4, %xmm2
movsd 0x10(%rax), %xmm3
mulsd %xmm4, %xmm3
movq 0x60(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq 0x70(%rsp), %rdi
leaq 0x2537(%rip), %rsi      # 0x7c7e
movb $0x4, %al
callq 0x2240
movl $0xa, %edi
movq 0x70(%rsp), %rsi
callq 0x2200
cmpb $0x1, 0x5a41(%rip)      # 0xb1a5
jne 0x5837
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %r14, %r8
movq %r12, %r9
movsd 0x168(%rsp), %xmm0
movl $0x3, %eax
pushq %rax
pushq 0x1a8(%rsp)
callq 0x4017
addq $0x10, %rsp
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rbp, %r8
movq %r13, %r9
movl $0x3, %eax
pushq %rax
pushq 0x1a0(%rsp)
callq 0x41e2
movq 0x188(%rsp), %r8
movq 0x190(%rsp), %rdi
addq $0x10, %rsp
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r14,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%r15,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%r12,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%rdi,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%rbp,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%rbx,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%r13,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%r8,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
addq $0x8, %rcx
cmpq $0x328, %rcx            # imm = 0x328
jne 0x57e7
incq %rax
cmpq $0x4, %rax
jne 0x57e5
xorl %eax, %eax
movq 0x60(%rsp), %rsi
movq 0x170(%rsp), %rdi
movq 0x78(%rsp), %r8
movq 0x118(%rsp), %r9
movq 0x38(%rsp), %r10
movq 0x58(%rsp), %r11
movq 0x40(%rsp), %rdx
movsd (%rdi,%rax,2), %xmm0
addsd (%r11,%rax,2), %xmm0
movl (%r8,%rax), %ecx
addl %ecx, (%rdx,%rax)
movq 0x10(%rsp), %rcx
movl (%rcx,%rax), %ecx
addl %ecx, (%r9,%rax)
movl (%rsi,%rax), %ecx
addl %ecx, (%r10,%rax)
movsd %xmm0, (%r11,%rax,2)
addq $0x4, %rax
cmpq $0x10, %rax
jne 0x5862
movq 0x120(%rsp), %rax
addl 0x20(%rsp), %eax
movq %rax, 0x120(%rsp)
movq 0x1a8(%rsp), %rdi
callq 0x21d0
movq %rax, %rcx
leaq 0x1b8(%rsp), %rax
cmpq %rax, %rcx
jne 0x5517
xorl %eax, %eax
movsd 0x1732(%rip), %xmm2     # 0x7008
movq 0x118(%rsp), %r9
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq 0x58(%rsp), %rsi
movq 0x40(%rsp), %rdi
movq 0x108(%rsp), %r8
movsd (%rsi,%rax,2), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%rdi,%rax), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl (%r9,%rax), %xmm1
movsd %xmm0, (%r8,%rax,2)
xorps %xmm0, %xmm0
cvtsi2sdl (%rcx,%rax), %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rdx,%rax,2)
addq $0x4, %rax
cmpq $0x10, %rax
jne 0x58fa
cmpb $0x1, 0x5861(%rip)      # 0xb1a5
movq 0x180(%rsp), %rsi
movq 0x190(%rsp), %r13
movq 0x178(%rsp), %r8
movq 0x188(%rsp), %rbp
jne 0x5af9
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r15,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq (%rsi,%rcx), %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%r13,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
movq (%rbx,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq (%r8,%rcx), %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%rbp,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
addq $0x8, %rcx
cmpq $0x328, %rcx            # imm = 0x328
jne 0x596e
incq %rax
cmpq $0x4, %rax
jne 0x596c
movq 0x55e1(%rip), %r12      # 0xafc0
movq %rsi, %r15
movq (%r12), %rdi
movsd 0x5782(%rip), %xmm0     # 0xb170
leaq 0x22b1(%rip), %rsi      # 0x7ca6
movb $0x1, %al
movq %r8, %rbx
callq 0x2240
movq (%r12), %rdi
leaq 0x22ad(%rip), %rsi      # 0x7cb7
leaq 0x22b5(%rip), %rdx      # 0x7cc6
leaq 0x22b2(%rip), %rcx      # 0x7cca
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2240
movq (%r12), %rdi
subq $0x8, %rsp
leaq 0x22ca(%rip), %r9       # 0x7cfb
leaq 0x22c4(%rip), %r8       # 0x7cfc
leaq 0x204c(%rip), %rcx      # 0x7a8b
leaq 0x228f(%rip), %rsi      # 0x7cd5
leaq 0x22a9(%rip), %rdx      # 0x7cf6
xorl %eax, %eax
pushq %r9
pushq %r8
pushq %rcx
callq 0x2240
movsd 0x15a7(%rip), %xmm2     # 0x7008
addq $0x20, %rsp
leaq 0x2297(%rip), %r12      # 0x7d03
movq (%r15,%r14,8), %rax
movl 0xc(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
movq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rax), %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x157b(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm1
movq (%rbx,%r14,8), %rax
movl 0xc(%rax), %r8d
xorps %xmm3, %xmm3
cvtsi2sd %r8d, %xmm3
divsd %xmm0, %xmm3
mulsd %xmm4, %xmm3
movq 0x5508(%rip), %rax      # 0xafc0
movq (%rax), %rdi
movq (%r13,%r14,8), %rax
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movq (%rbp,%r14,8), %rax
movsd 0x18(%rax), %xmm2
mulsd %xmm4, %xmm2
movq %r12, %rsi
movl %r14d, %edx
movb $0x4, %al
callq 0x2240
movsd 0x151c(%rip), %xmm2     # 0x7008
incq %r14
cmpq $0x65, %r14
jne 0x5a6c
movq 0x108(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x1502(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm0
movsd (%rax), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm4, %xmm2
movsd 0x10(%rax), %xmm3
mulsd %xmm4, %xmm3
movq 0x40(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
leaq 0x21e5(%rip), %rsi      # 0x7d2b
leaq 0x2211(%rip), %rdx      # 0x7d5e
movq 0x70(%rsp), %rbx
movq %rbx, %rdi
movb $0x4, %al
pushq 0x120(%rsp)
pushq %r10
callq 0x2240
addq $0x10, %rsp
testb $0x1, 0x6(%rsp)
je 0x5bbf
movq 0x48(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x148e(%rip), %xmm3     # 0x7010
mulsd %xmm3, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm3, %xmm2
mulsd 0x10(%rax), %xmm3
movq 0x38(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
leaq 0x20c9(%rip), %rsi      # 0x7c7e
movq %rbx, %rdi
movb $0x4, %al
callq 0x2240
movl $0xa, %edi
movq %rbx, %rsi
callq 0x2200
testq %rbx, %rbx
movq 0x10(%rsp), %r13
movq 0x60(%rsp), %r14
movq 0x170(%rsp), %r15
movq 0x78(%rsp), %r12
je 0x5bfc
movq 0x53d1(%rip), %rax      # 0xafc0
cmpq (%rax), %rbx
je 0x5bfc
movq %rbx, %rdi
callq 0x2160
leaq 0x128(%rsp), %rdi
callq 0x6408
leaq 0x88(%rsp), %rdi
callq 0x6450
leaq 0x98(%rsp), %rdi
callq 0x6450
leaq 0x138(%rsp), %rdi
callq 0x6408
leaq 0xa8(%rsp), %rdi
callq 0x6450
leaq 0xb8(%rsp), %rdi
callq 0x6450
leaq 0x148(%rsp), %rdi
callq 0x6408
leaq 0xc8(%rsp), %rdi
callq 0x6450
leaq 0xd8(%rsp), %rdi
callq 0x6450
leaq 0x158(%rsp), %rdi
callq 0x6408
leaq 0xe8(%rsp), %rdi
callq 0x6450
leaq 0xf8(%rsp), %rdi
callq 0x6450
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x108(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x58(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x38(%rsp), %rdi
callq 0x2220
movq 0x118(%rsp), %rdi
callq 0x2220
movq %r12, %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq %r13, %rdi
callq 0x2220
movq 0x68(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2220
movq 0x110(%rsp), %rdi
callq 0x2220
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
callq 0x2220
leaq 0x1b0(%rsp), %rdi
callq 0x64fa
movl %ebx, %eax
addq $0xdd8, %rsp            # imm = 0xDD8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x249f
jmp 0x5dc0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rbx
jmp 0x5d40
movq 0x5258(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x1a2d(%rip), %rsi      # 0x77b7
leaq 0x1ced(%rip), %rcx      # 0x7a7e
leaq 0x9e0(%rsp), %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4ad6
movq 0x522c(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x1d85(%rip), %rsi      # 0x7b3b
movq %r12, %rdx
xorl %eax, %eax
callq 0x2240
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5d3b
movq 0x5207(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x1c27(%rip), %rsi      # 0x7a02
movl %r15d, %edx
xorl %eax, %eax
callq 0x2240
jmp 0x5dc0
jmp 0x5ef7
jmp 0x5efc
jmp 0x5f01
jmp 0x5f06
jmp 0x5f0b
jmp 0x5f10
jmp 0x5f18
jmp 0x5f20
jmp 0x5f28
jmp 0x5f30
jmp 0x5f38
jmp 0x5f40
movq %rax, %rbx
jmp 0x5ff1
movq %rax, %rbx
jmp 0x5ffe
movq %rax, %rbx
jmp 0x6008
movq %rax, %rbx
jmp 0x6012
movq %rax, %rbx
jmp 0x601c
movq %rax, %rbx
jmp 0x6026
movq %rax, %rbx
jmp 0x6033
movq %rax, %rbx
jmp 0x603d
movq %rax, %rbx
jmp 0x604a
movq %rax, %rbx
jmp 0x6054
movq %rax, %rbx
jmp 0x605e
movq %rax, %rbx
jmp 0x6068
movq %rax, %rbx
jmp 0x6072
movq %rax, %rbx
jmp 0x607c
movq %rax, %rbx
jmp 0x6086
jmp 0x5eef
movq %rax, %rbx
movq 0x1e0(%rsp), %rdi
leaq 0x1f0(%rsp), %rax
cmpq %rax, %rdi
jne 0x5eda
jmp 0x6093
jmp 0x5eef
movq %rax, %rbx
jmp 0x609d
jmp 0x5eef
movq %rax, %rbx
movq 0x1e0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6093
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x6093
movq %rax, %rbx
jmp 0x6093
movq %rax, %rbx
jmp 0x5f58
movq %rax, %rbx
jmp 0x5f65
movq %rax, %rbx
jmp 0x5f72
movq %rax, %rbx
jmp 0x5f7f
movq %rax, %rbx
jmp 0x5f8c
movq %rax, %rbx
jmp 0x5f99
movq %rax, %rbx
jmp 0x5fa6
movq %rax, %rbx
jmp 0x5fb3
movq %rax, %rbx
jmp 0x5fc0
movq %rax, %rbx
jmp 0x5fcd
movq %rax, %rbx
jmp 0x5fda
movq %rax, %rbx
jmp 0x5fe7
movq %rax, %rbx
leaq 0x128(%rsp), %rdi
callq 0x6408
leaq 0x88(%rsp), %rdi
callq 0x6450
leaq 0x98(%rsp), %rdi
callq 0x6450
leaq 0x138(%rsp), %rdi
callq 0x6408
leaq 0xa8(%rsp), %rdi
callq 0x6450
leaq 0xb8(%rsp), %rdi
callq 0x6450
leaq 0x148(%rsp), %rdi
callq 0x6408
leaq 0xc8(%rsp), %rdi
callq 0x6450
leaq 0xd8(%rsp), %rdi
callq 0x6450
leaq 0x158(%rsp), %rdi
callq 0x6408
leaq 0xe8(%rsp), %rdi
callq 0x6450
leaq 0xf8(%rsp), %rdi
callq 0x6450
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x108(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x58(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x38(%rsp), %rdi
callq 0x2220
movq 0x118(%rsp), %rdi
callq 0x2220
movq 0x78(%rsp), %rdi
callq 0x2220
movq 0x170(%rsp), %rdi
callq 0x2220
movq 0x60(%rsp), %rdi
callq 0x2220
movq 0x10(%rsp), %rdi
callq 0x2220
movq 0x68(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2220
movq 0x110(%rsp), %rdi
callq 0x2220
movq 0x8(%rsp), %rdi
callq 0x2220
leaq 0x1b0(%rsp), %rdi
callq 0x64fa
movq %rbx, %rdi
callq 0x2270