// File: jimmiebergmann[P]fbx-file/fbx.cpp
// Function: Fbx::Record::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int) const
void Record::write(const std::string & filename, const uint32_t version) const
    {
        std::ofstream file(filename, std::ios::binary);
        if (file.is_open() == false)
        {
            throw std::runtime_error("Failed to open file.");
        }

        std::vector<uint8_t> data;

        // Write FBX header.
        const uint8_t magic[21] = "Kaydara FBX Binary  ";
        const uint8_t * pVersion = reinterpret_cast<const uint8_t*>(&version);

        data.insert(data.end(), magic, magic + 21);
        data.push_back(0x1A);
        data.push_back(0);
        data.insert(data.end(), pVersion, pVersion + 4);

        std::stack<std::tuple<ConstIterator, ConstIterator, uint32_t>> stack;
        if (m_nestedList.size())
        {
            stack.push(std::make_tuple(m_nestedList.begin(), m_nestedList.end(), 0));
        }

        while (stack.size())
        {
            auto & top = stack.top();
            ConstIterator & currentIt = std::get<0>(top);
            ConstIterator & endIt = std::get<1>(top);
            uint32_t & parentStart = std::get<2>(top);

            if (parentStart != 0)
            {
                const uint32_t currentPos = static_cast<uint32_t>(data.size());
                const uint8_t * pCurrentPos = reinterpret_cast<const uint8_t *>(&currentPos);
                data[parentStart] = pCurrentPos[0];
                data[parentStart + 1] = pCurrentPos[1];
                data[parentStart + 2] = pCurrentPos[2];
                data[parentStart + 3] = pCurrentPos[3];
            }

            if (currentIt == endIt)
            {
                data.insert(data.end(), 13, 0);
                stack.pop();

                continue;
            }

            const Record * pRecord = *currentIt;
            parentStart = static_cast<uint32_t>(data.size());
            ++currentIt;

            // Write record header.
            const auto & properties = pRecord->properties();
            const uint32_t numProperties = static_cast<uint32_t>(properties.size());
            const uint8_t * pNumProperties = reinterpret_cast<const uint8_t*>(&numProperties);
            const std::string & name = pRecord->name();
            const uint8_t * pName = reinterpret_cast<const uint8_t*>(&name[0]);
            const uint8_t nameLength = static_cast<uint8_t>(name.size());
            data.insert(data.end(), 4, 0);
            data.insert(data.end(), pNumProperties, pNumProperties + 4);
            const uint32_t propertiesOffset = static_cast<uint32_t>(data.size());
            data.insert(data.end(), 4, 0);
            data.push_back(nameLength);
            data.insert(data.end(), pName, pName + nameLength);

            // Write record properties.
            const uint32_t propertyStart = static_cast<uint32_t>(data.size());
            for (auto pIt = properties.begin(); pIt != properties.end(); ++pIt)
            {
                Property * pProperty = *pIt;
                data.push_back(pProperty->code());

                switch (pProperty->code())
                {
                case 'I': writePrimitive(data, pProperty->primitive().integer32); break;
                case 'L': writePrimitive(data, pProperty->primitive().integer64); break;
                case 'F': writePrimitive(data, pProperty->primitive().float32); break;
                case 'D': writePrimitive(data, pProperty->primitive().float64); break;
                case 'C': writePrimitive(data, pProperty->primitive().boolean); break;
                case 'Y': writePrimitive(data, pProperty->primitive().integer16); break;
                case 'i': writeArray<int32_t>(data, pProperty->array()); break;
                case 'l': writeArray<int64_t>(data, pProperty->array()); break;
                case 'f': writeArray<float>(data, pProperty->array()); break;
                case 'd': writeArray<double>(data, pProperty->array()); break;
                case 'b': writeArray<bool>(data, pProperty->array()); break;
                case 'R':
                case 'S': writeRaw(data, pProperty->raw()); break;
                default: break;
                }
            }

            // Set properties length
            const uint32_t propertiesEnd = static_cast<uint32_t>(data.size());
            const uint32_t propertiesLength = propertiesEnd - propertyStart;
            const uint8_t * pPropertiesLength = reinterpret_cast<const uint8_t*>(&propertiesLength);
            data[propertiesOffset] = pPropertiesLength[0];
            data[propertiesOffset + 1] = pPropertiesLength[1];
            data[propertiesOffset + 2] = pPropertiesLength[2];
            data[propertiesOffset + 3] = pPropertiesLength[3];

            // Add nested list.
            if (pRecord->size())
            {
                stack.push(std::make_tuple(pRecord->begin(), pRecord->end(), 0));
            }
            
        }

        file.write(reinterpret_cast<const char*>(&data[0]), data.size());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x5d0, %rsp            # imm = 0x5D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4c8(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movq %rdi, -0x4c0(%rbp)
movl $0x4, %edx
callq 0x35b0
movq -0x4c0(%rbp), %rdi
callq 0x3250
movb %al, -0x4b5(%rbp)
jmp 0x235c1
movb -0x4b5(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x2364f
movl $0x10, %edi
callq 0x3160
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x4d0(%rbp)
leaq 0x13844(%rip), %rsi     # 0x36e33
callq 0x3100
jmp 0x235f6
movq -0x4d0(%rbp), %rdi
movq 0x219ec(%rip), %rsi     # 0x44ff0
movq 0x219bd(%rip), %rdx     # 0x44fc8
callq 0x3520
jmp 0x241e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x241c9
movq -0x4d0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
callq 0x3230
jmp 0x241c9
leaq -0x240(%rbp), %rdi
movq %rdi, -0x4e0(%rbp)
callq 0x27d90
movq -0x4e0(%rbp), %rdi
movabsq $0x20207972616e69, %rax # imm = 0x20207972616E69
movq %rax, -0x253(%rbp)
movaps 0x13a7f(%rip), %xmm0    # 0x37100
movaps %xmm0, -0x260(%rbp)
leaq -0x14(%rbp), %rax
movq %rax, -0x268(%rbp)
callq 0x28cb0
movq %rax, -0x278(%rbp)
leaq -0x270(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x28ce0
movq -0x4e0(%rbp), %rdi
leaq -0x24b(%rbp), %rcx
movq -0x270(%rbp), %rsi
leaq -0x260(%rbp), %rdx
callq 0x28c10
movq %rax, -0x4d8(%rbp)
jmp 0x236dc
movq -0x4d8(%rbp), %rax
movq %rax, -0x280(%rbp)
movb $0x1a, -0x281(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x281(%rbp), %rsi
callq 0x28d20
jmp 0x23706
movb $0x0, -0x282(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x282(%rbp), %rsi
callq 0x28d20
jmp 0x23722
leaq -0x240(%rbp), %rdi
movq %rdi, -0x4f0(%rbp)
callq 0x28cb0
movq %rax, -0x298(%rbp)
leaq -0x290(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0x28ce0
movq -0x4f0(%rbp), %rdi
movq -0x268(%rbp), %rdx
movq %rdx, %rcx
addq $0x4, %rcx
movq -0x290(%rbp), %rsi
callq 0x28c10
movq %rax, -0x4e8(%rbp)
jmp 0x23779
movq -0x4e8(%rbp), %rax
movq %rax, -0x2a0(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x28d50
jmp 0x23795
movq -0x4c8(%rbp), %rdi
addq $0x40, %rdi
callq 0x28d80
cmpq $0x0, %rax
je 0x23878
movq -0x4c8(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x4f8(%rbp)
callq 0x28e20
movq -0x4f8(%rbp), %rdi
movq %rax, -0x328(%rbp)
callq 0x28e50
movq %rax, -0x330(%rbp)
movl $0x0, -0x334(%rbp)
leaq -0x320(%rbp), %rdi
leaq -0x328(%rbp), %rsi
leaq -0x330(%rbp), %rdx
leaq -0x334(%rbp), %rcx
callq 0x28de0
jmp 0x2380d
leaq -0x308(%rbp), %rdi
movq %rdi, -0x500(%rbp)
leaq -0x320(%rbp), %rsi
callq 0x28e80
movq -0x500(%rbp), %rsi
leaq -0x2f0(%rbp), %rdi
callq 0x28db0
jmp 0x2383c
jmp 0x23878
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x241bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x291a0
jmp 0x241bd
jmp 0x2387a
leaq -0x2f0(%rbp), %rdi
callq 0x28eb0
movq %rax, -0x508(%rbp)
jmp 0x2388f
movq -0x508(%rbp), %rax
cmpq $0x0, %rax
je 0x2414e
leaq -0x2f0(%rbp), %rdi
callq 0x28ed0
movq %rax, -0x510(%rbp)
jmp 0x238b5
movq -0x510(%rbp), %rax
movq %rax, -0x340(%rbp)
movq -0x340(%rbp), %rdi
callq 0x28ef0
movq %rax, -0x348(%rbp)
movq -0x340(%rbp), %rdi
callq 0x28f10
movq %rax, -0x350(%rbp)
movq -0x340(%rbp), %rdi
callq 0x28f30
movq %rax, -0x358(%rbp)
movq -0x358(%rbp), %rax
cmpl $0x0, (%rax)
je 0x239f6
leaq -0x240(%rbp), %rdi
callq 0x28040
movl %eax, -0x35c(%rbp)
leaq -0x35c(%rbp), %rax
movq %rax, -0x368(%rbp)
movq -0x368(%rbp), %rax
movb (%rax), %al
movb %al, -0x514(%rbp)
movq -0x358(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x28f50
movb -0x514(%rbp), %cl
movb %cl, (%rax)
movq -0x368(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x513(%rbp)
movq -0x358(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x28f50
movb -0x513(%rbp), %cl
movb %cl, (%rax)
movq -0x368(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x512(%rbp)
movq -0x358(%rbp), %rax
movl (%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x28f50
movb -0x512(%rbp), %cl
movb %cl, (%rax)
movq -0x368(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x511(%rbp)
movq -0x358(%rbp), %rax
movl (%rax), %eax
addl $0x3, %eax
movl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
callq 0x28f50
movb -0x511(%rbp), %cl
movb %cl, (%rax)
movq -0x348(%rbp), %rdi
movq -0x350(%rbp), %rsi
callq 0x28f70
testb $0x1, %al
jne 0x23a0f
jmp 0x23a8c
leaq -0x240(%rbp), %rdi
movq %rdi, -0x528(%rbp)
callq 0x28cb0
movq %rax, -0x378(%rbp)
leaq -0x370(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x28ce0
movq -0x528(%rbp), %rdi
movb $0x0, -0x379(%rbp)
movq -0x370(%rbp), %rsi
movl $0xd, %edx
leaq -0x379(%rbp), %rcx
callq 0x28fa0
movq %rax, -0x520(%rbp)
jmp 0x23a6b
movq -0x520(%rbp), %rax
movq %rax, -0x388(%rbp)
leaq -0x2f0(%rbp), %rdi
callq 0x29040
jmp 0x23a87
jmp 0x2387a
movq -0x348(%rbp), %rdi
callq 0x29060
movq (%rax), %rax
movq %rax, -0x390(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x28040
movl %eax, %ecx
movq -0x358(%rbp), %rax
movl %ecx, (%rax)
movq -0x348(%rbp), %rdi
callq 0x29090
movq -0x390(%rbp), %rdi
callq 0x241f0
movq %rax, -0x530(%rbp)
jmp 0x23ada
movq -0x530(%rbp), %rax
movq %rax, -0x398(%rbp)
movq -0x398(%rbp), %rdi
callq 0x216b0
movl %eax, -0x39c(%rbp)
leaq -0x39c(%rbp), %rax
movq %rax, -0x3a8(%rbp)
movq -0x390(%rbp), %rdi
callq 0x23530
movq %rax, -0x538(%rbp)
jmp 0x23b1d
movq -0x538(%rbp), %rax
movq %rax, -0x3b0(%rbp)
movq -0x3b0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3360
movq %rax, -0x3b8(%rbp)
movq -0x3b0(%rbp), %rdi
callq 0x3210
movb %al, -0x3b9(%rbp)
leaq -0x240(%rbp), %rdi
movq %rdi, -0x548(%rbp)
callq 0x28cb0
movq %rax, -0x3d0(%rbp)
leaq -0x3c8(%rbp), %rdi
leaq -0x3d0(%rbp), %rsi
callq 0x28ce0
movq -0x548(%rbp), %rdi
movb $0x0, -0x3d1(%rbp)
movq -0x3c8(%rbp), %rsi
movl $0x4, %edx
leaq -0x3d1(%rbp), %rcx
callq 0x28fa0
movq %rax, -0x540(%rbp)
jmp 0x23bb0
movq -0x540(%rbp), %rax
movq %rax, -0x3e0(%rbp)
leaq -0x240(%rbp), %rdi
movq %rdi, -0x558(%rbp)
callq 0x28cb0
movq %rax, -0x3f0(%rbp)
leaq -0x3e8(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
callq 0x28ce0
movq -0x558(%rbp), %rdi
movq -0x3a8(%rbp), %rdx
movq %rdx, %rcx
addq $0x4, %rcx
movq -0x3e8(%rbp), %rsi
callq 0x28c10
movq %rax, -0x550(%rbp)
jmp 0x23c15
movq -0x550(%rbp), %rax
movq %rax, -0x3f8(%rbp)
leaq -0x240(%rbp), %rdi
movq %rdi, -0x568(%rbp)
callq 0x28040
movq -0x568(%rbp), %rdi
movl %eax, -0x3fc(%rbp)
callq 0x28cb0
movq %rax, -0x410(%rbp)
leaq -0x408(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x28ce0
movq -0x568(%rbp), %rdi
movb $0x0, -0x411(%rbp)
movq -0x408(%rbp), %rsi
movl $0x4, %edx
leaq -0x411(%rbp), %rcx
callq 0x28fa0
movq %rax, -0x560(%rbp)
jmp 0x23c91
movq -0x560(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x3b9(%rbp), %rsi
callq 0x290b0
jmp 0x23cb4
leaq -0x240(%rbp), %rdi
movq %rdi, -0x578(%rbp)
callq 0x28cb0
movq %rax, -0x430(%rbp)
leaq -0x428(%rbp), %rdi
leaq -0x430(%rbp), %rsi
callq 0x28ce0
movq -0x578(%rbp), %rdi
movq -0x3b8(%rbp), %rdx
movzbl -0x3b9(%rbp), %eax
movq %rdx, %rcx
addq %rax, %rcx
movq -0x428(%rbp), %rsi
callq 0x28c10
movq %rax, -0x570(%rbp)
jmp 0x23d11
movq -0x570(%rbp), %rax
movq %rax, -0x438(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x28040
movl %eax, -0x43c(%rbp)
movq -0x398(%rbp), %rdi
callq 0x217a0
movq %rax, -0x448(%rbp)
movq -0x398(%rbp), %rdi
callq 0x21800
movq %rax, -0x450(%rbp)
leaq -0x448(%rbp), %rdi
leaq -0x450(%rbp), %rsi
callq 0x29120
testb $0x1, %al
jne 0x23d73
jmp 0x23f8d
leaq -0x448(%rbp), %rdi
callq 0x29150
movq (%rax), %rax
movq %rax, -0x458(%rbp)
movq -0x458(%rbp), %rdi
callq 0x21030
movb %al, -0x459(%rbp)
leaq -0x240(%rbp), %rdi
leaq -0x459(%rbp), %rsi
callq 0x28d20
jmp 0x23db0
movq -0x458(%rbp), %rdi
callq 0x21030
movzbl %al, %eax
addl $-0x43, %eax
movl %eax, %ecx
movq %rcx, -0x580(%rbp)
subl $0x29, %eax
ja 0x23f78
movq -0x580(%rbp), %rax
leaq 0x12ee2(%rip), %rcx     # 0x36cc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x458(%rbp), %rdi
callq 0x21110
movl (%rax), %esi
leaq -0x240(%rbp), %rdi
callq 0x24210
jmp 0x23e07
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21110
movq (%rax), %rsi
leaq -0x240(%rbp), %rdi
callq 0x24270
jmp 0x23e29
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21110
movss (%rax), %xmm0
leaq -0x240(%rbp), %rdi
callq 0x242d0
jmp 0x23e4c
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21110
movsd (%rax), %xmm0
leaq -0x240(%rbp), %rdi
callq 0x24330
jmp 0x23e6f
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21110
movzbl (%rax), %esi
andl $0x1, %esi
leaq -0x240(%rbp), %rdi
callq 0x24390
jmp 0x23e94
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21110
movswl (%rax), %esi
leaq -0x240(%rbp), %rdi
callq 0x24400
jmp 0x23eb6
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21150
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x24460
jmp 0x23ed8
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21150
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x24970
jmp 0x23efa
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21150
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x24e80
jmp 0x23f19
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21150
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x25390
jmp 0x23f38
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21150
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x258a0
jmp 0x23f57
jmp 0x23f7a
movq -0x458(%rbp), %rdi
callq 0x21520
movq %rax, %rsi
leaq -0x240(%rbp), %rdi
callq 0x25db0
jmp 0x23f76
jmp 0x23f7a
jmp 0x23f7a
jmp 0x23f7c
leaq -0x448(%rbp), %rdi
callq 0x29180
jmp 0x23d44
leaq -0x240(%rbp), %rdi
movq %rdi, -0x598(%rbp)
callq 0x28040
movq -0x598(%rbp), %rdi
movl %eax, -0x460(%rbp)
movl -0x460(%rbp), %eax
movl -0x43c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x464(%rbp)
leaq -0x464(%rbp), %rax
movq %rax, -0x470(%rbp)
movq -0x470(%rbp), %rax
movb (%rax), %al
movb %al, -0x59b(%rbp)
movl -0x3fc(%rbp), %eax
movl %eax, %esi
callq 0x28f50
movb -0x59b(%rbp), %cl
movq -0x598(%rbp), %rdi
movb %cl, (%rax)
movq -0x470(%rbp), %rax
movb 0x1(%rax), %al
movb %al, -0x59a(%rbp)
movl -0x3fc(%rbp), %eax
incl %eax
movl %eax, %esi
callq 0x28f50
movb -0x59a(%rbp), %cl
movq -0x598(%rbp), %rdi
movb %cl, (%rax)
movq -0x470(%rbp), %rax
movb 0x2(%rax), %al
movb %al, -0x599(%rbp)
movl -0x3fc(%rbp), %eax
addl $0x2, %eax
movl %eax, %esi
callq 0x28f50
movb -0x599(%rbp), %cl
movq -0x598(%rbp), %rdi
movb %cl, (%rax)
movq -0x470(%rbp), %rax
movb 0x3(%rax), %al
movb %al, -0x589(%rbp)
movl -0x3fc(%rbp), %eax
addl $0x3, %eax
movl %eax, %esi
callq 0x28f50
movb -0x589(%rbp), %cl
movb %cl, (%rax)
movq -0x390(%rbp), %rdi
callq 0x25e60
movq %rax, -0x588(%rbp)
jmp 0x24094
movq -0x588(%rbp), %rax
cmpq $0x0, %rax
je 0x24149
movq -0x390(%rbp), %rdi
callq 0x25e80
movq %rax, -0x5a8(%rbp)
jmp 0x240ba
movq -0x5a8(%rbp), %rax
movq %rax, -0x4a8(%rbp)
movq -0x390(%rbp), %rdi
callq 0x25eb0
movq %rax, -0x5b0(%rbp)
jmp 0x240dd
movq -0x5b0(%rbp), %rax
movq %rax, -0x4b0(%rbp)
movl $0x0, -0x4b4(%rbp)
leaq -0x4a0(%rbp), %rdi
leaq -0x4a8(%rbp), %rsi
leaq -0x4b0(%rbp), %rdx
leaq -0x4b4(%rbp), %rcx
callq 0x28de0
jmp 0x24118
leaq -0x488(%rbp), %rdi
movq %rdi, -0x5b8(%rbp)
leaq -0x4a0(%rbp), %rsi
callq 0x28e80
movq -0x5b8(%rbp), %rsi
leaq -0x2f0(%rbp), %rdi
callq 0x28db0
jmp 0x24147
jmp 0x24149
jmp 0x2387a
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
movq %rdi, -0x5c8(%rbp)
callq 0x28f50
movq -0x5c8(%rbp), %rdi
movq %rax, -0x5c0(%rbp)
callq 0x28040
movq -0x5c0(%rbp), %rsi
movq %rax, %rdx
leaq -0x218(%rbp), %rdi
callq 0x33f0
jmp 0x24190
leaq -0x2f0(%rbp), %rdi
callq 0x291a0
leaq -0x240(%rbp), %rdi
callq 0x27e20
leaq -0x218(%rbp), %rdi
callq 0x3450
addq $0x5d0, %rsp            # imm = 0x5D0
popq %rbp
retq
leaq -0x240(%rbp), %rdi
callq 0x27e20
leaq -0x218(%rbp), %rdi
callq 0x3450
movq -0x220(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)