// File: /workspace/github_cpp_makefile_star2_O2/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 $0xee8, %rsp            # imm = 0xEE8
movq %rsi, %r15
movl %edi, 0x8(%rsp)
cmpl $0x1, %edi
jg 0x3fa3
movq %r15, %rdi
callq 0x241c
xorl %ebx, %ebx
jmp 0x55f3
leaq 0x8f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
leaq 0xcf0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
movb $0x0, 0x17(%rsp)
movl $0x1, 0x4c(%rsp)
leaq 0xaf0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
leaq 0x2c8(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
leaq 0x6f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
movl $0x12d, %edi            # imm = 0x12D
callq 0x2030
movq %rax, 0x38(%rsp)
movq %rax, 0x298(%rsp)
movl $0x12d, 0x290(%rsp) # imm = 0x12D
movl 0x8(%rsp), %eax
movq %rax, 0x40(%rsp)
pushq $0x1
popq %rbx
movb $0x1, 0x7(%rsp)
xorl %ebp, %ebp
movslq %ebx, %r14
cmpq 0x40(%rsp), %r14
jge 0x458a
movq (%r15,%r14,8), %r13
cmpb $0x2d, (%r13)
setne %al
orb %bpl, %al
testb $0x1, %al
jne 0x4398
movsbl 0x1(%r13), %ebp
movl %ebp, %edi
leaq 0x17(%rsp), %rsi
xorl %edx, %edx
callq 0x2a53
testb %al, %al
jne 0x4565
cmpb $0x68, %bpl
jne 0x40a3
cmpb $0x0, 0x2(%r13)
je 0x457d
movq %r13, %rdi
leaq 0x39a4(%rip), %rsi      # 0x7a51
callq 0x2280
testl %eax, %eax
je 0x457d
cmpb $0x6f, %bpl
je 0x40db
movzbl %bpl, %eax
movl %ebx, %r12d
cmpl $0x48, %eax
jne 0x40e9
cmpb $0x0, 0x2(%r13)
movl %ebx, %r12d
jne 0x40e9
jmp 0x55d7
cmpb $0x0, 0x2(%r13)
movl %r14d, %r12d
je 0x43fd
movq %r13, %rdi
leaq 0x3965(%rip), %rsi      # 0x7a58
callq 0x2280
testl %eax, %eax
je 0x43fa
cmpb $0x6c, %bpl
jne 0x4111
cmpb $0x0, 0x2(%r13)
je 0x4354
movq %r13, %rdi
leaq 0x3943(%rip), %rsi      # 0x7a5e
callq 0x2280
testl %eax, %eax
je 0x4354
movq %r13, %rdi
leaq 0x3934(%rip), %rsi      # 0x7a66
callq 0x2280
testl %eax, %eax
je 0x42c5
movq %r13, %rdi
leaq 0x391c(%rip), %rsi      # 0x7a65
callq 0x2280
testl %eax, %eax
je 0x42c5
movq %r13, %rdi
leaq 0x3911(%rip), %rsi      # 0x7a71
callq 0x2280
testl %eax, %eax
je 0x4513
movq %r13, %rdi
leaq 0x38fe(%rip), %rsi      # 0x7a75
callq 0x2280
testl %eax, %eax
je 0x4513
movq %r13, %rdi
leaq 0x38f6(%rip), %rsi      # 0x7a84
callq 0x2280
testl %eax, %eax
je 0x42dc
movq %r13, %rdi
leaq 0x38de(%rip), %rsi      # 0x7a83
callq 0x2280
testl %eax, %eax
je 0x42dc
cmpb $0x66, %bpl
jne 0x41c3
cmpb $0x0, 0x2(%r13)
je 0x43d2
movq %r13, %rdi
leaq 0x3906(%rip), %rsi      # 0x7ad3
callq 0x2280
testl %eax, %eax
je 0x43d2
movq %r13, %rdi
leaq 0x38f8(%rip), %rsi      # 0x7adc
callq 0x2280
testl %eax, %eax
je 0x436b
movq %r13, %rdi
leaq 0x38e6(%rip), %rsi      # 0x7ae1
callq 0x2280
testl %eax, %eax
je 0x436b
movq %r13, %rdi
leaq 0x38dc(%rip), %rsi      # 0x7aee
callq 0x2280
testl %eax, %eax
je 0x444f
movq %r13, %rdi
leaq 0x38cd(%rip), %rsi      # 0x7af6
callq 0x2280
testl %eax, %eax
je 0x4458
movq %r13, %rdi
leaq 0x38bd(%rip), %rsi      # 0x7afd
callq 0x2280
testl %eax, %eax
je 0x446c
movq %r13, %rdi
leaq 0x38b3(%rip), %rsi      # 0x7b0a
callq 0x2280
testl %eax, %eax
je 0x4493
movq %r13, %rdi
leaq 0x38a5(%rip), %rsi      # 0x7b13
callq 0x2280
testl %eax, %eax
je 0x44ba
cmpb $0x6d, %bpl
jne 0x428c
cmpb $0x0, 0x2(%r13)
je 0x4425
movq %r13, %rdi
leaq 0x3887(%rip), %rsi      # 0x7b1d
callq 0x2280
testl %eax, %eax
je 0x4425
cmpb $0x2d, %bpl
jne 0x5607
cmpb $0x0, 0x2(%r13)
jne 0x5607
incq %r14
incl %ebx
movb $0x1, %bpl
jmp 0x4055
movl 0x8(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0xaf0(%rsp), %rcx
jmp 0x440e
movq 0x8(%r15,%r14,8), %rbx
movq %rbx, %rdi
callq 0x2810
testb %al, %al
je 0x44f2
movq 0x10(%r15,%r14,8), %r13
movq %r13, %rdi
callq 0x2810
testb %al, %al
je 0x44f2
movq 0x18(%r15,%r14,8), %rbp
movq %rbp, %rdi
callq 0x2810
testb %al, %al
je 0x44f2
movq %rbx, %rdi
callq 0x2230
movsd %xmm0, 0x6e7d(%rip)     # 0xb1a8
movq %r13, %rdi
callq 0x2230
movsd %xmm0, 0x6e75(%rip)     # 0xb1b0
movq %rbp, %rdi
callq 0x2230
movsd %xmm0, 0x6e6d(%rip)     # 0xb1b8
addl $0x4, %r12d
jmp 0x4462
movl 0x8(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0xcf0(%rsp), %rcx
jmp 0x440e
subq $0x8, %rsp
movl 0x10(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x6e20(%rip), %rcx      # 0xb1a0
pushq $0x1
popq %r8
xorl %r9d, %r9d
pushq $0x7fffffff             # imm = 0x7FFFFFFF
callq 0x58f7
popq %rcx
popq %rdx
jmp 0x44e0
leaq 0x2f0(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
leaq 0x4f0(%rsp), %rdx
callq 0x5ce0
leaq 0x2c0(%rsp), %rdi
movq %r14, %rsi
callq 0x6488
movq %r14, %rdi
callq 0x2100
incl %ebx
jmp 0x4052
subq $0x8, %rsp
movl 0x10(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x54(%rsp), %rcx
pushq $0x1
popq %r8
xorl %r9d, %r9d
pushq $0x4
callq 0x58f7
popq %rcx
popq %rdx
jmp 0x44e0
movl %r12d, %ebx
movl 0x8(%rsp), %edi
movq %r15, %rsi
movl %ebx, %edx
leaq 0x8f0(%rsp), %rcx
callq 0x274f
movl %eax, %ebx
xorl %ebp, %ebp
cmpl $-0x1, %eax
jne 0x4052
jmp 0x5640
subq $0x8, %rsp
movl 0x10(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x6d4e(%rip), %rcx      # 0xb188
pushq $0x1
popq %r8
xorl %r9d, %r9d
pushq $0x4
callq 0x58f7
popq %rcx
popq %rdx
jmp 0x44e0
movb $0x1, 0x6d77(%rip)      # 0xb1cd
jmp 0x445f
movb $0x1, 0x6d75(%rip)      # 0xb1d4
incl %r12d
xorl %ebp, %ebp
movl %r12d, %ebx
jmp 0x4052
subq $0x8, %rsp
movl 0x10(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x6d57(%rip), %rcx      # 0xb1d8
pushq $0x1
popq %r8
xorl %r9d, %r9d
pushq $0xa
callq 0x58f7
popq %rcx
popq %rdx
jmp 0x44e0
subq $0x8, %rsp
movl 0x10(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x6d28(%rip), %rcx      # 0xb1d0
pushq $0x1
popq %r8
xorl %r9d, %r9d
pushq $0x1
callq 0x58f7
popq %rcx
popq %rdx
jmp 0x44e0
xorpd %xmm0, %xmm0
movl 0x8(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
leaq 0x6cc9(%rip), %rcx      # 0xb198
pushq $0x1
popq %r8
movsd 0x2b35(%rip), %xmm1     # 0x7010
callq 0x5a75
movl %eax, %ebx
xorl %ebp, %ebp
cmpl $-0x1, %eax
jne 0x4052
jmp 0x5640
movq 0x6adf(%rip), %rax      # 0xafd8
movq (%rax), %rcx
leaq 0x358b(%rip), %rdi      # 0x7a8e
pushq $0x44
popq %rsi
pushq $0x1
popq %rdx
callq 0x22e0
jmp 0x434b
movl $0x1f5, %edx            # imm = 0x1F5
leaq 0x2f0(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl 0x8(%rsp), %edi
movq %r15, %rsi
movl %r12d, %edx
movq %r14, %rcx
callq 0x274f
cmpl $-0x1, %eax
je 0x5640
movl %eax, %ebx
movq %r14, %rdi
leaq 0x352e(%rip), %rsi      # 0x7a7f
pushq $0x1
popq %rdx
callq 0x2250
testl %eax, %eax
sete 0x7(%rsp)
jmp 0x4050
movq %r13, %rdi
callq 0x20f0
cmpl $0x1, %eax
jg 0x5645
incl %ebx
jmp 0x4050
movq %r15, %rdi
callq 0x241c
jmp 0x55d7
cmpb $0x1, 0x6c3c(%rip)      # 0xb1cd
jne 0x45a1
cmpb $0x0, 0xaf0(%rsp)
je 0x5624
movsd 0x6bef(%rip), %xmm0     # 0xb198
movsd %xmm0, 0x60(%rsp)
cmpb $0x0, 0xcf0(%rsp)
je 0x464c
leaq 0x34ab(%rip), %r15      # 0x7a6f
leaq 0xcf0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2220
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x2a98
testq %rbx, %rbx
je 0x464c
leaq 0x2f0(%rsp), %r15
leaq 0x4f0(%rsp), %r12
leaq 0x2c0(%rsp), %r13
movq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x29fd
cmpl $-0x1, %eax
je 0x4644
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5ce0
movq %r13, %rdi
movq %r15, %rsi
callq 0x6488
movq %r15, %rdi
callq 0x2100
jmp 0x460c
movq %rbx, %rdi
callq 0x21a0
cmpb $0x0, 0x8f0(%rsp)
je 0x469d
leaq 0x351e(%rip), %rsi      # 0x7b7b
leaq 0x8f0(%rsp), %rdi
callq 0x21e0
testl %eax, %eax
je 0x469d
leaq 0x350d(%rip), %rbx      # 0x7b82
leaq 0x8f0(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2220
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x2a98
jmp 0x46a7
movq 0x691c(%rip), %rax      # 0xafc0
movq (%rax), %r13
cmpq $0x0, 0x2e8(%rsp)
je 0x4766
leaq 0x352b(%rip), %r10      # 0x7be8
leaq 0x351f(%rip), %r12      # 0x7be3
leaq 0x3513(%rip), %r15      # 0x7bde
leaq 0x3507(%rip), %r14      # 0x7bd9
leaq 0x34f9(%rip), %rbx      # 0x7bd2
leaq 0x34eb(%rip), %r11      # 0x7bcb
leaq 0x349d(%rip), %rsi      # 0x7b84
leaq 0x34c1(%rip), %rdx      # 0x7baf
leaq 0x34bf(%rip), %rcx      # 0x7bb4
leaq 0x34c1(%rip), %r8       # 0x7bbd
leaq 0x34c1(%rip), %r9       # 0x7bc4
movq %r13, %rdi
xorl %eax, %eax
pushq %r10
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
callq 0x2290
addq $0x30, %rsp
testb $0x1, 0x7(%rsp)
je 0x475b
leaq 0x34c5(%rip), %rsi      # 0x7bef
leaq 0x34de(%rip), %rdx      # 0x7c0f
leaq 0x34df(%rip), %rcx      # 0x7c17
leaq 0x34de(%rip), %r8       # 0x7c1d
leaq 0x34dd(%rip), %r9       # 0x7c23
movq %r13, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
callq 0x2290
addq $0x20, %rsp
pushq $0xa
popq %rdi
movq %r13, %rsi
callq 0x2240
movl 0x6a34(%rip), %ebx      # 0xb1a0
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x208(%rsp)
movl %ebx, 0x200(%rsp)
movq %rbx, %rdi
callq 0x2030
movq %rax, 0x1f8(%rsp)
movl %ebx, 0x1f0(%rsp)
movq %rbx, %rdi
callq 0x2030
leaq 0x2b0(%rsp), %r14
movq %rax, 0x8(%r14)
movl %ebx, (%r14)
leaq 0x200(%rsp), %rbx
pushq $0x2d
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5d1c
leaq 0x1f0(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x5d1c
movq %r14, %rdi
movl %ebp, %esi
callq 0x5d1c
movq 0x8(%rbx), %rax
movq %rax, 0x230(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x28(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x20(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, 0x118(%rsp)
movl $0x4, 0x110(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, 0x108(%rsp)
movl $0x4, 0x100(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %rax, 0xf8(%rsp)
movl $0x4, 0xf0(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %rax, 0xe8(%rsp)
movl $0x4, 0xe0(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, 0xd8(%rsp)
movl $0x4, 0xd0(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %rax, 0xc8(%rsp)
movl $0x4, 0xc0(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %rax, 0x1e8(%rsp)
movl $0x4, 0x1e0(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %rax, 0x1d8(%rsp)
movl $0x4, 0x1d0(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, 0x1c8(%rsp)
movl $0x4, 0x1c0(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
movq %rax, 0x1b8(%rsp)
movl $0x4, 0x1b0(%rsp)
pushq $0x10
popq %rdi
callq 0x2030
movq %r13, 0x58(%rsp)
movq %rax, 0x1a8(%rsp)
movl $0x4, 0x1a0(%rsp)
pushq $0x20
popq %rdi
callq 0x2030
leaq 0x2a0(%rsp), %r13
movq %rax, 0x8(%r13)
movl $0x4, (%r13)
leaq 0x110(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5d34
leaq 0x100(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5d34
leaq 0xf0(%rsp), %rdi
xorl %esi, %esi
callq 0x5d4c
leaq 0xe0(%rsp), %rdi
xorl %esi, %esi
callq 0x5d4c
leaq 0xd0(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5d34
leaq 0xc0(%rsp), %rdi
xorl %esi, %esi
callq 0x5d4c
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x5d4c
leaq 0x1d0(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5d4c
leaq 0x1c0(%rsp), %rbp
xorpd %xmm0, %xmm0
movq %rbp, %rdi
callq 0x5d34
leaq 0x1b0(%rsp), %r14
xorpd %xmm0, %xmm0
movq %r14, %rdi
callq 0x5d34
leaq 0x1a0(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d4c
xorpd %xmm0, %xmm0
movq %r13, %rdi
callq 0x5d34
leaq 0x110(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa8(%rsp)
leaq 0x100(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb8(%rsp)
leaq 0xf0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x88(%rsp)
leaq 0xe0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
leaq 0xd0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb0(%rsp)
leaq 0xc0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x8(%r15), %rax
movq %rax, 0x80(%rsp)
movq 0x8(%r12), %rax
movq %rax, 0x68(%rsp)
movq 0x8(%rbp), %r15
movq 0x8(%r14), %rax
movq %rax, 0x78(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x70(%rsp)
movq 0x8(%r13), %r14
movl 0x66e4(%rip), %ebx      # 0xb1a0
leaq (,%rbx,8), %rdi
callq 0x2030
movq %rax, 0x198(%rsp)
movl %ebx, 0x190(%rsp)
leaq 0x280(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x270(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x180(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5db4
leaq 0x170(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x160(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x150(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5db4
leaq 0x260(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x250(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x140(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5db4
leaq 0x240(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
leaq 0x130(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5d62
movq %r14, 0x210(%rsp)
movq %r15, 0x218(%rsp)
leaq 0x120(%rsp), %rdi
pushq $0x65
popq %rsi
pushq $0x4
popq %rdx
callq 0x5db4
movsd 0x60(%rsp), %xmm0
mulsd 0x2446(%rip), %xmm0     # 0x7020
movsd %xmm0, 0x60(%rsp)
leaq 0x190(%rsp), %r15
xorpd %xmm0, %xmm0
movq %r15, %rdi
callq 0x5d34
leaq 0x280(%rsp), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x270(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x180(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5e32
leaq 0x170(%rsp), %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x150(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5e32
leaq 0x260(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x250(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x140(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5e32
leaq 0x240(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x130(%rsp), %rdi
xorl %esi, %esi
callq 0x5e06
leaq 0x120(%rsp), %rdi
xorpd %xmm0, %xmm0
callq 0x5e32
movq 0x8(%r15), %rax
movq %rax, 0x30(%rsp)
movq (%r12), %r12
movq (%rbp), %rbp
leaq 0x180(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x228(%rsp)
leaq 0x170(%rsp), %rax
movq (%rax), %r15
leaq 0x160(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x150(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movq (%r14), %r14
movq (%rbx), %rbx
leaq 0x140(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x220(%rsp)
movq (%r13), %r13
leaq 0x130(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x120(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x98(%rsp)
leaq 0x2f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
leaq 0x4f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2130
movq 0x2d8(%rsp), %rcx
movq $0x0, 0x90(%rsp)
leaq 0x2c8(%rsp), %rax
cmpq %rax, %rcx
je 0x5173
movq %rcx, 0x238(%rsp)
movq 0x20(%rcx), %rsi
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x6f0(%rsp), %rdi
callq 0x2170
movb $0x0, 0x8e3(%rsp)
leaq 0x6f0(%rsp), %rdi
leaq 0x2f0(%rsp), %rsi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x26f5
movl 0x63eb(%rip), %r9d      # 0xb1d0
movl 0x4c(%rsp), %eax
subq $0x8, %rsp
leaq 0x6f8(%rsp), %rdi
movq 0x238(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x38(%rsp), %r8
pushq %rax
callq 0x2bf5
popq %rcx
popq %rdx
cmpb $0x1, 0x63b9(%rip)      # 0xb1d4
movq %rax, 0x18(%rsp)
jne 0x4e39
movl 0x63b0(%rip), %edx      # 0xb1d8
movq 0x20(%rsp), %rdi
movl %eax, %esi
callq 0x315c
movq 0x18(%rsp), %rax
cmpb $0x1, 0x638d(%rip)      # 0xb1cd
jne 0x4eb2
leaq 0x4f0(%rsp), %rdi
leaq 0x2dd8(%rip), %rsi      # 0x7c29
leaq 0xaf0(%rsp), %rdx
leaq 0x2f0(%rsp), %rcx
xorl %eax, %eax
callq 0x2090
movl 0x6362(%rip), %edx      # 0xb1d0
leaq 0x4f0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x32df
movq 0x18(%rsp), %rax
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x4eb2
movq 0x30(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
mulsd 0x2168(%rip), %xmm0     # 0x7010
movsd %xmm0, (%rdx,%rcx,8)
incq %rcx
jmp 0x4e91
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl %eax, %edx
movq 0x40(%rsp), %r8
movq 0xc0(%rsp), %r9
pushq $0x3
callq 0x3518
movq 0x28(%rsp), %r11
addq $0x10, %rsp
movq 0xb8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x211c(%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 0x38(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
movq 0x58(%rsp), %rdi
leaq 0x2d02(%rip), %rsi      # 0x7c33
leaq 0x2f0(%rsp), %rdx
movb $0x4, %al
pushq %r11
pushq %r10
callq 0x2290
popq %rcx
popq %rdx
testb $0x1, 0x7(%rsp)
je 0x4fda
subq $0x8, %rsp
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x90(%rsp), %rcx
movq 0x58(%rsp), %r8
movq 0xb0(%rsp), %r9
pushq $0x3
callq 0x3b98
popq %rcx
popq %rdx
movq 0xa8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x2079(%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 0x50(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq 0x58(%rsp), %rdi
leaq 0x2c96(%rip), %rsi      # 0x7c69
movb $0x4, %al
callq 0x2290
pushq $0xa
popq %rdi
movq 0x58(%rsp), %rsi
callq 0x2240
cmpb $0x0, 0x61df(%rip)      # 0xb1cd
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %r8
movq 0x88(%rsp), %r9
movq 0x50(%rsp), %r10
movq 0xb0(%rsp), %r11
je 0x50fd
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r12, %r8
movq %rbp, %r9
movsd 0x60(%rsp), %xmm0
pushq $0x3
popq %rax
pushq %rax
pushq 0x230(%rsp)
callq 0x3c67
popq %rcx
popq %rdx
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r14, %r8
movq %rbx, %r9
pushq $0x3
popq %rax
pushq %rax
pushq 0x228(%rsp)
callq 0x3e0a
movq 0xc0(%rsp), %r11
movq 0x60(%rsp), %r10
movq 0x98(%rsp), %r9
movq 0x88(%rsp), %r8
movq 0x90(%rsp), %rdi
addq $0x10, %rsp
xorl %eax, %eax
cmpq $0x4, %rax
je 0x50fd
xorl %ecx, %ecx
cmpq $0x328, %rcx            # imm = 0x328
je 0x50f8
movq (%r12,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%r15,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%rbp,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq 0x40(%rsp), %rsi
movq (%rsi,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%r14,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%r13,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%rbx,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq 0x8(%rsp), %rsi
movq (%rsi,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
addq $0x8, %rcx
jmp 0x50a5
incq %rax
jmp 0x509d
xorl %eax, %eax
movq 0x68(%rsp), %rdx
movq 0x70(%rsp), %rsi
cmpq $0x10, %rax
je 0x5140
movsd (%r11,%rax,2), %xmm0
addsd (%r8,%rax,2), %xmm0
movsd %xmm0, (%r8,%rax,2)
movq 0x38(%rsp), %rcx
movl (%rcx,%rax), %ecx
addl %ecx, (%rsi,%rax)
movl (%r9,%rax), %ecx
addl %ecx, (%rdi,%rax)
movl (%r10,%rax), %ecx
addl %ecx, (%rdx,%rax)
addq $0x4, %rax
jmp 0x5109
movq 0x18(%rsp), %rax
addl 0x90(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x238(%rsp), %rdi
callq 0x2210
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rax, 0x90(%rsp)
jmp 0x4d8d
xorl %eax, %eax
movsd 0x1e8b(%rip), %xmm2     # 0x7008
movq 0x68(%rsp), %rcx
movq 0x218(%rsp), %r12
movq 0x70(%rsp), %rdx
movq 0x210(%rsp), %rbp
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdi
cmpq $0x10, %rax
je 0x51e0
cvtsi2sdl (%rdx,%rax), %xmm0
movsd (%rdi,%rax,2), %xmm1
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rbp,%rax,2)
cvtsi2sdl (%rsi,%rax), %xmm0
cvtsi2sdl (%rcx,%rax), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%r12,%rax,2)
addq $0x4, %rax
jmp 0x51a4
cmpb $0x1, 0x5fe6(%rip)      # 0xb1cd
jne 0x5387
xorl %eax, %eax
movq 0xa0(%rsp), %rsi
movq 0x98(%rsp), %rdi
cmpq $0x4, %rax
je 0x526c
xorl %ecx, %ecx
cmpq $0x328, %rcx            # imm = 0x328
je 0x5267
movq (%r15,%rcx), %rdx
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq 0x40(%rsp), %rdx
movq (%rdx,%rcx), %rdx
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%rsi,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
movq (%r13,%rcx), %rdx
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq 0x8(%rsp), %rdx
movq (%rdx,%rcx), %rdx
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%rdi,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
addq $0x8, %rcx
jmp 0x5207
incq %rax
jmp 0x51ff
movq 0x5d4d(%rip), %r15      # 0xafc0
movq (%r15), %rdi
movsd 0x5f1a(%rip), %xmm0     # 0xb198
leaq 0x2a0c(%rip), %rsi      # 0x7c91
movb $0x1, %al
callq 0x2290
movq (%r15), %rdi
leaq 0x2a0c(%rip), %rsi      # 0x7ca2
leaq 0x2a14(%rip), %rdx      # 0x7cb1
leaq 0x2a11(%rip), %rcx      # 0x7cb5
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x2290
movq (%r15), %rdi
subq $0x8, %rsp
leaq 0x2a2b(%rip), %r9       # 0x7ce6
leaq 0x2a25(%rip), %r8       # 0x7ce7
leaq 0x27b3(%rip), %rcx      # 0x7a7c
leaq 0x29f0(%rip), %rsi      # 0x7cc0
leaq 0x2a0a(%rip), %rdx      # 0x7ce1
xorl %eax, %eax
pushq %r9
pushq %r8
pushq %rcx
callq 0x2290
addq $0x20, %rsp
leaq 0x2a00(%rip), %r14      # 0x7cee
cmpq $0x65, %rbx
movsd 0x1d0e(%rip), %xmm2     # 0x7008
je 0x5387
movq 0x40(%rsp), %rax
movq (%rax,%rbx,8), %rax
movl 0xc(%rax), %ecx
cvtsi2sd %ecx, %xmm1
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
cvtsi2sdl 0xc(%rax), %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x1ce3(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm1
movq (%rdx,%rbx,8), %rax
movl 0xc(%rax), %r8d
cvtsi2sd %r8d, %xmm3
divsd %xmm0, %xmm3
mulsd %xmm4, %xmm3
movq (%r15), %rdi
movq 0xa0(%rsp), %rax
movq (%rax,%rbx,8), %rax
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movq 0x98(%rsp), %rax
movq (%rax,%rbx,8), %rax
movsd 0x18(%rax), %xmm2
mulsd %xmm4, %xmm2
movq %r14, %rsi
movl %ebx, %edx
movb $0x4, %al
callq 0x2290
incq %rbx
jmp 0x52ee
movsd 0x18(%rbp), %xmm0
movsd 0x1c7c(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm0
movsd (%rbp), %xmm1
mulsd %xmm4, %xmm1
movsd 0x8(%rbp), %xmm2
mulsd %xmm4, %xmm2
movsd 0x10(%rbp), %xmm3
mulsd %xmm4, %xmm3
movq 0x70(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
leaq 0x2949(%rip), %rsi      # 0x7d16
leaq 0x2975(%rip), %rdx      # 0x7d49
movq 0x58(%rsp), %rbx
movq %rbx, %rdi
movb $0x4, %al
pushq 0x90(%rsp)
pushq %r10
callq 0x2290
popq %rcx
popq %rdx
testb $0x1, 0x7(%rsp)
je 0x5447
movsd 0x18(%r12), %xmm0
movsd 0x1c0c(%rip), %xmm3     # 0x7010
mulsd %xmm3, %xmm0
movsd (%r12), %xmm1
mulsd %xmm3, %xmm1
movsd 0x8(%r12), %xmm2
mulsd %xmm3, %xmm2
mulsd 0x10(%r12), %xmm3
movq 0x68(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
leaq 0x282c(%rip), %rsi      # 0x7c69
movq %rbx, %rdi
movb $0x4, %al
callq 0x2290
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2240
testq %rbx, %rbx
je 0x546b
movq 0x5b62(%rip), %rax      # 0xafc0
cmpq (%rax), %rbx
je 0x546b
movq %rbx, %rdi
callq 0x21a0
leaq 0x120(%rsp), %rdi
callq 0x5e60
leaq 0x130(%rsp), %rdi
callq 0x5ea0
leaq 0x240(%rsp), %rdi
callq 0x5ea0
leaq 0x140(%rsp), %rdi
callq 0x5e60
leaq 0x250(%rsp), %rdi
callq 0x5ea0
leaq 0x260(%rsp), %rdi
callq 0x5ea0
leaq 0x150(%rsp), %rdi
callq 0x5e60
leaq 0x160(%rsp), %rdi
callq 0x5ea0
leaq 0x170(%rsp), %rdi
callq 0x5ea0
leaq 0x180(%rsp), %rdi
callq 0x5e60
leaq 0x270(%rsp), %rdi
callq 0x5ea0
leaq 0x280(%rsp), %rdi
callq 0x5ea0
leaq 0x190(%rsp), %rdi
callq 0x5ee0
leaq 0x2a0(%rsp), %rdi
callq 0x5ee0
leaq 0x1a0(%rsp), %rdi
callq 0x5efc
leaq 0x1b0(%rsp), %rdi
callq 0x5ee0
leaq 0x1c0(%rsp), %rdi
callq 0x5ee0
leaq 0x1d0(%rsp), %rdi
callq 0x5efc
leaq 0x1e0(%rsp), %rdi
callq 0x5efc
leaq 0xc0(%rsp), %rdi
callq 0x5efc
leaq 0xd0(%rsp), %rdi
callq 0x5ee0
leaq 0xe0(%rsp), %rdi
callq 0x5efc
leaq 0xf0(%rsp), %rdi
callq 0x5efc
leaq 0x100(%rsp), %rdi
callq 0x5ee0
leaq 0x110(%rsp), %rdi
callq 0x5ee0
leaq 0x2b0(%rsp), %rdi
callq 0x5bf8
leaq 0x1f0(%rsp), %rdi
callq 0x5bf8
leaq 0x200(%rsp), %rdi
callq 0x5bf8
xorl %ebx, %ebx
leaq 0x290(%rsp), %rdi
callq 0x5bf8
leaq 0x2c0(%rsp), %rdi
callq 0x5fb8
movl %ebx, %eax
addq $0xee8, %rsp            # imm = 0xEE8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x59ca(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x250e(%rip), %rsi      # 0x7b26
movq %r13, %rdx
xorl %eax, %eax
callq 0x2290
jmp 0x5640
movq 0x59ad(%rip), %rax      # 0xafd8
movq (%rax), %rcx
leaq 0x250f(%rip), %rdi      # 0x7b44
pushq $0x36
popq %rsi
pushq $0x1
popq %rdx
callq 0x22e0
pushq $-0x1
popq %rbx
jmp 0x55d9
movq 0x598c(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x23a9(%rip), %rsi      # 0x79ff
movl %ebp, %edx
xorl %eax, %eax
callq 0x2290
jmp 0x5640
movq %rax, %rbx
jmp 0x5776
movq %rax, %rbx
jmp 0x5783
movq %rax, %rbx
jmp 0x5790
movq %rax, %rbx
jmp 0x579d
movq %rax, %rbx
jmp 0x57aa
movq %rax, %rbx
jmp 0x57b7
movq %rax, %rbx
jmp 0x57c4
movq %rax, %rbx
jmp 0x57d1
movq %rax, %rbx
jmp 0x57de
movq %rax, %rbx
jmp 0x57eb
movq %rax, %rbx
jmp 0x57f8
movq %rax, %rbx
jmp 0x5805
movq %rax, %rbx
jmp 0x5812
movq %rax, %rbx
jmp 0x581f
movq %rax, %rbx
jmp 0x582c
movq %rax, %rbx
jmp 0x5839
movq %rax, %rbx
jmp 0x5846
movq %rax, %rbx
jmp 0x5853
movq %rax, %rbx
jmp 0x5860
movq %rax, %rbx
jmp 0x586d
movq %rax, %rbx
jmp 0x587a
movq %rax, %rbx
jmp 0x5887
movq %rax, %rbx
jmp 0x5894
movq %rax, %rbx
jmp 0x58a1
movq %rax, %rbx
jmp 0x58ae
movq %rax, %rbx
jmp 0x58bb
movq %rax, %rbx
jmp 0x58c8
jmp 0x5749
jmp 0x5751
jmp 0x5749
movq %rax, %rbx
jmp 0x58e2
jmp 0x5749
movq %rax, %rbx
jmp 0x58d5
movq %rax, %rbx
leaq 0x2f0(%rsp), %rdi
callq 0x2100
jmp 0x58d5
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x5e60
leaq 0x130(%rsp), %rdi
callq 0x5ea0
leaq 0x240(%rsp), %rdi
callq 0x5ea0
leaq 0x140(%rsp), %rdi
callq 0x5e60
leaq 0x250(%rsp), %rdi
callq 0x5ea0
leaq 0x260(%rsp), %rdi
callq 0x5ea0
leaq 0x150(%rsp), %rdi
callq 0x5e60
leaq 0x160(%rsp), %rdi
callq 0x5ea0
leaq 0x170(%rsp), %rdi
callq 0x5ea0
leaq 0x180(%rsp), %rdi
callq 0x5e60
leaq 0x270(%rsp), %rdi
callq 0x5ea0
leaq 0x280(%rsp), %rdi
callq 0x5ea0
leaq 0x190(%rsp), %rdi
callq 0x5ee0
leaq 0x2a0(%rsp), %rdi
callq 0x5ee0
leaq 0x1a0(%rsp), %rdi
callq 0x5efc
leaq 0x1b0(%rsp), %rdi
callq 0x5ee0
leaq 0x1c0(%rsp), %rdi
callq 0x5ee0
leaq 0x1d0(%rsp), %rdi
callq 0x5efc
leaq 0x1e0(%rsp), %rdi
callq 0x5efc
leaq 0xc0(%rsp), %rdi
callq 0x5efc
leaq 0xd0(%rsp), %rdi
callq 0x5ee0
leaq 0xe0(%rsp), %rdi
callq 0x5efc
leaq 0xf0(%rsp), %rdi
callq 0x5efc
leaq 0x100(%rsp), %rdi
callq 0x5ee0
leaq 0x110(%rsp), %rdi
callq 0x5ee0
leaq 0x2b0(%rsp), %rdi
callq 0x5bf8
leaq 0x1f0(%rsp), %rdi
callq 0x5bf8
leaq 0x200(%rsp), %rdi
callq 0x5bf8
leaq 0x290(%rsp), %rdi
callq 0x5bf8
leaq 0x2c0(%rsp), %rdi
callq 0x5fb8
movq %rbx, %rdi
callq 0x22c0