// File: /workspace/github_cpp_makefile_star2_O1/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 $0x4508, %rsp           # imm = 0x4508
leaq -0x2b8(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x489f(%rip), %rdx      # 0x8a66
leaq -0x2c8(%rbp), %rdi
movq %rdx, %rsi
callq 0x5e6c
movw $0x3e02, -0x4530(%rbp)  # imm = 0x3E02
movb $0x0, -0x452e(%rbp)
movq 0x6deb(%rip), %rdi      # 0xafd8
leaq 0x438d(%rip), %rsi      # 0x8581
movl $0x27, %edx
callq 0x2270
movl 0x6ff8(%rip), %eax      # 0xb1fc
cmpl 0x7106(%rip), %eax      # 0xb310
jne 0x421d
movl $0x34, %edx
leaq 0x4391(%rip), %rsi      # 0x85a9
jmp 0x44a8
movq 0x6db4(%rip), %rdi      # 0xafd8
leaq 0x43b3(%rip), %rsi      # 0x85de
movl $0x15, %edx
callq 0x2270
leaq -0x300(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x7089(%rip), %rsi      # 0xb2d0
movq 0x708a(%rip), %rdx      # 0xb2d8
addq %rsi, %rdx
leaq -0x310(%rbp), %rdi
callq 0x5dd2
leaq -0x310(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x5f2e
movq %rax, %r12
movq -0x310(%rbp), %rdi
cmpq %rbx, %rdi
je 0x428e
movq -0x300(%rbp), %rsi
incq %rsi
callq 0x2220
movl $0x18, %edx
testq %r12, %r12
je 0x4467
xorps %xmm0, %xmm0
movups %xmm0, -0x2e1(%rbp)
movaps %xmm0, -0x2f0(%rbp)
movaps %xmm0, -0x330(%rbp)
movups %xmm0, -0x321(%rbp)
leaq -0x4530(%rbp), %rdi
movl $0x4000, %edx           # imm = 0x4000
movl $0xff, %esi
callq 0x2150
movq 0x8(%r12), %rax
cmpq (%r12), %rax
je 0x441b
leaq -0x60(%rbp), %r13
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
movq %r12, -0x30(%rbp)
movslq %r15d, %rsi
movq (%r12), %rbx
movq 0x8(%r12), %rdx
subq %rbx, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x55fd
imulq $0x38, %rsi, %r14
movq %r13, -0x70(%rbp)
movq (%rbx,%r14), %rsi
movq 0x8(%rbx,%r14), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x5dd2
addq %r14, %rbx
movl 0x30(%rbx), %eax
movl %eax, 0x20(%r13)
movups 0x20(%rbx), %xmm0
movups %xmm0, 0x10(%r13)
movzwl -0x4e(%rbp), %r14d
movzwl -0x50(%rbp), %r12d
leal (%r12,%r14), %ebx
cmpl $0x3dff, %ebx           # imm = 0x3DFF
ja 0x43b3
testq %r12, %r12
je 0x43cb
movq -0x48(%rbp), %r13
leaq (%r14,%rbp), %rdi
addq $-0x4530, %rdi          # imm = 0xBAD0
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 -0x330(%rbp,%rcx), %edx
movl $0x1, %esi
cmovel %edx, %esi
testb %dl, %dl
cmovnel %edx, %esi
movb %sil, -0x330(%rbp,%rcx)
incq %rax
cmpq %rax, %r12
jne 0x437c
jmp 0x43cb
movl $0x54, %edx
movq 0x6c19(%rip), %rdi      # 0xafd8
leaq 0x4247(%rip), %rsi      # 0x860d
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %r13
cmpq %r13, %rdi
je 0x43e4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
cmpl $0x3e00, %ebx           # imm = 0x3E00
movq -0x30(%rbp), %r12
jae 0x44b4
movq 0x8(%r12), %rax
subq (%r12), %rax
incl %r15d
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
cmpq %r15, %rax
ja 0x42f5
movq 0x6bb6(%rip), %rdi      # 0xafd8
leaq 0x4239(%rip), %rsi      # 0x8662
movl $0x1c, %edx
callq 0x2270
movq 0x6b9e(%rip), %rdi      # 0xafd8
leaq 0x423e(%rip), %rsi      # 0x867f
movl $0x1d, %edx
callq 0x2270
callq 0x3941
testl %eax, %eax
je 0x4470
cmpl $0x3, %eax
jne 0x449c
leaq 0x423d(%rip), %rsi      # 0x869d
movl $0x18, %edx
jmp 0x44a8
leaq 0x4186(%rip), %rsi      # 0x85f4
jmp 0x44a8
leaq -0x76(%rbp), %rdi
movw $0x0, (%rdi)
callq 0x3996
testl %eax, %eax
je 0x44ec
movq 0x6b4f(%rip), %rdi      # 0xafd8
leaq 0x4226(%rip), %rsi      # 0x86b6
movl $0x20, %edx
callq 0x2270
jmp 0x44b4
movl $0x16, %edx
leaq 0x408e(%rip), %rsi      # 0x8536
movq 0x6b29(%rip), %rdi      # 0xafd8
callq 0x2270
xorl %ebx, %ebx
movq -0x2c8(%rbp), %rdi
leaq -0x2b8(%rbp), %rax
cmpq %rax, %rdi
je 0x44d8
movq -0x2b8(%rbp), %rsi
incq %rsi
callq 0x2220
movl %ebx, %eax
addq $0x4508, %rsp           # imm = 0x4508
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x77(%rbp), %rdi
movb $0x0, (%rdi)
callq 0x3a17
testl %eax, %eax
je 0x4516
movq 0x6ad5(%rip), %rdi      # 0xafd8
leaq 0x41ac(%rip), %rsi      # 0x86b6
movl $0x20, %edx
callq 0x2270
jmp 0x44b4
movzwl -0x76(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0x3aad
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x6aa6(%rip), %rdi      # 0xafd8
callq 0x2270
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4550
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x4530(%rbp), %rax
movzwl 0x1(%rax), %eax
rolw $0x8, %ax
xorl %r14d, %r14d
movzwl %ax, %eax
movl %eax, -0x30(%rbp)
cmpb $0x1, -0x330(%rbp,%r14)
jne 0x45ae
movl %r14d, %ebx
shll $0x9, %ebx
testq %r14, %r14
je 0x45dc
xorl %r12d, %r12d
cmpb $0x0, -0x2f0(%rbp,%r14)
jne 0x45a6
movzbl %r14b, %edi
callq 0x3e47
testl %eax, %eax
jne 0x4b80
movb $0x1, -0x2f0(%rbp,%r14)
movl %ebx, %r15d
jmp 0x4638
cmpb $0x0, -0x2f0(%rbp,%r14)
jne 0x471f
movzbl %r14b, %edi
callq 0x3e47
testl %eax, %eax
jne 0x4b80
movb $0x1, -0x2f0(%rbp,%r14)
jmp 0x471f
xorl %edi, %edi
callq 0x3e47
testl %eax, %eax
jne 0x4b80
movb $0x1, -0x2f0(%rbp)
xorl %edi, %edi
callq 0x3e9e
testl %eax, %eax
jne 0x4b80
leaq 0x3f76(%rip), %rdi      # 0x857e
xorl %esi, %esi
movl $0x3, %edx
callq 0x3f05
testl %eax, %eax
jne 0x4b80
movl -0x30(%rbp), %edi
callq 0x4025
movl $0x3, %r12d
movl $0x3, %r15d
testl %eax, %eax
jne 0x4b80
orl $0x1ff, %ebx            # imm = 0x1FF
movl %r15d, %ecx
leal 0x1(%r15), %eax
cmpb $-0x1, -0x4530(%rbp,%rcx)
je 0x4714
movl %r15d, %r13d
cmpl %ebx, %eax
ja 0x468d
xorl %ecx, %ecx
movl %r15d, %r13d
leal 0x1(%r13), %edx
cmpb $-0x1, -0x4530(%rbp,%rdx)
movl $0x0, %edx
jne 0x467e
cmpl $0x6, %ecx
ja 0x468d
incl %ecx
movl %r13d, %eax
movl %ecx, %edx
movl %eax, %r13d
leal (%rdx,%r13), %eax
incl %eax
movl %edx, %ecx
cmpl %ebx, %eax
jbe 0x465f
cmpl %r15d, %r12d
je 0x46bb
movzwl %r15w, %edi
callq 0x3e9e
testl %eax, %eax
je 0x46bb
movl $0x20, %edx
movq 0x692d(%rip), %rdi      # 0xafd8
leaq 0x4004(%rip), %rsi      # 0x86b6
callq 0x2270
xorl %ecx, %ecx
jmp 0x4709
movl %r13d, %edx
subl %r15d, %edx
incl %edx
movl %r15d, %esi
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
andl %eax, %edx
leaq -0x4530(%rbp), %rdi
callq 0x3f05
testl %eax, %eax
je 0x46fe
movl $0x20, %edx
movq 0x68ed(%rip), %rdi      # 0xafd8
leaq 0x3fc4(%rip), %rsi      # 0x86b6
callq 0x2270
xorl %ecx, %ecx
movl %r15d, %r12d
jmp 0x4709
incl %r13d
movb $0x1, %cl
movl %r13d, %r15d
movl %r13d, %r12d
movl %r15d, %eax
testb %cl, %cl
je 0x44b4
movl %eax, %r15d
cmpl %ebx, %eax
jbe 0x463e
incq %r14
cmpq $0x1f, %r14
jne 0x4568
movq 0x68a5(%rip), %rdi      # 0xafd8
leaq 0x3f9d(%rip), %rsi      # 0x86d7
movl $0x24, %edx
callq 0x2270
movq 0x688d(%rip), %rdi      # 0xafd8
leaq 0x3faa(%rip), %rsi      # 0x86fc
movl $0x1b, %edx
callq 0x2270
movb -0x452f(%rbp), %al
movb %al, -0x32(%rbp)
movb -0x452e(%rbp), %al
movb %al, -0x31(%rbp)
xorl %ecx, %ecx
movq 0x6861(%rip), %r15      # 0xafd8
movq $0x0, -0x140(%rbp)
movq %rcx, -0x148(%rbp)
cmpb $0x1, -0x330(%rbp,%rcx)
jne 0x4b55
movq -0x148(%rbp), %rax
movl %eax, %ecx
shll $0x9, %ecx
xorl %r14d, %r14d
movl %ecx, -0x30(%rbp)
movl %ecx, %ebx
testq %rax, %rax
jne 0x4872
movl $0x3e09, %edi           # imm = 0x3E09
callq 0x3e9e
testl %eax, %eax
jne 0x4b9d
leaq -0x530(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4087
testl %eax, %eax
jne 0x4b9d
movzbl -0x530(%rbp), %r12d
cmpl $0x2, %r12d
jne 0x4bba
movb -0x32(%rbp), %al
cmpb %al, -0x52f(%rbp)
jne 0x4bba
movb -0x31(%rbp), %al
cmpb %al, -0x52e(%rbp)
jne 0x4bba
xorl %edi, %edi
callq 0x3e9e
testl %eax, %eax
jne 0x4b9d
leaq -0x530(%rbp), %rdi
xorl %esi, %esi
movl $0x3, %edx
callq 0x4087
testl %eax, %eax
jne 0x4b9d
movzbl -0x530(%rbp), %r13d
cmpl $0x2, %r13d
jne 0x4c29
cmpb $0x3e, -0x52f(%rbp)
jne 0x4c29
movl $0x3, %r14d
cmpb $0x0, -0x52e(%rbp)
movl $0x3, %ebx
jne 0x4c29
addl $0x1ff, -0x30(%rbp)     # imm = 0x1FF
movl %ebx, %r13d
leal 0x1(%rbx), %eax
cmpb $-0x1, -0x4530(%rbp,%r13)
je 0x4b4a
movl %ebx, %r12d
cmpl -0x30(%rbp), %eax
ja 0x48cb
xorl %ecx, %ecx
movl %ebx, %r12d
leal 0x1(%r12), %edx
cmpb $-0x1, -0x4530(%rbp,%rdx)
movl $0x0, %edx
jne 0x48bb
cmpl $0x6, %ecx
ja 0x48cb
incl %ecx
movl %r12d, %eax
movl %ecx, %edx
movl %eax, %r12d
leal (%rdx,%r12), %eax
incl %eax
movl %edx, %ecx
cmpl -0x30(%rbp), %eax
jbe 0x489b
cmpl %ebx, %r14d
je 0x48f8
movzwl %bx, %edi
callq 0x3e9e
testl %eax, %eax
je 0x48f8
movl $0x20, %edx
movq %r15, %rdi
leaq 0x3dcb(%rip), %rsi      # 0x86b6
callq 0x2270
xorl %r13d, %r13d
jmp 0x4b3f
movl %r12d, %r14d
subl %ebx, %r14d
incl %r14d
movl %ebx, %esi
movl $0xffff, %eax           # imm = 0xFFFF
andl %eax, %esi
movl %r14d, %edx
andl %eax, %edx
leaq -0x530(%rbp), %rdi
callq 0x4087
testl %eax, %eax
je 0x493e
movl $0x20, %edx
movq %r15, %rdi
leaq 0x3d88(%rip), %rsi      # 0x86b6
callq 0x2270
xorl %r13d, %r13d
movl %ebx, %r14d
jmp 0x4b3f
testl %r14d, %r14d
sete %al
movl %eax, -0x74(%rbp)
je 0x499b
movb -0x4530(%rbp,%r13), %r15b
cmpb %r15b, -0x530(%rbp,%r13)
jne 0x49a7
movl %r14d, %eax
leal 0x1(%r12), %ecx
movl $0x1, %r13d
movl %ebx, %r14d
cmpq %r13, %rax
je 0x4b27
incl %r14d
movb -0x4530(%rbp,%r14), %r15b
incq %r13
cmpb %r15b, -0x530(%rbp,%r14)
je 0x496c
decq %r13
cmpq %rax, %r13
setae %al
movl %eax, -0x74(%rbp)
jmp 0x49ad
movl %ebx, %r14d
movl -0x74(%rbp), %r13d
jmp 0x4b35
xorl %r13d, %r13d
movl %ebx, %r14d
movl $0x1f, %edx
movq 0x661f(%rip), %rdi      # 0xafd8
leaq 0x3e32(%rip), %rsi      # 0x87f2
callq 0x2270
leaq -0x70(%rbp), %rdi
movl %r14d, %esi
callq 0x6f54
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x65f8(%rip), %rdi      # 0xafd8
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x49fe
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movl $0xd, %edx
movq 0x65ce(%rip), %rdi      # 0xafd8
leaq 0x3e01(%rip), %rsi      # 0x8812
callq 0x2270
movzbl %r15b, %esi
leaq -0x70(%rbp), %rdi
callq 0x6f54
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x65a6(%rip), %r15      # 0xafd8
movq %r15, %rdi
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x4a53
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movl $0x10, %edx
movq %r15, %rdi
leaq 0x3dbe(%rip), %rsi      # 0x8820
callq 0x2270
movzbl -0x530(%rbp,%r13), %esi
leaq -0x98(%rbp), %r15
movq %r15, %rdi
callq 0x6f54
movq %r15, %rdi
leaq 0x3bd7(%rip), %rsi      # 0x8660
callq 0x23b0
movq 0x6543(%rip), %r15      # 0xafd8
movl -0x74(%rbp), %r13d
leaq -0x60(%rbp), %rsi
movq %rsi, -0x70(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4abd
movq %rdx, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4ac3
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %r15, %rdi
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x4b03
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4b35
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x4b35
setbe %r13b
movl %ecx, %r14d
movq 0x64a3(%rip), %r15      # 0xafd8
incl %r12d
testb %r13b, %r13b
cmovnel %r12d, %ebx
movl %ebx, %eax
testb %r13b, %r13b
je 0x51a2
movl %eax, %ebx
cmpl -0x30(%rbp), %eax
jbe 0x4879
movq -0x148(%rbp), %rax
cmpq $0x1e, %rax
leaq 0x1(%rax), %rax
setae %cl
movq %rcx, -0x140(%rbp)
movq %rax, %rcx
cmpq $0x1f, %rax
jne 0x4782
jmp 0x51af
movq 0x6451(%rip), %rdi      # 0xafd8
leaq 0x3b28(%rip), %rsi      # 0x86b6
movl $0x20, %edx
callq 0x2270
jmp 0x44b4
movq 0x6434(%rip), %rdi      # 0xafd8
leaq 0x3b0b(%rip), %rsi      # 0x86b6
movl $0x20, %edx
callq 0x2270
jmp 0x51a2
leaq -0x208(%rbp), %rdi
movl $0x3e09, %esi           # imm = 0x3E09
callq 0x6f54
leaq 0x3b46(%rip), %rsi      # 0x8718
leaq -0x228(%rbp), %rdi
leaq -0x208(%rbp), %rdx
callq 0x5c0b
leaq 0x3b6e(%rip), %rsi      # 0x875a
leaq -0x228(%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 0x4c9b
movq %rdx, -0xb8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa8(%rbp)
jmp 0x4ca2
leaq -0x208(%rbp), %rdi
movl $0x2, %esi
callq 0x6f54
leaq 0x3b46(%rip), %rsi      # 0x8787
leaq -0x228(%rbp), %rdi
leaq -0x208(%rbp), %rdx
callq 0x5c0b
leaq 0x3b0f(%rip), %rsi      # 0x876a
leaq -0x228(%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 0x51f3
movq %rdx, -0xb8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xa8(%rbp)
jmp 0x51fa
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)
movzbl -0x452f(%rbp), %esi
leaq -0x1e8(%rbp), %rdi
callq 0x6f54
leaq -0x248(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x1e8(%rbp), %rdx
callq 0x5d1f
leaq 0x3a7a(%rip), %rsi      # 0x876a
leaq -0x248(%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 0x4d29
movq %rdx, -0xd8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xc8(%rbp)
jmp 0x4d30
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)
movzbl -0x452e(%rbp), %esi
leaq -0x1c8(%rbp), %rdi
callq 0x6f54
leaq -0x268(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x1c8(%rbp), %rdx
callq 0x5d1f
leaq 0x39f0(%rip), %rsi      # 0x876e
leaq -0x268(%rbp), %rdi
callq 0x23b0
leaq -0xe8(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4db7
movq %rdx, -0xf8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xe8(%rbp)
jmp 0x4dbf
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0xf0(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x1a8(%rbp), %rdi
movl %r12d, %esi
callq 0x6f54
leaq -0x288(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x1a8(%rbp), %rdx
callq 0x5d1f
leaq 0x3961(%rip), %rsi      # 0x876a
leaq -0x288(%rbp), %rdi
callq 0x23b0
leaq -0x108(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4e43
movq %rdx, -0x118(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x108(%rbp)
jmp 0x4e4b
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
movq %rdx, -0x110(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movzbl -0x52f(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x6f54
leaq -0x2a8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x188(%rbp), %rdx
callq 0x5d1f
leaq 0x38d1(%rip), %rsi      # 0x876a
leaq -0x2a8(%rbp), %rdi
callq 0x23b0
leaq -0x128(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4ed2
movq %rdx, -0x138(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x128(%rbp)
jmp 0x4ed8
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x130(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movzbl -0x52e(%rbp), %esi
leaq -0x168(%rbp), %rdi
callq 0x6f54
leaq -0x98(%rbp), %rdi
leaq -0x138(%rbp), %rsi
leaq -0x168(%rbp), %rdx
callq 0x5d1f
leaq 0x385e(%rip), %rsi      # 0x8784
leaq -0x98(%rbp), %rdi
callq 0x23b0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4f56
movq %rdx, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x4f60
movups (%rcx), %xmm0
leaq -0x60(%rbp), %rdx
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x6052(%rip), %rdi      # 0xafd8
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x4fa4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x4fc6
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x158(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fe5
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x138(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5000
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x298(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x501f
movq -0x298(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x178(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x503e
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x118(%rbp), %rdi
cmpq %r12, %rdi
je 0x5059
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x278(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5078
movq -0x278(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5097
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r13, %rdi
je 0x50b2
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x258(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50d1
movq -0x258(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50f0
movq -0x1b8(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r15, %rdi
je 0x510b
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x238(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x512a
movq -0x238(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1d8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5149
movq -0x1d8(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x5164
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x218(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5183
movq -0x218(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1f8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51a2
movq -0x1f8(%rbp), %rsi
incq %rsi
callq 0x2220
testb $0x1, -0x140(%rbp)
je 0x44b4
callq 0x3a6d
testl %eax, %eax
jne 0x44fc
movq 0x5e15(%rip), %rdi      # 0xafd8
leaq 0x3667(%rip), %rsi      # 0x8831
movl $0x22, %edx
callq 0x2270
movb $0x1, %bl
movq 0x5dfb(%rip), %rdi      # 0xafd8
leaq 0x3670(%rip), %rsi      # 0x8854
movl $0x30, %edx
callq 0x2270
jmp 0x44b6
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 -0x1e8(%rbp), %rdi
movl $0x3e, %esi
callq 0x6f54
leaq -0x248(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
leaq -0x1e8(%rbp), %rdx
callq 0x5d1f
leaq 0x3524(%rip), %rsi      # 0x876a
leaq -0x248(%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 0x527f
movq %rdx, -0xd8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xc8(%rbp)
jmp 0x5286
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 -0x1c8(%rbp), %rdi
xorl %esi, %esi
callq 0x6f54
leaq -0x268(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq -0x1c8(%rbp), %rdx
callq 0x5d1f
leaq 0x350d(%rip), %rsi      # 0x87dc
leaq -0x268(%rbp), %rdi
callq 0x23b0
leaq -0xe8(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5309
movq %rdx, -0xf8(%rbp)
movq (%rcx), %rdx
movq %rdx, -0xe8(%rbp)
jmp 0x5311
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 -0x1a8(%rbp), %rdi
movl %r13d, %esi
callq 0x6f54
leaq -0x288(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
leaq -0x1a8(%rbp), %rdx
callq 0x5d1f
leaq 0x340f(%rip), %rsi      # 0x876a
leaq -0x288(%rbp), %rdi
callq 0x23b0
leaq -0x108(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5394
movq %rdx, -0x118(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x108(%rbp)
jmp 0x539c
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)
movzbl -0x52f(%rbp), %esi
leaq -0x188(%rbp), %rdi
callq 0x6f54
leaq -0x2a8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
leaq -0x188(%rbp), %rdx
callq 0x5d1f
leaq 0x3380(%rip), %rsi      # 0x876a
leaq -0x2a8(%rbp), %rdi
callq 0x23b0
leaq -0x128(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5423
movq %rdx, -0x138(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x128(%rbp)
jmp 0x5429
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, -0x130(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movzbl -0x52e(%rbp), %esi
leaq -0x168(%rbp), %rdi
callq 0x6f54
leaq -0x98(%rbp), %rdi
leaq -0x138(%rbp), %rsi
leaq -0x168(%rbp), %rdx
callq 0x5d1f
leaq 0x330d(%rip), %rsi      # 0x8784
leaq -0x98(%rbp), %rdi
callq 0x23b0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x54a7
movq %rdx, -0x70(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x60(%rbp)
jmp 0x54b1
movups (%rcx), %xmm0
leaq -0x60(%rbp), %rdx
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, -0x68(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq 0x5b01(%rip), %rdi      # 0xafd8
callq 0x2270
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x54f5
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5517
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x158(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5536
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x138(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5551
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x298(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5570
movq -0x298(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x178(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x558f
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x55aa
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x278(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55c9
movq -0x278(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55e8
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
jne 0x50a3
jmp 0x50b2
leaq 0x32ab(%rip), %rdi      # 0x88af
xorl %eax, %eax
callq 0x22f0
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x562e
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x562e
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5656
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5656
movq %rax, -0x30(%rbp)
leaq -0x158(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x567b
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x567b
movq %rax, -0x30(%rbp)
movq -0x138(%rbp), %rdi
cmpq %rbx, %rdi
je 0x569c
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x569c
movq %rax, -0x30(%rbp)
leaq -0x298(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56c1
movq -0x298(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x56c1
movq %rax, -0x30(%rbp)
leaq -0x178(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56e6
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x56e6
movq %rax, -0x30(%rbp)
movq -0x118(%rbp), %rdi
cmpq %r13, %rdi
je 0x5707
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5707
movq %rax, -0x30(%rbp)
leaq -0x278(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5726
movq -0x278(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5745
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r12, %rdi
jne 0x58df
jmp 0x58ee
movq %rax, -0x30(%rbp)
jmp 0x5726
movq %rax, -0x30(%rbp)
jmp 0x5745
jmp 0x59e8
jmp 0x59f1
jmp 0x59fa
jmp 0x5a03
jmp 0x5a0c
jmp 0x5a15
jmp 0x5a1e
jmp 0x5a27
jmp 0x5ae3
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x57b6
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x57b6
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x57de
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x57de
movq %rax, -0x30(%rbp)
leaq -0x158(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5803
movq -0x158(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5803
movq %rax, -0x30(%rbp)
movq -0x138(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5824
movq -0x128(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5824
movq %rax, -0x30(%rbp)
leaq -0x298(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5849
movq -0x298(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5849
movq %rax, -0x30(%rbp)
leaq -0x178(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x586e
movq -0x178(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x586e
movq %rax, -0x30(%rbp)
movq -0x118(%rbp), %rdi
cmpq %r12, %rdi
je 0x588f
movq -0x108(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x588f
movq %rax, -0x30(%rbp)
leaq -0x278(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58b4
movq -0x278(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x58b4
movq %rax, -0x30(%rbp)
leaq -0x198(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58d3
movq -0x198(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xf8(%rbp), %rdi
cmpq %r13, %rdi
je 0x58ee
movq -0xe8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x258(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x590d
movq -0x258(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1b8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x592c
movq -0x1b8(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xd8(%rbp), %rdi
cmpq %r15, %rdi
je 0x5947
movq -0xc8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x238(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5966
movq -0x238(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1d8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5985
movq -0x1d8(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0xb8(%rbp), %rdi
cmpq %r14, %rdi
je 0x59a0
movq -0xa8(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x218(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x59bf
movq -0x218(%rbp), %rsi
incq %rsi
callq 0x2220
leaq -0x1f8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ae7
movq -0x1f8(%rbp), %rsi
jmp 0x5ad5
movq %rax, -0x30(%rbp)
jmp 0x58d3
movq %rax, -0x30(%rbp)
jmp 0x58ee
movq %rax, -0x30(%rbp)
jmp 0x590d
movq %rax, -0x30(%rbp)
jmp 0x592c
movq %rax, -0x30(%rbp)
jmp 0x5947
movq %rax, -0x30(%rbp)
jmp 0x5966
movq %rax, -0x30(%rbp)
jmp 0x5985
movq %rax, -0x30(%rbp)
jmp 0x59a0
movq %rax, -0x30(%rbp)
jmp 0x59bf
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5a5f
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5a5f
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rdi
leaq -0x88(%rbp), %rax
cmpq %rax, %rdi
je 0x5ae7
movq -0x88(%rbp), %rsi
jmp 0x5ad5
jmp 0x5ae3
jmp 0x5ac0
jmp 0x5ae3
jmp 0x5ac0
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
movq %rax, -0x30(%rbp)
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
jmp 0x5acc
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
jmp 0x5ae3
movq %rax, -0x30(%rbp)
movq -0x310(%rbp), %rdi
cmpq %rbx, %rdi
je 0x5ae7
movq -0x300(%rbp), %rsi
jmp 0x5ad5
movq %rax, -0x30(%rbp)
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x5ae7
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x2220
jmp 0x5ae7
jmp 0x5ae3
jmp 0x5ae3
movq %rax, -0x30(%rbp)
movq -0x2c8(%rbp), %rdi
leaq -0x2b8(%rbp), %rax
cmpq %rax, %rdi
je 0x5b09
movq -0x2b8(%rbp), %rsi
incq %rsi
callq 0x2220
movq -0x30(%rbp), %rdi
callq 0x2380