// File: /workspace/github_cpp_makefile_star2_O3/gulamf[P]NRF24LE1Flash/main.cpp
// Function: ProgramUC()
bool ProgramUC()
{
    string debugInfo = "";
    vector<HexRecord> *hexRecords;
    BLCommandReturnType blCommandReturnVal;
    uint8_t readData[512] ;
    bool pageErased[31];
    bool dataInPage[31];
    uint8_t ucFlash [0x4000];
    uint8_t jumpInstruction[] = {0x02, 0x3E, 0x00};

    ucFlash[0] = jumpInstruction[0];
    ucFlash[1] = jumpInstruction[1];
    ucFlash[2] = jumpInstruction[2];

    #if DEBUG_MSG_BOX_ENABLED
    outputString = "";
    #endif


    cout << "Initiating program/verify sequence...\r\n";

    if (resetpin == blenabled)
    {
        cout << "Reset and bootloader enable pins cannot be the same!";
        return false;
    }

    cout << "Parsing hex file...\r\n";

    //begin parse hex file
    hexRecords = HexUtils::ParseHexFile(hexfile, debugInfo);

    //If hexRecords is null, then the file could not be found
    if (hexRecords == NULL)
    {
        cout << "Could not open hex file!";
        return false;
    }

    for (unsigned int  x = 0; x < sizeof(pageErased); x++)
    {
        pageErased[x] = false;
        dataInPage[x] = false;
    }

    for (unsigned int x = 0; x < sizeof(ucFlash); x++)
    {
        ucFlash[x] = 0xFF;
    }

    //Loop through each of the individual hex records to build the complete flash image
    for (unsigned int x = 0; x < hexRecords->size(); x++)
    {
        HexRecord curHexRecord = (HexRecord)hexRecords->at((int)x);

        //If an address is found that is in the bootloader's address space, then throw an error
        if ((curHexRecord.address + curHexRecord.len) >= 0x3E00)
        {
            cout << "Attempting to program address in bootloader's address space (0x3E00 through 0x3FFF)!";
            return false;
        }

        //Loop through the data in the hex record to build the flash image
        for (unsigned int y = 0; y < curHexRecord.len; y++)
        {
            uint8_t curPage = (uint8_t)((curHexRecord.address + y) / 512);

            uint8_t data = curHexRecord.data[y];
            int addr = curHexRecord.address;
            ucFlash[ addr + y] = data;

            if (!dataInPage[curPage] && (ucFlash[curHexRecord.address + y] != 0xFF))
                dataInPage[curPage] = true;
        }
    }
    //end parse hex file

    cout << "Parsing hex file complete!\r\n";
    cout << "Programming device flash...\r\n";

    //begin start bootloader
    blCommandReturnVal = ExecuteCommandStartBootloader();

    if (blCommandReturnVal == BLCommandReturnType_SerialPortFailure)
    {
        cout << "Could not open COM port!";
        return false;
    }
    else if (blCommandReturnVal != BLCommandReturnType_OK)
    {
        cout << "Device not connected!\n";
        return false;
    }
    //end start	bootloader

    //begin device id check
    uint16_t devId = 0;

    blCommandReturnVal = ExecuteCommandGetDevID(&devId);

    if (blCommandReturnVal != BLCommandReturnType_OK)
    {
        cout << "Lost communications with device!";
        return false;
    }
    //end device id check

    //begin bootloader version check
    uint8_t blVersion = 0;

    blCommandReturnVal = ExecuteCommandGetBLVersion(&blVersion);

    if (blCommandReturnVal != BLCommandReturnType_OK)
    {
        cout << "Lost communications with device!";
        return false;
    }
    //end device id check

    cout << ConvertBLDevIDToString(devId);

    //begin write hex file data
    for (uint8_t curPage = 0; curPage < 31; curPage++)
    {
        unsigned int writeStartAddress = 0;
        unsigned int writeEndAddress = 0;
        unsigned int curPageStartAddress = (unsigned int )curPage * 512;
        unsigned int curPageEndAddress = curPageStartAddress + 512 - 1;
        unsigned int curRWAddress = 0;

        //If there is data in the page, then we will do some writing
        if (dataInPage[curPage])
        {
            //Page 0 is a special case because it contains the jump to bootloader code
            if (curPage == 0)
            {
                //Erase page 0 here
                if (ExecuteCommandErasePage(0) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Mark page erased
                pageErased[0] = true;

                //Set the RW address so we can write the jump instruction
                if (ExecuteCommandSetRWAddress(0) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Update our shadow copy of the chip's RW address
                curRWAddress = 0;

                //Write the jump instruction
                if (ExecuteCommandWrite(jumpInstruction, 0, 3) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Update our shadow copy of the chip's RW address
                curRWAddress += 3;

                //Set the user main address that lived in the jump instruction of the user's hex file (bytes 1 (MSB) and 2 (LSB))
                if (ExecuteCommandSetUsrMainAddress((uint16_t)(ucFlash[1] << 8) + ucFlash[2]) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Since we've already written the first 3 bytes in the page, update the start address for the rest of the page accordingly
                writeStartAddress = 3;
            }
            else
            {
                //Erase the page if it hasn't been erased
                if (!pageErased[curPage])
                {
                    if (ExecuteCommandErasePage(curPage) != BLCommandReturnType_OK)
                    {
                        cout << "Lost communications with device!";
                        return false;
                    }

                    pageErased[curPage] = true;
                }

                //We haven't written any data, so the start address is just the first address of the page
                writeStartAddress = curPageStartAddress;
            }

            //Loop through this page
            while (writeStartAddress <= curPageEndAddress)
            {
                //Check to see if the current byte is 0xFF or not (FLASH erases to 0xFF, so we do not have to write that value)
                if (ucFlash[writeStartAddress] != 0xFF)
                {
                    uint endFFhCount = 0; //Counter for number of 0xFF values seen after the last non-0xFF value

                    //We have found a non-0xFF value, so now we will try to find where we will end this write operation
                    writeEndAddress = writeStartAddress;

                    //curViewingAddress is the address we're inspecting to see if we want to write the value or not
                    uint curViewingAddress = writeEndAddress + 1;

                    //Check if curViewingAddress is within the current page boundary
                    while (curViewingAddress <= curPageEndAddress)
                    {
                        //We're in the current page boundary, so check if the next value in the flash image is non-0xFF
                        if (ucFlash[writeEndAddress + 1] != 0xFF)
                        {
                            //The next value is non-0xFF, so set writeEndAddress to curViewingAddress and zero out endFFhCount
                            writeEndAddress = curViewingAddress;
                            endFFhCount = 0;
                        }
                        else
                        {
                            //The next value is 0xFF, so increment endFFhCount
                            endFFhCount++;

                            //We have to write at least 8 0xFF values before it makes sense to break a single write into two
                            if (endFFhCount >= 8)
                            {
                                //We are on our 8th 0xFF, so we will break this write
                                break;
                            }
                        }

                        //curViewingAddress is always one location ahead of writeEndAddress plus endFFhCount
                        curViewingAddress = writeEndAddress + endFFhCount + 1;
                    }

                    //Update the chip's RW address if it isn't equal to writeStartAddress
                    if (curRWAddress != writeStartAddress)
                    {
                        if (ExecuteCommandSetRWAddress((uint16_t)writeStartAddress) != BLCommandReturnType_OK)
                        {
                            cout << "Lost communications with device!";
                            return false;
                        }
                    }

                    //Update our shadow copy of the chip's RW address
                    curRWAddress = writeStartAddress;

                    //Write the curent block to the chip
                    uint numBytesToWrite = writeEndAddress - writeStartAddress + 1;

                    if (ExecuteCommandWrite(ucFlash, (uint16_t)curRWAddress, (uint16_t)numBytesToWrite) != BLCommandReturnType_OK)
                    {
                        cout << "Lost communications with device!";
                        return false;
                    }

                    //Update shadow copy of chip's RW address
                    curRWAddress += numBytesToWrite;

                    //Update writeStartAddress
                    writeStartAddress = writeEndAddress + 1;
                }
                else
                {
                    //The value was 0xFF, so look at the next value to try to start the write
                    writeStartAddress++;
                }
            }
        }
        else
        {
            //There is no data in the page, so erase it if it hasn't already been erased
            if (!pageErased[curPage])
            {
                //Erase current page
                if (ExecuteCommandErasePage(curPage) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Mark page erased
                pageErased[curPage] = true;
            }
        }
        //Update the progress bar
        //cout << (((curPage + 1) * 100) / 32) << "% complete\n";
    }
    //end write hex file data

    cout << "Programming device flash complete!\r\n";
    cout << "Verifying device flash...\r\n";

    //begin verify hex file data
    for (uint8_t curPage = 0; curPage < 31; curPage++)
    {
        uint readStartAddress = 0;
        uint readEndAddress = 0;
        uint curPageStartAddress = (uint)curPage * 512;
        uint curPageEndAddress = curPageStartAddress + 512 - 1;
        uint curRWAddress = 0;
        uint userMainJumpInstLoc = 0x3E09;

        //If there is data in the page, then we will do some writing
        if (dataInPage[curPage])
        {
            //Page 0 is a special case because it contains the jump to user code
            if (curPage == 0)
            {
                //Set the RW address so we can read the jump to user main instruction
                if (ExecuteCommandSetRWAddress((uint16_t)userMainJumpInstLoc) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                curRWAddress = userMainJumpInstLoc;

                //Read the jump to user main instruction from the chip
                if (ExecuteCommandRead(readData, 0, 3) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Update our shadow copy of the chip's RW address
                curRWAddress += 3;

                //Verify jump to user main instruction
                if ((readData[0] != 0x02) || (readData[1] != ucFlash[1]) || (readData[2] != ucFlash[2]))
                {
                    cout << "Programming error in jump to user main instruction starting at 0x" + ToHexString(userMainJumpInstLoc) + ": expected [0x02 0x" + ToHexString(ucFlash[1]) + " 0x" + ToHexString(ucFlash[2]) + "], zzbut received [0x" + ToHexString(readData[0]) + " 0x" + ToHexString(readData[1])+ " 0x" + ToHexString(readData[2]) + "]!";
                    return false;
                }

                //Set the RW address so we can read the jump to bootloader instruction
                if (ExecuteCommandSetRWAddress(0) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Update our shadow copy of the chip's RW address
                curRWAddress = 0;

                //Read the jump instruction
                if (ExecuteCommandRead(readData, 0, 3) != BLCommandReturnType_OK)
                {
                    cout << "Lost communications with device!";
                    return false;
                }

                //Update our shadow copy of the chip's RW address
                curRWAddress += 3;

                //Verify jump to bootloader instruction
                if ((readData[0] != jumpInstruction[0]) || (readData[1] != jumpInstruction[1]) || (readData[2] != jumpInstruction[2]))
                {
                    cout << "Programming error in jump to bootloader instruction starting at 0x0000: expected [0x" + ToHexString(jumpInstruction[0]) + " 0x" + ToHexString(jumpInstruction[1]) + " 0x" + ToHexString(jumpInstruction[2]) + "], xxbut received [0x" + ToHexString(readData[0]) + " 0x" + ToHexString(readData[1]) + " 0x" + ToHexString(readData[2]) + "]!";
                    return false;
                }

                //Since we've already read the first 3 bytes in the page, update the start address for the rest of the page accordingly
                readStartAddress = 3;
            }
            else
            {
                //We haven't read any data, so the start address is just the first address of the page
                readStartAddress = curPageStartAddress;
            }

            //Loop through this page
            while (readStartAddress <= curPageEndAddress)
            {
                //Check to see if the current byte is 0xFF or not (FLASH erases to 0xFF, so we do not have to read that value since it automatically matches)
                if (ucFlash[readStartAddress] != 0xFF)
                {
                    uint endFFhCount = 0; //Counter for number of 0xFF values seen after the last non-0xFF value

                    //We have found a non-0xFF value, so now we will try to find where we will end this read operation
                    readEndAddress = readStartAddress;

                    //curViewingAddress is the address we're inspecting to see if we want to read the value or not
                    uint curViewingAddress = readEndAddress + 1;

                    //Check if curViewingAddress is within the current page boundary
                    while (curViewingAddress <= curPageEndAddress)
                    {
                        //We're in the current page boundary, so check if the next value in the flash image is non-0xFF
                        if (ucFlash[readEndAddress + 1] != 0xFF)
                        {
                            //The next value is non-0xFF, so set readEndAddress to curViewingAddress and zero out endFFhCount
                            readEndAddress = curViewingAddress;
                            endFFhCount = 0;
                        }
                        else
                        {
                            //The next value is 0xFF, so increment endFFhCount
                            endFFhCount++;

                            //We have to read at least 8 0xFF values before it makes sense to break a single read into two
                            if (endFFhCount >= 8)
                            {
                                //We are on our 8th 0xFF, so we will break this read
                                break;
                            }
                        }

                        //curViewingAddress is always one location ahead of readEndAddress plus endFFhCount
                        curViewingAddress = readEndAddress + endFFhCount + 1;
                    }

                    //Update the chip's RW address if it isn't equal to readStartAddress
                    if (curRWAddress != readStartAddress)
                    {
                        if (ExecuteCommandSetRWAddress((uint16_t)(readStartAddress)) != BLCommandReturnType_OK)
                        {
                            cout << "Lost communications with device!";
                            return false;
                        }
                    }

                    //Update our shadow copy of the chip's RW address
                    curRWAddress = readStartAddress;

                    //Read the curent block to the chip
                    uint numBytesToRead = readEndAddress - readStartAddress + 1;


                    if (ExecuteCommandRead(readData, readStartAddress, (uint16_t)numBytesToRead) != BLCommandReturnType_OK)
                    {
                        cout << "Lost communications with device!";
                        return false;
                    }

                    //Verify read data
                    for (unsigned int x = 0; x < numBytesToRead; x++)
                    {
                        //Check the current byte against the flash image
                        if (readData[readStartAddress + x] != ucFlash[curRWAddress])
                        {
                            cout << "Programming error at address 0x";
                            cout << ToHexString(curRWAddress);
                            cout << ": expected 0x";
                            cout << ToHexString(ucFlash[curRWAddress]);
                            cout << " but received 0x";
                            cout << ToHexString(readData[x])+ "!";
                            return false;
                        }

                        //Increment shadow copy of chip's RW address
                        curRWAddress++;
                    }

                    //Update readStartAddress
                    readStartAddress = readEndAddress + 1;
                }
                else
                {
                    //The value was 0xFF, so look at the next value to try to start the write
                    readStartAddress++;
                }
            }
        }
        //Update the progress bar
        //cout << (((curPage + 1) * 100) / 32) << "% complete\n";
    }
    //end verify hex file data


    //begin exit bootloader
    if (ExecuteCommandExitBootloader() != BLCommandReturnType_OK)
    {
        cout << "Lost communications with device!";
        return false;
    }
    //end exit bootloader

    cout << "Verifying device flash complete!\r\n";
    cout << "Program/verify sequence completed successfully!\n";

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x44f8, %rsp           # imm = 0x44F8
leaq -0x2b0(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x38e4(%rip), %rdx      # 0x7a51
leaq -0x2c0(%rbp), %rdi
movq %rdx, %rsi
callq 0x5e0a
movq 0x5e55(%rip), %rdi      # 0x9fd8
leaq 0x33e2(%rip), %rsi      # 0x756c
movl $0x27, %edx
callq 0x2270
movl 0x6062(%rip), %eax      # 0xa1fc
cmpl 0x6170(%rip), %eax      # 0xa310
jne 0x41b3
movl $0x34, %edx
leaq 0x33e6(%rip), %rsi      # 0x7594
jmp 0x443e
movq 0x5e1e(%rip), %rdi      # 0x9fd8
leaq 0x3408(%rip), %rsi      # 0x75c9
movl $0x15, %edx
callq 0x2270
leaq -0x2f0(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x60f3(%rip), %rsi      # 0xa2d0
movq 0x60f4(%rip), %rdx      # 0xa2d8
addq %rsi, %rdx
leaq -0x300(%rbp), %rdi
callq 0x5d6c
leaq -0x300(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x5ece
movq %rax, %r12
movq -0x300(%rbp), %rdi
cmpq %rbx, %rdi
je 0x4224
movq -0x2f0(%rbp), %rsi
incq %rsi
callq 0x2220
movl $0x18, %edx
testq %r12, %r12
je 0x43fd
xorps %xmm0, %xmm0
movups %xmm0, -0x2d1(%rbp)
movaps %xmm0, -0x2e0(%rbp)
movaps %xmm0, -0x320(%rbp)
movups %xmm0, -0x311(%rbp)
leaq -0x4520(%rbp), %rdi
movl $0x4000, %edx           # imm = 0x4000
movl $0xff, %esi
callq 0x2150
movq (%r12), %rbx
movq 0x8(%r12), %rdx
cmpq %rbx, %rdx
je 0x43b1
leaq -0x58(%rbp), %r13
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
movq %r12, -0x30(%rbp)
movslq %r15d, %rsi
subq %rbx, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x553d
imulq $0x38, %rsi, %r14
movq %r13, -0x68(%rbp)
movq (%rbx,%r14), %rsi
movq 0x8(%rbx,%r14), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x5d6c
addq %r14, %rbx
movl 0x30(%rbx), %eax
movl %eax, 0x20(%r13)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x10(%r13)
movzwl -0x46(%rbp), %r14d
movzwl -0x48(%rbp), %r12d
leal (%r12,%r14), %ebx
cmpl $0x3dff, %ebx           # imm = 0x3DFF
ja 0x4343
testq %r12, %r12
je 0x435b
movq -0x40(%rbp), %r13
leaq (%r14,%rbp), %rdi
addq $-0x4520, %rdi          # imm = 0xBAE0
movq %r13, %rsi
movq %r12, %rdx
callq 0x21b0
xorl %eax, %eax
leal (%r14,%rax), %ecx
shrl $0x9, %ecx
movzbl %cl, %ecx
cmpb $-0x1, (%r13,%rax)
movzbl -0x320(%rbp,%rcx), %edx
movl $0x1, %esi
cmovel %edx, %esi
testb %dl, %dl
cmovnel %edx, %esi
movb %sil, -0x320(%rbp,%rcx)
incq %rax
cmpq %rax, %r12
jne 0x430c
jmp 0x435b
movl $0x54, %edx
movq 0x5c89(%rip), %rdi      # 0x9fd8
leaq 0x32a2(%rip), %rsi      # 0x75f8
callq 0x2270
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %r13
cmpq %r13, %rdi
je 0x4374
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
cmpl $0x3e00, %ebx           # imm = 0x3E00
movq -0x30(%rbp), %r12
jae 0x444a
incl %r15d
movq (%r12), %rbx
movq 0x8(%r12), %rdx
movq %rdx, %rax
subq %rbx, %rax
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
cmpq %r15, %rax
ja 0x428e
movq 0x5c20(%rip), %rdi      # 0x9fd8
leaq 0x328e(%rip), %rsi      # 0x764d
movl $0x1c, %edx
callq 0x2270
movq 0x5c08(%rip), %rdi      # 0x9fd8
leaq 0x3293(%rip), %rsi      # 0x766a
movl $0x1d, %edx
callq 0x2270
callq 0x39b6
testl %eax, %eax
je 0x4406
cmpl $0x3, %eax
jne 0x4432
leaq 0x3292(%rip), %rsi      # 0x7688
movl $0x18, %edx
jmp 0x443e
leaq 0x31db(%rip), %rsi      # 0x75df
jmp 0x443e
leaq -0x6a(%rbp), %rdi
movw $0x0, (%rdi)
callq 0x3a0b
testl %eax, %eax
je 0x4482
movq 0x5bb9(%rip), %rdi      # 0x9fd8
leaq 0x327b(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movl $0x16, %edx
leaq 0x30e3(%rip), %rsi      # 0x7521
movq 0x5b93(%rip), %rdi      # 0x9fd8
callq 0x2270
xorl %ebx, %ebx
movq -0x2c0(%rbp), %rdi
leaq -0x2b0(%rbp), %rax
cmpq %rax, %rdi
je 0x446e
movq -0x2b0(%rbp), %rsi
incq %rsi
callq 0x2220
movl %ebx, %eax
addq $0x44f8, %rsp           # imm = 0x44F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x6b(%rbp), %rdi
movb $0x0, (%rdi)
callq 0x3a8c
testl %eax, %eax
je 0x44ac
movq 0x5b3f(%rip), %rdi      # 0x9fd8
leaq 0x3201(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movzwl -0x6a(%rbp), %esi
leaq -0x68(%rbp), %rdi
callq 0x3b22
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x5b10(%rip), %rdi      # 0x9fd8
callq 0x2270
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x44e6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x4520(%rbp), %rcx
movzbl 0x1(%rcx), %eax
movl %eax, -0x98(%rbp)
shll $0x8, %eax
movzbl 0x2(%rcx), %ecx
movl %ecx, -0x94(%rbp)
orl %ecx, %eax
xorl %ecx, %ecx
movzwl %ax, %eax
movl %eax, -0x13c(%rbp)
cmpb $0x1, -0x320(%rbp,%rcx)
movq %rcx, -0x30(%rbp)
jne 0x455c
movl %ecx, %r14d
shll $0x9, %r14d
testq %rcx, %rcx
je 0x458c
xorl %r13d, %r13d
cmpb $0x0, -0x2e0(%rbp,%rcx)
jne 0x4554
movzbl %cl, %edi
callq 0x3eb7
testl %eax, %eax
jne 0x4933
movq -0x30(%rbp), %rax
movb $0x1, -0x2e0(%rbp,%rax)
movl %r14d, %r12d
jmp 0x45eb
cmpb $0x0, -0x2e0(%rbp,%rcx)
jne 0x468e
movzbl -0x30(%rbp), %edi
callq 0x3eb7
testl %eax, %eax
jne 0x4933
movq -0x30(%rbp), %rax
movb $0x1, -0x2e0(%rbp,%rax)
jmp 0x468e
xorl %edi, %edi
callq 0x3eb7
testl %eax, %eax
jne 0x4933
movb $0x1, -0x2e0(%rbp)
xorl %edi, %edi
callq 0x3f0e
testl %eax, %eax
jne 0x4933
leaq 0x2fb1(%rip), %rdi      # 0x7569
xorl %esi, %esi
movl $0x3, %edx
callq 0x3f75
testl %eax, %eax
jne 0x4933
movl -0x13c(%rbp), %edi
callq 0x402e
movl $0x3, %r13d
movl $0x3, %r12d
testl %eax, %eax
jne 0x4933
orl $0x1ff, %r14d           # imm = 0x1FF
movl %r12d, %ecx
leal 0x1(%r12), %eax
cmpb $-0x1, -0x4520(%rbp,%rcx)
je 0x4682
movl %r12d, %r15d
cmpl %r14d, %eax
ja 0x4640
xorl %ecx, %ecx
movl %r12d, %r15d
leal 0x1(%r15), %edx
cmpb $-0x1, -0x4520(%rbp,%rdx)
movl $0x0, %edx
jne 0x4630
cmpl $0x6, %ecx
ja 0x4640
incl %ecx
movl %r15d, %eax
movl %ecx, %edx
movl %eax, %r15d
leal (%rdx,%r15), %eax
incl %eax
movl %edx, %ecx
cmpl %r14d, %eax
jbe 0x4611
movzwl %r12w, %ebx
cmpl %r12d, %r13d
je 0x4658
movl %ebx, %edi
callq 0x3f0e
testl %eax, %eax
jne 0x4916
movl %r15d, %eax
subl %r12d, %eax
incl %eax
movzwl %ax, %edx
leaq -0x4520(%rbp), %rdi
movl %ebx, %esi
callq 0x3f75
testl %eax, %eax
jne 0x48f9
incl %r15d
movl %r15d, %eax
movl %r15d, %r13d
movl %eax, %r12d
cmpl %r14d, %eax
jbe 0x45f2
movq -0x30(%rbp), %rcx
incq %rcx
cmpq $0x1f, %rcx
jne 0x4511
movq 0x5932(%rip), %rdi      # 0x9fd8
leaq 0x3015(%rip), %rsi      # 0x76c2
movl $0x24, %edx
callq 0x2270
movq 0x591a(%rip), %rdi      # 0x9fd8
leaq 0x3022(%rip), %rsi      # 0x76e7
movl $0x1b, %edx
callq 0x2270
xorl %eax, %eax
movq %rax, -0x30(%rbp)
cmpb $0x1, -0x320(%rbp,%rax)
jne 0x48a4
movq -0x30(%rbp), %rcx
movl %ecx, %r15d
shll $0x9, %r15d
xorl %eax, %eax
movl %r15d, %r14d
testq %rcx, %rcx
jne 0x47c7
movl $0x3e09, %edi           # imm = 0x3E09
callq 0x3f0e
testl %eax, %eax
jne 0x4ae4
leaq -0x520(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4090
testl %eax, %eax
jne 0x4ae4
movzbl -0x520(%rbp), %r12d
movb -0x51f(%rbp), %r13b
movb -0x51e(%rbp), %bl
cmpl $0x2, %r12d
jne 0x4b1e
cmpb -0x98(%rbp), %r13b
jne 0x4b1e
cmpb -0x94(%rbp), %bl
jne 0x4b1e
xorl %edi, %edi
callq 0x3f0e
testl %eax, %eax
jne 0x4ae4
leaq -0x520(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4090
testl %eax, %eax
jne 0x4ae4
movzbl -0x520(%rbp), %r12d
movb -0x51f(%rbp), %r13b
movb -0x51e(%rbp), %bl
cmpl $0x2, %r12d
jne 0x4b83
cmpb $0x3e, %r13b
jne 0x4b83
movl $0x3, %eax
movl $0x3, %r14d
testb %bl, %bl
jne 0x4b83
orl $0x1ff, %r15d           # imm = 0x1FF
movl %r14d, %r12d
cmpb $-0x1, -0x4520(%rbp,%r12)
je 0x488e
leal 0x1(%r14), %ecx
movl %r14d, %ebx
cmpl %r15d, %ecx
ja 0x481c
xorl %edx, %edx
movl %r14d, %ebx
leal 0x1(%rbx), %esi
cmpb $-0x1, -0x4520(%rbp,%rsi)
movl $0x0, %esi
jne 0x480e
cmpl $0x6, %edx
ja 0x481c
incl %edx
movl %ebx, %ecx
movl %edx, %esi
movl %ecx, %ebx
leal (%rsi,%rbx), %ecx
incl %ecx
movl %esi, %edx
cmpl %r15d, %ecx
jbe 0x47f1
movzwl %r14w, %esi
cmpl %r14d, %eax
je 0x483a
movl %esi, %r13d
movl %esi, %edi
callq 0x3f0e
testl %eax, %eax
movl %r13d, %esi
jne 0x4b01
movl %ebx, %r13d
subl %r14d, %r13d
incl %r13d
movzwl %r13w, %edx
leaq -0x520(%rbp), %rdi
callq 0x4090
testl %eax, %eax
jne 0x4ac7
testl %r13d, %r13d
je 0x4893
leal 0x1(%rbx), %eax
movl %r13d, %ecx
xorl %r14d, %r14d
leal (%r12,%r14), %edx
movzbl -0x4520(%rbp,%rdx), %r13d
cmpb %r13b, -0x520(%rbp,%rdx)
jne 0x4950
incq %r14
cmpq %r14, %rcx
jne 0x4869
jmp 0x4896
movl %r14d, %ebx
jmp 0x4896
movl %r14d, %eax
incl %ebx
movl %ebx, %r14d
cmpl %r15d, %ebx
jbe 0x47ce
movq -0x30(%rbp), %rax
incq %rax
cmpq $0x1f, %rax
jne 0x46d1
callq 0x3ae2
testl %eax, %eax
jne 0x4492
movq 0x570f(%rip), %rdi      # 0x9fd8
leaq 0x2f4c(%rip), %rsi      # 0x781c
movl $0x22, %edx
callq 0x2270
movb $0x1, %bl
movq 0x56f5(%rip), %rdi      # 0x9fd8
leaq 0x2f55(%rip), %rsi      # 0x783f
movl $0x30, %edx
callq 0x2270
jmp 0x444c
movq 0x56d8(%rip), %rdi      # 0x9fd8
leaq 0x2d9a(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movq 0x56bb(%rip), %rdi      # 0x9fd8
leaq 0x2d7d(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movq 0x569e(%rip), %rdi      # 0x9fd8
leaq 0x2d60(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movq 0x5681(%rip), %rdi      # 0x9fd8
leaq 0x2e7f(%rip), %rsi      # 0x77dd
movl $0x1f, %edx
callq 0x2270
addq %r14, %r12
leaq -0x68(%rbp), %rdi
movl %r12d, %esi
callq 0x6ecc
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x5652(%rip), %rdi      # 0x9fd8
callq 0x2270
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x49a4
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x562d(%rip), %rdi      # 0x9fd8
leaq 0x2e4b(%rip), %rsi      # 0x77fd
movl $0xd, %edx
callq 0x2270
leaq -0x68(%rbp), %rdi
movl %r13d, %esi
callq 0x6ecc
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x5601(%rip), %rdi      # 0x9fd8
callq 0x2270
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x49f5
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
movq 0x55dc(%rip), %rdi      # 0x9fd8
leaq 0x2e08(%rip), %rsi      # 0x780b
movl $0x10, %edx
callq 0x2270
movzbl -0x520(%rbp,%r14), %esi
leaq -0x138(%rbp), %rdi
callq 0x6ecc
leaq 0x2c22(%rip), %rsi      # 0x764b
leaq -0x138(%rbp), %rdi
callq 0x23b0
leaq -0x58(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x4a59
movq %rsi, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x4a63
movups (%rcx), %xmm0
leaq -0x58(%rbp), %rsi
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x60(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x5557(%rip), %rdi      # 0x9fd8
callq 0x2270
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4a9f
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x444a
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x444a
movq 0x550a(%rip), %rdi      # 0x9fd8
leaq 0x2bcc(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movq 0x54ed(%rip), %rdi      # 0x9fd8
leaq 0x2baf(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
movq 0x54d0(%rip), %rdi      # 0x9fd8
leaq 0x2b92(%rip), %rsi      # 0x76a1
movl $0x20, %edx
callq 0x2270
jmp 0x444a
leaq -0x200(%rbp), %rdi
movl $0x3e09, %esi           # imm = 0x3E09
callq 0x6ecc
leaq 0x2bcd(%rip), %rsi      # 0x7703
leaq -0x220(%rbp), %rdi
leaq -0x200(%rbp), %rdx
callq 0x5ba5
leaq 0x2bf5(%rip), %rsi      # 0x7745
leaq -0x220(%rbp), %rdi
callq 0x23b0
leaq -0x80(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4bef
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x4bf9
leaq -0x200(%rbp), %rdi
movl $0x2, %esi
callq 0x6ecc
leaq 0x2bd7(%rip), %rsi      # 0x7772
leaq -0x220(%rbp), %rdi
leaq -0x200(%rbp), %rdx
callq 0x5ba5
leaq 0x2ba0(%rip), %rsi      # 0x7755
leaq -0x220(%rbp), %rdi
callq 0x23b0
leaq -0x80(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x50e8
movq %rdx, -0x90(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x80(%rbp)
jmp 0x50f2
movups (%rcx), %xmm0
leaq -0x80(%rbp), %rdx
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, -0x88(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1e0(%rbp), %rdi
movl -0x98(%rbp), %esi
callq 0x6ecc
leaq -0x240(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x1e0(%rbp), %rdx
callq 0x5cb9
leaq 0x2b0f(%rip), %rsi      # 0x7755
leaq -0x240(%rbp), %rdi
callq 0x23b0
leaq -0xa8(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4c7f
movq %rdx, -0xb8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa8(%rbp)
jmp 0x4c86
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0xb0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1c0(%rbp), %rdi
movl -0x94(%rbp), %esi
callq 0x6ecc
leaq -0x260(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x1c0(%rbp), %rdx
callq 0x5cb9
leaq 0x2a86(%rip), %rsi      # 0x7759
leaq -0x260(%rbp), %rdi
callq 0x23b0
leaq -0xc8(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4d0c
movq %rdx, -0xd8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xc8(%rbp)
jmp 0x4d13
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0xd0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1a0(%rbp), %rdi
movl %r12d, %esi
callq 0x6ecc
leaq -0x280(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x1a0(%rbp), %rdx
callq 0x5cb9
leaq 0x29f8(%rip), %rsi      # 0x7755
leaq -0x280(%rbp), %rdi
callq 0x23b0
movzbl %r13b, %esi
leaq -0xe8(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4d9b
movq %rdx, -0xf8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xe8(%rbp)
jmp 0x4da3
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0xf0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x180(%rbp), %rdi
callq 0x6ecc
leaq -0x2a0(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x180(%rbp), %rdx
callq 0x5cb9
leaq 0x296b(%rip), %rsi      # 0x7755
leaq -0x2a0(%rbp), %rdi
callq 0x23b0
movzbl %bl, %esi
leaq -0x108(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4e26
movq %rdx, -0x118(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x108(%rbp)
jmp 0x4e2e
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x110(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x160(%rbp), %rdi
callq 0x6ecc
leaq -0x138(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x160(%rbp), %rdx
callq 0x5cb9
leaq 0x28fa(%rip), %rsi      # 0x776f
leaq -0x138(%rbp), %rdi
callq 0x23b0
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4ea5
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x4eab
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x60(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x5107(%rip), %rdi      # 0x9fd8
callq 0x2270
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x4eeb
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f0a
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x150(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f29
movq -0x150(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x4f44
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x290(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f63
movq -0x290(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x170(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f82
movq -0x170(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
je 0x4f9d
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x270(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fbc
movq -0x270(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x190(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fdb
movq -0x190(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r15, %rdi
je 0x4ff6
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5015
movq -0x250(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5034
movq -0x1b0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x504f
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x230(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x506e
movq -0x230(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1d0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x508d
movq -0x1d0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x50a9
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x210(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50c8
movq -0x210(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1f0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x444a
movq -0x1f0(%rbp), %rsi
jmp 0x4aba
movups (%rcx), %xmm0
leaq -0x80(%rbp), %rdx
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, -0x88(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1e0(%rbp), %rdi
movl $0x3e, %esi
callq 0x6ecc
leaq -0x240(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x1e0(%rbp), %rdx
callq 0x5cb9
leaq 0x2617(%rip), %rsi      # 0x7755
leaq -0x240(%rbp), %rdi
callq 0x23b0
leaq -0xa8(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5177
movq %rdx, -0xb8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa8(%rbp)
jmp 0x517e
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, -0xb0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1c0(%rbp), %rdi
xorl %esi, %esi
callq 0x6ecc
leaq -0x260(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x1c0(%rbp), %rdx
callq 0x5cb9
leaq 0x2600(%rip), %rsi      # 0x77c7
leaq -0x260(%rbp), %rdi
callq 0x23b0
leaq -0xc8(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5200
movq %rdx, -0xd8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xc8(%rbp)
jmp 0x5207
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, -0xd0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1a0(%rbp), %rdi
movl %r12d, %esi
callq 0x6ecc
leaq -0x280(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x1a0(%rbp), %rdx
callq 0x5cb9
leaq 0x2504(%rip), %rsi      # 0x7755
leaq -0x280(%rbp), %rdi
callq 0x23b0
movzbl %r13b, %esi
leaq -0xe8(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x528f
movq %rdx, -0xf8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xe8(%rbp)
jmp 0x5297
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0xf0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x180(%rbp), %rdi
callq 0x6ecc
leaq -0x2a0(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x180(%rbp), %rdx
callq 0x5cb9
leaq 0x2477(%rip), %rsi      # 0x7755
leaq -0x2a0(%rbp), %rdi
callq 0x23b0
movzbl %bl, %esi
leaq -0x108(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x531a
movq %rdx, -0x118(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x108(%rbp)
jmp 0x5322
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x110(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x160(%rbp), %rdi
callq 0x6ecc
leaq -0x138(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x160(%rbp), %rdx
callq 0x5cb9
leaq 0x2406(%rip), %rsi      # 0x776f
leaq -0x138(%rbp), %rdi
callq 0x23b0
leaq -0x58(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5399
movq %rdx, -0x68(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x58(%rbp)
jmp 0x539f
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x60(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x4c13(%rip), %rdi      # 0x9fd8
callq 0x2270
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x53df
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x53fe
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x150(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x541d
movq -0x150(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x5438
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x290(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5457
movq -0x290(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x170(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5476
movq -0x170(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
je 0x5491
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x270(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54b0
movq -0x270(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x190(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54cf
movq -0x190(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r14, %rdi
je 0x54ea
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5509
movq -0x250(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5528
movq -0x1b0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r15, %rdi
jne 0x5040
jmp 0x504f
leaq 0x2356(%rip), %rdi      # 0x789a
xorl %eax, %eax
callq 0x22f0
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x556a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x556a
movq %rax, -0x30(%rbp)
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x558f
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x558f
movq %rax, -0x30(%rbp)
leaq -0x150(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55b4
movq -0x150(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x55b4
movq %rax, -0x30(%rbp)
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x55d5
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x55d5
movq %rax, -0x30(%rbp)
leaq -0x290(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55fa
movq -0x290(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x55fa
movq %rax, -0x30(%rbp)
leaq -0x170(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x561f
movq -0x170(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x561f
movq %rax, -0x30(%rbp)
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
je 0x5640
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5640
movq %rax, -0x30(%rbp)
leaq -0x270(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5665
movq -0x270(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5665
movq %rax, -0x30(%rbp)
leaq -0x190(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5684
movq -0x190(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r14, %rdi
je 0x569f
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56be
movq -0x250(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56dd
movq -0x1b0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r15, %rdi
jne 0x58c0
jmp 0x58cf
movq %rax, -0x30(%rbp)
jmp 0x5684
movq %rax, -0x30(%rbp)
jmp 0x569f
movq %rax, -0x30(%rbp)
jmp 0x56be
movq %rax, -0x30(%rbp)
jmp 0x56dd
jmp 0x5995
jmp 0x599e
jmp 0x59a7
jmp 0x59b0
jmp 0x59b9
jmp 0x5a7d
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5747
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5747
movq %rax, -0x30(%rbp)
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x576c
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x576c
movq %rax, -0x30(%rbp)
leaq -0x150(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5791
movq -0x150(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5791
movq %rax, -0x30(%rbp)
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x57b2
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x57b2
movq %rax, -0x30(%rbp)
leaq -0x290(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57d7
movq -0x290(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x57d7
movq %rax, -0x30(%rbp)
leaq -0x170(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57fc
movq -0x170(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x57fc
movq %rax, -0x30(%rbp)
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
je 0x581d
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x581d
movq %rax, -0x30(%rbp)
leaq -0x270(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x583c
movq -0x270(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x190(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x585b
movq -0x190(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r15, %rdi
je 0x5876
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x250(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5895
movq -0x250(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58b4
movq -0x1b0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x58cf
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x230(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58ee
movq -0x230(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1d0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x590d
movq -0x1d0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rax
cmpq %rax, %rdi
je 0x5929
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x210(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5948
movq -0x210(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1f0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a81
movq -0x1f0(%rbp), %rsi
jmp 0x5a6f
movq %rax, -0x30(%rbp)
jmp 0x583c
movq %rax, -0x30(%rbp)
jmp 0x585b
movq %rax, -0x30(%rbp)
jmp 0x5876
movq %rax, -0x30(%rbp)
jmp 0x5895
movq %rax, -0x30(%rbp)
jmp 0x58b4
movq %rax, -0x30(%rbp)
jmp 0x58cf
movq %rax, -0x30(%rbp)
jmp 0x58ee
movq %rax, -0x30(%rbp)
jmp 0x590d
movq %rax, -0x30(%rbp)
jmp 0x5929
movq %rax, -0x30(%rbp)
jmp 0x5948
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x59f6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x59f6
movq %rax, -0x30(%rbp)
leaq -0x128(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a81
movq -0x128(%rbp), %rsi
jmp 0x5a6f
jmp 0x5a7d
jmp 0x5a5a
jmp 0x5a7d
jmp 0x5a5a
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
movq %rax, -0x30(%rbp)
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x5a66
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
jmp 0x5a7d
movq %rax, -0x30(%rbp)
movq -0x300(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5a81
movq -0x2f0(%rbp), %rsi
jmp 0x5a6f
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x5a81
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5a81
jmp 0x5a7d
jmp 0x5a7d
movq %rax, -0x30(%rbp)
movq -0x2c0(%rbp), %rdi
leaq -0x2b0(%rbp), %rax
cmpq %rax, %rdi
je 0x5aa3
movq -0x2b0(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x30(%rbp), %rdi
callq 0x2380