// File: /workspace/github_cpp_makefile_star2_O3/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 $0xde8, %rsp            # imm = 0xDE8
movq %rsi, %r12
cmpl $0x1, %edi
jg 0x442a
movq %r12, %rdi
callq 0x25fc
xorl %ebx, %ebx
jmp 0x5eb9
movl %edi, %ebx
leaq 0x3f0(%rsp), %rdi
xorl %r14d, %r14d
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x9f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movb $0x0, 0x27(%rsp)
movl $0x1, 0x8c(%rsp)
leaq 0xbf0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x1c8(%rsp), %rax
movl $0x0, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r14, 0x20(%rax)
leaq 0x7f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movl $0x12d, %edi            # imm = 0x12D
callq 0x2030
movq %rax, 0x18(%rsp)
movl %ebx, %eax
movq %rax, 0x28(%rsp)
movb $0x1, 0xf(%rsp)
movl $0x1, %r14d
xorl %ebp, %ebp
movq %r12, 0x10(%rsp)
movslq %r14d, %r13
movq (%r12,%r13,8), %r15
cmpb $0x2d, (%r15)
jne 0x48f5
testb $0x1, %bpl
jne 0x48f5
movzbl 0x1(%r15), %ebp
leaq 0x27(%rsp), %rdi
callq 0x20e0
testl %eax, %eax
jle 0x4511
cmpl $0x68, %ebp
je 0x4516
testl %ebp, %ebp
jne 0x4539
jmp 0x4a82
cmpl $0x68, %ebp
jne 0x4539
cmpb $0x0, 0x2(%r15)
je 0x4aa4
movq %r15, %rdi
leaq 0x357e(%rip), %rsi      # 0x7aa9
callq 0x2230
testl %eax, %eax
jne 0x4565
jmp 0x4aa4
movq %r15, %rdi
leaq 0x3566(%rip), %rsi      # 0x7aa9
callq 0x2230
testl %eax, %eax
je 0x4aa4
cmpl $0x6f, %ebp
je 0x4593
cmpl $0x48, %ebp
jne 0x4565
cmpb $0x0, 0x2(%r15)
je 0x4aac
movq %r15, %rdi
leaq 0x3541(%rip), %rsi      # 0x7ab0
callq 0x2230
testl %eax, %eax
je 0x489b
movl %r14d, %r12d
cmpl $0x6c, %ebp
jne 0x45b8
cmpb $0x0, 0x2(%r15)
movl %r14d, %r12d
jne 0x45b8
jmp 0x4950
cmpb $0x0, 0x2(%r15)
je 0x489b
movq %r15, %rdi
leaq 0x3508(%rip), %rsi      # 0x7ab0
callq 0x2230
movl %r13d, %r12d
testl %eax, %eax
je 0x489b
movq %r15, %rdi
leaq 0x34f4(%rip), %rsi      # 0x7ab6
callq 0x2230
testl %eax, %eax
je 0x494d
movq %r15, %rdi
leaq 0x34e5(%rip), %rsi      # 0x7abe
callq 0x2230
testl %eax, %eax
je 0x4773
movq %r15, %rdi
leaq 0x34cd(%rip), %rsi      # 0x7abd
callq 0x2230
testl %eax, %eax
je 0x4773
movq %r15, %rdi
leaq 0x34c2(%rip), %rsi      # 0x7ac9
callq 0x2230
testl %eax, %eax
je 0x4798
movq %r15, %rdi
leaq 0x34af(%rip), %rsi      # 0x7acd
callq 0x2230
testl %eax, %eax
je 0x4798
movq %r15, %rdi
leaq 0x34a7(%rip), %rsi      # 0x7adc
callq 0x2230
testl %eax, %eax
je 0x47ed
movq %r15, %rdi
leaq 0x348f(%rip), %rsi      # 0x7adb
callq 0x2230
testl %eax, %eax
je 0x47ed
cmpl $0x66, %ebp
jne 0x4669
cmpb $0x0, 0x2(%r15)
je 0x48c6
movq %r15, %rdi
leaq 0x34b8(%rip), %rsi      # 0x7b2b
callq 0x2230
testl %eax, %eax
je 0x48c6
movq %r15, %rdi
leaq 0x34aa(%rip), %rsi      # 0x7b34
callq 0x2230
testl %eax, %eax
je 0x486a
movq %r15, %rdi
leaq 0x3498(%rip), %rsi      # 0x7b39
callq 0x2230
testl %eax, %eax
je 0x486a
movq %r15, %rdi
leaq 0x348e(%rip), %rsi      # 0x7b46
callq 0x2230
testl %eax, %eax
je 0x497d
movq %r15, %rdi
leaq 0x347f(%rip), %rsi      # 0x7b4e
callq 0x2230
testl %eax, %eax
je 0x4986
movq %r15, %rdi
leaq 0x346f(%rip), %rsi      # 0x7b55
callq 0x2230
testl %eax, %eax
je 0x499a
movq %r15, %rdi
leaq 0x3465(%rip), %rsi      # 0x7b62
callq 0x2230
testl %eax, %eax
je 0x49c8
movq %r15, %rdi
leaq 0x3457(%rip), %rsi      # 0x7b6b
callq 0x2230
testl %eax, %eax
je 0x49f3
cmpl $0x6d, %ebp
je 0x4a1d
movq %r15, %rdi
leaq 0x3441(%rip), %rsi      # 0x7b75
callq 0x2230
testl %eax, %eax
je 0x4a3b
cmpl $0x2d, %ebp
jne 0x5e78
cmpb $0x0, 0x2(%r15)
jne 0x5e78
incq %r13
incl %r14d
movb $0x1, %bpl
cmpq 0x28(%rsp), %r13
movq 0x10(%rsp), %r12
jl 0x44d8
jmp 0x4ab3
movl %ebx, %edi
movq 0x10(%rsp), %rsi
movl %r12d, %edx
leaq 0xbf0(%rsp), %rcx
callq 0x297c
cmpl $-0x1, %eax
jne 0x4975
jmp 0x5e9a
movl $0x1f5, %edx            # imm = 0x1F5
leaq 0x1f0(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x2100
movl %ebx, %edi
movq 0x10(%rsp), %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0x297c
cmpl $-0x1, %eax
je 0x5e9a
movl %eax, %r14d
movl $0x1, %edx
movq %r13, %rdi
leaq 0x32fb(%rip), %rsi      # 0x7ad7
callq 0x2210
testl %eax, %eax
sete 0xf(%rsp)
jmp 0x4a70
movq 0x10(%rsp), %rbp
movq 0x8(%rbp,%r13,8), %r14
movq %r14, %rdi
callq 0x2a3f
testb %al, %al
je 0x4a9a
movq 0x10(%rbp,%r13,8), %r15
movq %r15, %rdi
callq 0x2a3f
testb %al, %al
je 0x4a9a
movq 0x18(%rbp,%r13,8), %r13
movq %r13, %rdi
callq 0x2a3f
testb %al, %al
je 0x4a9a
movq %r14, %rdi
callq 0x21f0
movsd %xmm0, 0x693f(%rip)     # 0xb180
movq %r15, %rdi
callq 0x21f0
movsd %xmm0, 0x6937(%rip)     # 0xb188
movq %r13, %rdi
callq 0x21f0
movsd %xmm0, 0x692f(%rip)     # 0xb190
addl $0x4, %r12d
jmp 0x4990
subq $0x8, %rsp
movl %ebx, %edi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
leaq 0x68f9(%rip), %rcx      # 0xb178
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x7fffffff             # imm = 0x7FFFFFFF
callq 0x61d8
addq $0x10, %rsp
jmp 0x4a64
movl %ebx, %edi
movq 0x10(%rsp), %r12
movq %r12, %rsi
movl %r14d, %edx
leaq 0x3f0(%rsp), %rcx
callq 0x297c
cmpl $-0x1, %eax
je 0x5e9a
movl %eax, %r14d
jmp 0x4a96
subq $0x8, %rsp
movl %ebx, %edi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
leaq 0x94(%rsp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x4
callq 0x61d8
addq $0x10, %rsp
jmp 0x4a64
leaq 0x1f0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
leaq 0x5f0(%rsp), %rdx
callq 0x64f0
leaq 0x1c0(%rsp), %rdi
movq %r13, %rsi
callq 0x680c
movq 0x1f0(%rsp), %rdi
leaq 0x200(%rsp), %rax
cmpq %rax, %rdi
je 0x4945
movq 0x200(%rsp), %rsi
incq %rsi
callq 0x2180
incl %r14d
jmp 0x4a77
movl %r12d, %r14d
movq 0x18(%rsp), %r12
movl %ebx, %edi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
leaq 0x9f0(%rsp), %rcx
callq 0x297c
cmpl $-0x1, %eax
je 0x5ecd
movl %eax, %r14d
jmp 0x4a70
movb $0x1, 0x6821(%rip)      # 0xb1a5
jmp 0x498d
movb $0x1, 0x681f(%rip)      # 0xb1ac
incl %r12d
xorl %ebp, %ebp
movl %r12d, %r14d
jmp 0x4a72
subq $0x8, %rsp
movl %ebx, %edi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
leaq 0x6801(%rip), %rcx      # 0xb1b0
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0xa
callq 0x61d8
addq $0x10, %rsp
jmp 0x4a64
subq $0x8, %rsp
movl %ebx, %edi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
leaq 0x67cb(%rip), %rcx      # 0xb1a8
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x1
callq 0x61d8
addq $0x10, %rsp
jmp 0x4a64
xorpd %xmm0, %xmm0
movl %ebx, %edi
movq 0x10(%rsp), %rsi
movl %r12d, %edx
leaq 0x6768(%rip), %rcx      # 0xb170
movl $0x1, %r8d
movsd 0x25fa(%rip), %xmm1     # 0x7010
callq 0x6366
jmp 0x4a64
cmpb $0x0, 0x2(%r15)
je 0x4a3b
movq %r15, %rdi
leaq 0x3147(%rip), %rsi      # 0x7b75
callq 0x2230
testl %eax, %eax
jne 0x5e78
subq $0x8, %rsp
movl %ebx, %edi
movq 0x18(%rsp), %rsi
movl %r12d, %edx
leaq 0x6710(%rip), %rcx      # 0xb160
movl $0x1, %r8d
xorl %r9d, %r9d
pushq $0x4
callq 0x61d8
addq $0x10, %rsp
movl %eax, %r14d
cmpl $-0x1, %eax
je 0x5e9a
xorl %ebp, %ebp
movq 0x10(%rsp), %r12
cmpl %ebx, %r14d
jl 0x44d5
jmp 0x4ab3
movq %r15, %rdi
callq 0x20e0
cmpl $0x1, %eax
jg 0x5f00
incl %r14d
xorl %ebp, %ebp
jmp 0x4a77
callq 0x249d
jmp 0x4861
movq %r12, %rdi
callq 0x25fc
xorl %ebx, %ebx
jmp 0x5e9f
cmpb $0x1, 0x66eb(%rip)      # 0xb1a5
jne 0x4aca
cmpb $0x0, 0xbf0(%rsp)
je 0x5e95
movsd 0x669e(%rip), %xmm0     # 0xb170
movsd %xmm0, 0x168(%rsp)
cmpb $0x0, 0x9f0(%rsp)
movq 0x18(%rsp), %r13
je 0x4b96
leaq 0x2fd2(%rip), %rsi      # 0x7ac7
leaq 0x9f0(%rsp), %rdi
callq 0x21e0
testq %rax, %rax
je 0x5ed4
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x2c55
cmpl $-0x1, %eax
leaq 0x200(%rsp), %rbp
je 0x4b8e
leaq 0x1f0(%rsp), %r14
leaq 0x5f0(%rsp), %r15
leaq 0x1c0(%rsp), %r12
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x64f0
movq %r12, %rdi
movq %r14, %rsi
callq 0x680c
movq 0x1f0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4b79
movq 0x200(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
movq %r13, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x2c55
cmpl $-0x1, %eax
jne 0x4b43
movq %rbx, %rdi
callq 0x2160
cmpb $0x0, 0x3f0(%rsp)
je 0x4bff
leaq 0x302c(%rip), %rsi      # 0x7bd3
leaq 0x3f0(%rsp), %rdi
callq 0x21a0
testl %eax, %eax
je 0x4bff
leaq 0x301b(%rip), %rsi      # 0x7bda
leaq 0x3f0(%rsp), %rdi
callq 0x21e0
movq %rax, %rbx
testq %rax, %rax
jne 0x4c09
movq 0x63fd(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x2c27(%rip), %rsi      # 0x780c
leaq 0x2fee(%rip), %rcx      # 0x7bda
xorl %ebx, %ebx
leaq 0x3f0(%rsp), %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4c09
movq 0x63ba(%rip), %rax      # 0xafc0
movq (%rax), %rbx
movq %rbx, 0x78(%rsp)
cmpq $0x0, 0x1e8(%rsp)
je 0x4cd4
leaq 0x301c(%rip), %r10      # 0x7c40
leaq 0x3010(%rip), %r12      # 0x7c3b
leaq 0x3004(%rip), %r15      # 0x7c36
leaq 0x2ff8(%rip), %r14      # 0x7c31
leaq 0x2fea(%rip), %rbx      # 0x7c2a
leaq 0x2fdc(%rip), %r11      # 0x7c23
leaq 0x2f8e(%rip), %rsi      # 0x7bdc
leaq 0x2fb2(%rip), %rdx      # 0x7c07
leaq 0x2fb0(%rip), %rcx      # 0x7c0c
leaq 0x2fb2(%rip), %r8       # 0x7c15
leaq 0x2fb2(%rip), %r9       # 0x7c1c
movq 0x78(%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, 0xf(%rsp)
je 0x4cc7
leaq 0x2fb1(%rip), %rsi      # 0x7c47
leaq 0x2fca(%rip), %rdx      # 0x7c67
leaq 0x2fcb(%rip), %rcx      # 0x7c6f
leaq 0x2fca(%rip), %r8       # 0x7c75
leaq 0x2fc9(%rip), %r9       # 0x7c7b
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 0x649e(%rip), %ebp      # 0xb178
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x108(%rsp)
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x30(%rsp)
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x28(%rsp)
testq %rbp, %rbp
je 0x4d42
movq 0x108(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movq 0x30(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movq 0x28(%rsp), %rdi
movl $0x2d, %esi
movq %rbp, %rdx
callq 0x2100
movl $0x20, %edi
callq 0x2030
movq %rax, 0x58(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x70(%rsp)
movl $0x10, %edi
callq 0x2030
movq %rax, %rbx
movl $0x10, %edi
movq %rax, 0x118(%rsp)
callq 0x2030
movq %rax, %r14
movl $0x20, %edi
movq %rax, 0x68(%rsp)
callq 0x2030
movq %rax, %r15
movl $0x10, %edi
movq %rax, 0x170(%rsp)
callq 0x2030
movq %rax, %r12
movl $0x10, %edi
movq %rax, 0x80(%rsp)
callq 0x2030
movq %rax, %r13
movl $0x10, %edi
movq %rax, 0x110(%rsp)
callq 0x2030
movq %rax, 0x40(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x50(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, 0x60(%rsp)
movl $0x10, %edi
callq 0x2030
movq %rax, 0x48(%rsp)
movl $0x20, %edi
callq 0x2030
movq %rax, %rcx
xorpd %xmm0, %xmm0
movq 0x58(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x70(%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 0x40(%rsp), %rax
movupd %xmm0, (%rax)
movq 0x50(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x60(%rsp), %rax
movupd %xmm0, 0x10(%rax)
movupd %xmm0, (%rax)
movq 0x48(%rsp), %rax
movupd %xmm0, (%rax)
movupd %xmm0, 0x10(%rcx)
movq %rcx, 0x100(%rsp)
movupd %xmm0, (%rcx)
leaq (,%rbp,8), %r12
movq %r12, %rdi
callq 0x2030
movq %rax, %r15
movabsq $0x400000065, %rbx      # imm = 0x400000065
movq %rbx, 0x160(%rsp)
movl $0x328, %edi            # imm = 0x328
movq %rax, 0x38(%rsp)
callq 0x2030
movsd 0x168(%rsp), %xmm0
mulsd 0x214d(%rip), %xmm0     # 0x7020
movsd %xmm0, 0x168(%rsp)
movq %rax, 0x158(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0x158(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4ee7
movq %rbx, 0xf8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xf0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xf0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4f23
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 0x4f5f
movq %rbx, 0xe8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xe0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xe0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4f9b
movq %rbx, 0xd8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xd0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xd0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x4fd7
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 0x5013
movq %rbx, 0xc8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xc0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xc0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x504f
movq %rbx, 0xb8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xb0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xb0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x508b
movq %rbx, 0x130(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x128(%rsp)
xorl %r14d, %r14d
movl $0x20, %edi
callq 0x2030
movq 0x128(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x50c7
movq %rbx, 0xa8(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0xa0(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0xa0(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x5103
movq %rbx, 0x98(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x90(%rsp)
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x2030
movq 0x90(%rsp), %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
cmpq $0x65, %r14
jne 0x513f
movq %rbx, 0x180(%rsp)
movl $0x328, %edi            # imm = 0x328
callq 0x2030
movq %rax, 0x178(%rsp)
xorl %ebx, %ebx
movl $0x20, %edi
callq 0x2030
movq 0x178(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq $0x65, %rbx
jne 0x517a
testl %ebp, %ebp
je 0x51aa
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2100
movl $0x4, %edx
movl $0x65, %esi
movq 0x158(%rsp), %rax
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x51ea
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0x164(%rsp), %edx
cmpq %rdx, %rdi
jb 0x51cd
movl 0x160(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x51be
movl 0xf8(%rsp), %esi
testl %esi, %esi
je 0x5246
movq 0xf0(%rsp), %rax
movl 0xfc(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x523c
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xfc(%rsp), %edx
cmpq %rdx, %rdi
jb 0x521f
movl 0xf8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x5210
movl 0x150(%rsp), %ebx
testq %rbx, %rbx
je 0x5287
movl 0x154(%rsp), %r15d
movq 0x148(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x527f
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x526c
movl 0xe8(%rsp), %esi
testl %esi, %esi
je 0x52d9
movq 0xe0(%rsp), %rax
movl 0xec(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x52cf
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xec(%rsp), %edx
cmpq %rdx, %rdi
jb 0x52b2
movl 0xe8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x52a3
movl 0xd8(%rsp), %esi
testl %esi, %esi
je 0x532b
movq 0xd0(%rsp), %rax
movl 0xdc(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x5321
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xdc(%rsp), %edx
cmpq %rdx, %rdi
jb 0x5304
movl 0xd8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x52f5
movl 0x140(%rsp), %ebx
testq %rbx, %rbx
je 0x536c
movl 0x144(%rsp), %r15d
movq 0x138(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x5364
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x5351
movl 0xc8(%rsp), %esi
testl %esi, %esi
je 0x53be
movq 0xc0(%rsp), %rax
movl 0xcc(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x53b4
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xcc(%rsp), %edx
cmpq %rdx, %rdi
jb 0x5397
movl 0xc8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x5388
movl 0xb8(%rsp), %esi
testl %esi, %esi
je 0x5410
movq 0xb0(%rsp), %rax
movl 0xbc(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x5406
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xbc(%rsp), %edx
cmpq %rdx, %rdi
jb 0x53e9
movl 0xb8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x53da
movl 0x130(%rsp), %ebx
testq %rbx, %rbx
je 0x5451
movl 0x134(%rsp), %r15d
movq 0x128(%rsp), %r12
movq %r15, %r14
shlq $0x3, %r14
xorl %r13d, %r13d
testl %r15d, %r15d
je 0x5449
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
incq %r13
cmpq %r13, %rbx
jne 0x5436
movl 0xa8(%rsp), %esi
testl %esi, %esi
je 0x54a3
movq 0xa0(%rsp), %rax
movl 0xac(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x5499
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0xac(%rsp), %edx
cmpq %rdx, %rdi
jb 0x547c
movl 0xa8(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x546d
movl 0x98(%rsp), %esi
testl %esi, %esi
je 0x54f5
movq 0x90(%rsp), %rax
movl 0x9c(%rsp), %edx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %edx
je 0x54eb
movq (%rax,%rcx,8), %rsi
xorl %edi, %edi
movl $0x0, (%rsi,%rdi,4)
incq %rdi
movl 0x9c(%rsp), %edx
cmpq %rdx, %rdi
jb 0x54ce
movl 0x98(%rsp), %esi
incq %rcx
movl %esi, %edi
cmpq %rdi, %rcx
jb 0x54bf
movl 0x180(%rsp), %ebx
movq 0x178(%rsp), %rax
testq %rbx, %rbx
movq %rax, 0x198(%rsp)
je 0x5546
movl 0x184(%rsp), %r15d
movq %r15, %r14
shlq $0x3, %r14
xorl %r12d, %r12d
testl %r15d, %r15d
je 0x553e
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2100
movq 0x198(%rsp), %rax
incq %r12
cmpq %r12, %rbx
jne 0x5523
movq 0x158(%rsp), %r14
movq 0xf0(%rsp), %r15
movq 0x148(%rsp), %rax
movq %rax, 0x1b0(%rsp)
movq 0xe0(%rsp), %r13
movq 0xd0(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0xc0(%rsp), %r12
movq 0xb0(%rsp), %rbp
movq 0x128(%rsp), %rax
movq %rax, 0x1a8(%rsp)
movq 0xa0(%rsp), %rbx
movq 0x90(%rsp), %rax
movq %rax, 0x188(%rsp)
leaq 0x1f0(%rsp), %rdi
movq $0x0, 0x120(%rsp)
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
leaq 0x5f0(%rsp), %rdi
movl $0x1f5, %edx            # imm = 0x1F5
xorl %esi, %esi
callq 0x2100
movq 0x1d8(%rsp), %rcx
leaq 0x1c8(%rsp), %rax
cmpq %rax, %rcx
je 0x5a0e
movq $0x0, 0x120(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x20(%rcx), %rsi
movl $0x1f3, %edx            # imm = 0x1F3
leaq 0x7f0(%rsp), %rdi
callq 0x2130
movb $0x0, 0x9e3(%rsp)
leaq 0x7f0(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x28fb
movl 0x5b42(%rip), %r9d      # 0xb1a8
movl 0x8c(%rsp), %eax
subq $0x8, %rsp
leaq 0x7f8(%rsp), %rdi
movq 0x110(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %r8
pushq %rax
callq 0x2e3a
addq $0x10, %rsp
cmpb $0x1, 0x5b0b(%rip)      # 0xb1ac
movq %rax, 0x10(%rsp)
jne 0x56bf
movl 0x5b02(%rip), %edx      # 0xb1b0
movq 0x28(%rsp), %rdi
movl %eax, %esi
callq 0x3393
movq 0x10(%rsp), %rax
cmpb $0x1, 0x5adf(%rip)      # 0xb1a5
jne 0x5736
leaq 0x5f0(%rsp), %rdi
leaq 0x25aa(%rip), %rsi      # 0x7c81
leaq 0xbf0(%rsp), %rdx
leaq 0x1f0(%rsp), %rcx
xorl %eax, %eax
callq 0x2090
movl 0x5ab4(%rip), %edx      # 0xb1a8
leaq 0x5f0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x3582
movq 0x10(%rsp), %rax
testl %eax, %eax
movsd 0x18fb(%rip), %xmm1     # 0x7010
movq 0x38(%rsp), %rdx
jle 0x5736
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 0x5720
subq $0x8, %rsp
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl %eax, %edx
movq 0x88(%rsp), %r8
movq 0x78(%rsp), %r9
pushq $0x3
callq 0x37ae
movq 0x20(%rsp), %r11
addq $0x10, %rsp
movq 0x70(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x189b(%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 0x80(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
movq 0x78(%rsp), %rdi
leaq 0x24d6(%rip), %rsi      # 0x7c8b
leaq 0x1f0(%rsp), %rdx
movb $0x4, %al
pushq %r11
pushq %r10
callq 0x2240
addq $0x10, %rsp
testb $0x1, 0xf(%rsp)
je 0x585c
subq $0x8, %rsp
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x120(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x60(%rsp), %r9
pushq $0x3
callq 0x3fdb
addq $0x10, %rsp
movq 0x58(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x17f7(%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 0x68(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
movq 0x78(%rsp), %rdi
leaq 0x246c(%rip), %rsi      # 0x7cc1
movb $0x4, %al
callq 0x2240
movl $0xa, %edi
movq 0x78(%rsp), %rsi
callq 0x2200
cmpb $0x1, 0x5933(%rip)      # 0xb1a5
jne 0x5945
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r14, %r8
movq %r15, %r9
movsd 0x168(%rsp), %xmm0
movl $0x3, %eax
pushq %rax
pushq 0x1b8(%rsp)
callq 0x40b6
addq $0x10, %rsp
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r12, %r8
movq %rbp, %r9
movl $0x3, %eax
pushq %rax
pushq 0x1b0(%rsp)
callq 0x4283
movq 0x198(%rsp), %r8
movq 0x1a0(%rsp), %rdi
addq $0x10, %rsp
xorl %eax, %eax
xorl %ecx, %ecx
movq (%r14,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%r13,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%r15,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%rdi,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%r12,%rcx), %rdx
movl (%rdx,%rax,4), %edx
movq (%rbx,%rcx), %rsi
addl %edx, (%rsi,%rax,4)
movq (%rbp,%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 0x58f5
incq %rax
cmpq $0x4, %rax
jne 0x58f3
xorl %eax, %eax
movq 0x118(%rsp), %rcx
movq 0x68(%rsp), %rdx
movq 0x170(%rsp), %rsi
movq 0x80(%rsp), %rdi
movq 0x110(%rsp), %r8
movq 0x40(%rsp), %r9
movq 0x60(%rsp), %r10
movq 0x48(%rsp), %r11
movupd (%rsi,%rax,2), %xmm0
movupd (%r10,%rax,2), %xmm1
addpd %xmm0, %xmm1
movupd %xmm1, (%r10,%rax,2)
movq (%rdi,%rax), %xmm0
movq (%r11,%rax), %xmm1
paddd %xmm0, %xmm1
movq %xmm1, (%r11,%rax)
movq (%rcx,%rax), %xmm0
movq (%r8,%rax), %xmm1
paddd %xmm0, %xmm1
movq %xmm1, (%r8,%rax)
movq (%rdx,%rax), %xmm0
movq (%r9,%rax), %xmm1
paddd %xmm0, %xmm1
movq %xmm1, (%r9,%rax)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x597b
movq 0x120(%rsp), %rax
addl 0x10(%rsp), %eax
movq %rax, 0x120(%rsp)
movq 0x1b8(%rsp), %rdi
callq 0x21d0
movq %rax, %rcx
leaq 0x1c8(%rsp), %rax
cmpq %rax, %rcx
jne 0x561f
xorl %eax, %eax
movapd 0x1658(%rip), %xmm0     # 0x7070
movq 0x110(%rsp), %r9
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rdx
movq 0x60(%rsp), %rsi
movq 0x48(%rsp), %rdi
movq 0x100(%rsp), %r8
cvtdq2pd (%rdi,%rax), %xmm1
movupd (%rsi,%rax,2), %xmm2
addpd %xmm0, %xmm1
divpd %xmm1, %xmm2
movupd %xmm2, (%r8,%rax,2)
cvtdq2pd (%r9,%rax), %xmm1
cvtdq2pd (%rcx,%rax), %xmm2
addpd %xmm0, %xmm2
divpd %xmm2, %xmm1
movupd %xmm1, (%rdx,%rax,2)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x5a3c
cmpb $0x1, 0x5728(%rip)      # 0xb1a5
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %r12
movq 0x1a0(%rsp), %rdi
movq 0x188(%rsp), %rbp
jne 0x5c2c
xorl %eax, %eax
movsd 0x155b(%rip), %xmm2     # 0x7008
xorl %ecx, %ecx
movq (%r13,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq (%r12,%rcx), %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%rdi,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
movq (%rbx,%rcx), %rdx
xorps %xmm0, %xmm0
cvtsi2sdl (%rdx,%rax,4), %xmm0
movq (%rbp,%rcx), %rdx
xorps %xmm1, %xmm1
cvtsi2sdl (%rdx,%rax,4), %xmm1
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movq (%rsi,%rcx), %rdx
movsd %xmm0, (%rdx,%rax,8)
addq $0x8, %rcx
cmpq $0x328, %rcx            # imm = 0x328
jne 0x5aaf
incq %rax
cmpq $0x4, %rax
jne 0x5aad
movq 0x54a0(%rip), %r15      # 0xafc0
movq %rdi, %rbx
movq (%r15), %rdi
movsd 0x5642(%rip), %xmm0     # 0xb170
movq %rsi, %r13
leaq 0x21b1(%rip), %rsi      # 0x7ce9
movb $0x1, %al
callq 0x2240
movq (%r15), %rdi
leaq 0x21b1(%rip), %rsi      # 0x7cfa
leaq 0x21b9(%rip), %rdx      # 0x7d09
leaq 0x21b6(%rip), %rcx      # 0x7d0d
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2240
movq (%r15), %rdi
subq $0x8, %rsp
leaq 0x21cf(%rip), %r9       # 0x7d3e
leaq 0x21c9(%rip), %r8       # 0x7d3f
leaq 0x1f57(%rip), %rcx      # 0x7ad4
leaq 0x2194(%rip), %rsi      # 0x7d18
leaq 0x21ae(%rip), %rdx      # 0x7d39
xorl %eax, %eax
pushq %r9
pushq %r8
pushq %rcx
callq 0x2240
addq $0x20, %rsp
leaq 0x21a4(%rip), %r15      # 0x7d46
movq (%r12,%r14,8), %rax
movl 0xc(%rax), %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
movq (%rbp), %rax
xorps %xmm0, %xmm0
cvtsi2sdl 0xc(%rax), %xmm0
addsd 0x1444(%rip), %xmm0     # 0x7008
divsd %xmm0, %xmm1
movsd 0x1440(%rip), %xmm4     # 0x7010
mulsd %xmm4, %xmm1
movq (%rbp,%r14,8), %rax
movl 0xc(%rax), %r8d
xorps %xmm3, %xmm3
cvtsi2sd %r8d, %xmm3
divsd %xmm0, %xmm3
mulsd %xmm4, %xmm3
movq 0x53cc(%rip), %rax      # 0xafc0
movq (%rax), %rdi
movq (%rbx,%r14,8), %rax
movsd 0x18(%rax), %xmm0
mulsd %xmm4, %xmm0
movq (%r13,%r14,8), %rax
movsd 0x18(%rax), %xmm2
mulsd %xmm4, %xmm2
movq %r15, %rsi
movl %r14d, %edx
movb $0x4, %al
callq 0x2240
incq %r14
cmpq $0x65, %r14
jne 0x5ba2
movq 0x100(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x13cf(%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 0x48(%rsp), %rax
movl 0xc(%rax), %ecx
movl (%rax), %r8d
movl 0x4(%rax), %r9d
movl 0x8(%rax), %r10d
leaq 0x20f5(%rip), %rsi      # 0x7d6e
leaq 0x2121(%rip), %rdx      # 0x7da1
movq 0x78(%rsp), %r13
movq %r13, %rdi
movb $0x4, %al
pushq 0x120(%rsp)
pushq %r10
callq 0x2240
addq $0x10, %rsp
testb $0x1, 0xf(%rsp)
je 0x5cf2
movq 0x50(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd 0x135b(%rip), %xmm3     # 0x7010
mulsd %xmm3, %xmm0
movsd (%rax), %xmm1
mulsd %xmm3, %xmm1
movsd 0x8(%rax), %xmm2
mulsd %xmm3, %xmm2
mulsd 0x10(%rax), %xmm3
movq 0x40(%rsp), %rax
movl 0xc(%rax), %edx
movl (%rax), %ecx
movl 0x4(%rax), %r8d
movl 0x8(%rax), %r9d
leaq 0x1fd9(%rip), %rsi      # 0x7cc1
movq %r13, %rdi
movb $0x4, %al
callq 0x2240
movl $0xa, %edi
movq %r13, %rsi
callq 0x2200
testq %r13, %r13
movq 0x118(%rsp), %rbx
movq 0x68(%rsp), %r14
movq 0x170(%rsp), %r15
movq 0x18(%rsp), %r12
je 0x5d32
movq 0x529b(%rip), %rax      # 0xafc0
cmpq (%rax), %r13
je 0x5d32
movq %r13, %rdi
callq 0x2160
leaq 0x178(%rsp), %rdi
callq 0x652e
leaq 0x90(%rsp), %rdi
callq 0x6578
leaq 0xa0(%rsp), %rdi
callq 0x6578
leaq 0x128(%rsp), %rdi
callq 0x652e
leaq 0xb0(%rsp), %rdi
callq 0x6578
leaq 0xc0(%rsp), %rdi
callq 0x6578
leaq 0x138(%rsp), %rdi
callq 0x652e
leaq 0xd0(%rsp), %rdi
callq 0x6578
leaq 0xe0(%rsp), %rdi
callq 0x6578
leaq 0x148(%rsp), %rdi
callq 0x652e
leaq 0xf0(%rsp), %rdi
callq 0x6578
leaq 0x158(%rsp), %rdi
callq 0x6578
movq 0x38(%rsp), %rdi
callq 0x2220
movq 0x100(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x60(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x110(%rsp), %rdi
callq 0x2220
movq 0x80(%rsp), %rdi
callq 0x2220
movq %r15, %rdi
callq 0x2220
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x2220
movq 0x70(%rsp), %rdi
callq 0x2220
movq 0x58(%rsp), %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2220
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x108(%rsp), %rdi
callq 0x2220
xorl %ebx, %ebx
jmp 0x5ea4
movq 0x5159(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x1cf5(%rip), %rsi      # 0x7b7e
movq %r15, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x5e9a
callq 0x24bf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x2220
leaq 0x1c0(%rsp), %rdi
callq 0x6626
movl %ebx, %eax
addq $0xde8, %rsp            # imm = 0xDE8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5ea4
movq 0x50fd(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x1927(%rip), %rsi      # 0x780c
leaq 0x1bdb(%rip), %rcx      # 0x7ac7
leaq 0x9f0(%rsp), %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4b96
callq 0x247d
jmp 0x5e9a
jmp 0x6017
jmp 0x601c
jmp 0x6021
jmp 0x6026
jmp 0x602b
jmp 0x6030
jmp 0x6038
jmp 0x6040
jmp 0x6048
jmp 0x6050
jmp 0x6058
jmp 0x6060
movq %rax, %rbx
jmp 0x6111
movq %rax, %rbx
jmp 0x611e
movq %rax, %rbx
jmp 0x6128
movq %rax, %rbx
jmp 0x6132
movq %rax, %rbx
jmp 0x613c
movq %rax, %rbx
jmp 0x6146
movq %rax, %rbx
jmp 0x6153
movq %rax, %rbx
jmp 0x6160
movq %rax, %rbx
jmp 0x616d
movq %rax, %rbx
jmp 0x6177
movq %rax, %rbx
jmp 0x6184
movq %rax, %rbx
jmp 0x618e
movq %rax, %rbx
jmp 0x6198
movq %rax, %rbx
jmp 0x61a2
movq %rax, %rbx
jmp 0x61ac
jmp 0x600f
movq %rax, %rbx
movq 0x1f0(%rsp), %rdi
leaq 0x200(%rsp), %rax
cmpq %rax, %rdi
jne 0x5ffa
jmp 0x61b9
jmp 0x600f
movq %rax, %rbx
jmp 0x61c3
jmp 0x600f
movq %rax, %rbx
movq 0x1f0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x61b9
movq 0x200(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x61b9
movq %rax, %rbx
jmp 0x61b9
movq %rax, %rbx
jmp 0x6078
movq %rax, %rbx
jmp 0x6085
movq %rax, %rbx
jmp 0x6092
movq %rax, %rbx
jmp 0x609f
movq %rax, %rbx
jmp 0x60ac
movq %rax, %rbx
jmp 0x60b9
movq %rax, %rbx
jmp 0x60c6
movq %rax, %rbx
jmp 0x60d3
movq %rax, %rbx
jmp 0x60e0
movq %rax, %rbx
jmp 0x60ed
movq %rax, %rbx
jmp 0x60fa
movq %rax, %rbx
jmp 0x6107
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0x652e
leaq 0x90(%rsp), %rdi
callq 0x6578
leaq 0xa0(%rsp), %rdi
callq 0x6578
leaq 0x128(%rsp), %rdi
callq 0x652e
leaq 0xb0(%rsp), %rdi
callq 0x6578
leaq 0xc0(%rsp), %rdi
callq 0x6578
leaq 0x138(%rsp), %rdi
callq 0x652e
leaq 0xd0(%rsp), %rdi
callq 0x6578
leaq 0xe0(%rsp), %rdi
callq 0x6578
leaq 0x148(%rsp), %rdi
callq 0x652e
leaq 0xf0(%rsp), %rdi
callq 0x6578
leaq 0x158(%rsp), %rdi
callq 0x6578
movq 0x38(%rsp), %rdi
callq 0x2220
movq 0x100(%rsp), %rdi
callq 0x2220
movq 0x48(%rsp), %rdi
callq 0x2220
movq 0x60(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x110(%rsp), %rdi
callq 0x2220
movq 0x80(%rsp), %rdi
callq 0x2220
movq 0x170(%rsp), %rdi
callq 0x2220
movq 0x68(%rsp), %rdi
callq 0x2220
movq 0x118(%rsp), %rdi
callq 0x2220
movq 0x70(%rsp), %rdi
callq 0x2220
movq 0x58(%rsp), %rdi
callq 0x2220
movq 0x28(%rsp), %rdi
callq 0x2220
movq 0x30(%rsp), %rdi
callq 0x2220
movq 0x108(%rsp), %rdi
callq 0x2220
movq 0x18(%rsp), %rdi
callq 0x2220
leaq 0x1c0(%rsp), %rdi
callq 0x6626
movq %rbx, %rdi
callq 0x2270