; assembly                                                                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                     | /* bdlc_compactedarray.t/none @ 0x431b20 */
                                                                                                                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlc::CompactedArray_CountedValue_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char______bsl::vector_BloombergLP::bdlc::CompactedArray_CountedValue_bsl::basic_string_char__std::__1::char_traits_char___bsl::allo ()         | int64_t method_BloombergLP::bdlc::CompactedArray_CountedValue_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_bsl::vector_BloombergLP::bdlc::CompactedArray_CountedValue_bsl::basic_string_char_std::_1::char_traits_char_bsl::allo (int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                                                                     |     int64_t var_8h;
                                                                                                                                                                                                                                                                                     |     int64_t var_10h;
                                                                                                                                                                                                                                                                                     |     int64_t var_18h;
                                                                                                                                                                                                                                                                                     |     uint32_t var_20h;
                                                                                                                                                                                                                                                                                     |     int64_t var_28h;
                                                                                                                                                                                                                                                                                     |     int64_t var_30h;
                                                                                                                                                                                                                                                                                     |     rdx = arg3;
                                                                                                                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                                                                                     |     /* BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > >& bsl::vector<BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > >, bsl::allocator<BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > > >::emplace_back<bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > const&, unsigned long&>(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > const&, unsigned long&) */
    0x00431b20 push rbp                                                                                                                                                                                                                                                              |     
    0x00431b21 push r15                                                                                                                                                                                                                                                              |     
    0x00431b23 push r14                                                                                                                                                                                                                                                              |     
    0x00431b25 push r13                                                                                                                                                                                                                                                              |     
    0x00431b27 push r12                                                                                                                                                                                                                                                              |     
    0x00431b29 push rbx                                                                                                                                                                                                                                                              |     
    0x00431b2a sub rsp, 0x38                                                                                                                                                                                                                                                         |     
    0x00431b2e mov rbx, rdx                                                                                                                                                                                                                                                          |     rbx = rdx;
    0x00431b31 mov r12, rsi                                                                                                                                                                                                                                                          |     r12 = rsi;
    0x00431b34 mov r14, rdi                                                                                                                                                                                                                                                          |     r14 = rdi;
    0x00431b37 mov rbp, qword [rdi + 8]                                                                                                                                                                                                                                              |     rbp = *((rdi + 8));
    0x00431b3b mov rsi, qword [rdi + 0x10]                                                                                                                                                                                                                                           |     rsi = *((rdi + 0x10));
    0x00431b3f mov rdi, rbp                                                                                                                                                                                                                                                          |     rdi = rbp;
    0x00431b42 sub rdi, qword [r14]                                                                                                                                                                                                                                                  |     rdi -= *(r14);
    0x00431b45 sar rdi, 3                                                                                                                                                                                                                                                            |     rdi >>= 3;
    0x00431b49 movabs r15, 0x6db6db6db6db6db7                                                                                                                                                                                                                                        |     r15 = 0x6db6db6db6db6db7;
    0x00431b53 imul rdi, r15                                                                                                                                                                                                                                                         |     rdi *= r15;
    0x00431b57 cmp rsi, rdi                                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (rsi > rdi) {
    0x00431b5a jbe 0x431c28                                                                                                                                                                                                                                                          |         
    0x00431b60 mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |         rdi = *((r14 + 0x18));
    0x00431b64 mov rax, qword [rbx]                                                                                                                                                                                                                                                  |         rax = *(rbx);
    0x00431b67 mov qword [rbp + 0x30], rax                                                                                                                                                                                                                                           |         *((rbp + 0x30)) = rax;
    0x00431b6b test rdi, rdi                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rdi == 0) {
    0x00431b6e jne 0x431b84                                                                                                                                                                                                                                                          |             
    0x00431b70 mov rdi, qword [rip + 0x257e49]                                                                                                                                                                                                                                       |             rdi = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00431b77 test rdi, rdi                                                                                                                                                                                                                                                         |             
                                                                                                                                                                                                                                                                                     |             if (rdi != 0) {
    0x00431b7a jne 0x431b84                                                                                                                                                                                                                                                          |                 goto label_3;
                                                                                                                                                                                                                                                                                     |             }
    0x00431b7c call 0x43d890                                                                                                                                                                                                                                                         |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00431b81 mov rdi, rax                                                                                                                                                                                                                                                          |             rdi = rax;
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_3:
    0x00431b84 mov rax, qword [r12 + 0x20]                                                                                                                                                                                                                                           |         rax = *((r12 + 0x20));
    0x00431b89 mov qword [rbp + 0x20], rax                                                                                                                                                                                                                                           |         *((rbp + 0x20)) = rax;
    0x00431b8d movups xmm0, xmmword [r12]                                                                                                                                                                                                                                            |         __asm ("movups xmm0, xmmword [r12]");
    0x00431b92 movups xmm1, xmmword [r12 + 0x10]                                                                                                                                                                                                                                     |         __asm ("movups xmm1, xmmword [r12 + 0x10]");
    0x00431b98 movups xmmword [rbp + 0x10], xmm1                                                                                                                                                                                                                                     |         __asm ("movups xmmword [rbp + 0x10], xmm1");
    0x00431b9c movups xmmword [rbp], xmm0                                                                                                                                                                                                                                            |         __asm ("movups xmmword [rbp], xmm0");
    0x00431ba0 mov qword [rbp + 0x28], rdi                                                                                                                                                                                                                                           |         *((rbp + 0x28)) = rdi;
    0x00431ba4 cmp rax, 0x17                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rax != 0x17) {
    0x00431ba8 je 0x431c09                                                                                                                                                                                                                                                           |             
    0x00431baa mov rax, qword [r12 + 0x18]                                                                                                                                                                                                                                           |             rax = *((r12 + 0x18));
    0x00431baf cmp rax, 0x17                                                                                                                                                                                                                                                         |             
    0x00431bb3 mov esi, 0x17                                                                                                                                                                                                                                                         |             esi = 0x17;
                                                                                                                                                                                                                                                                                     |             if (rax > 0x17) {
    0x00431bb8 cmova rsi, rax                                                                                                                                                                                                                                                        |                 rsi = rax;
                                                                                                                                                                                                                                                                                     |             }
    0x00431bbc mov qword [rbp], 0                                                                                                                                                                                                                                                    |             *(rbp) = 0;
    0x00431bc4 mov qword [rbp + 0x18], rax                                                                                                                                                                                                                                           |             *((rbp + 0x18)) = rax;
    0x00431bc8 mov qword [rbp + 0x20], rsi                                                                                                                                                                                                                                           |             *((rbp + 0x20)) = rsi;
    0x00431bcc cmp rax, 0x18                                                                                                                                                                                                                                                         |             
                                                                                                                                                                                                                                                                                     |             if (rax >= 0x18) {
    0x00431bd0 jb 0x431be6                                                                                                                                                                                                                                                           |                 
    0x00431bd2 inc rsi                                                                                                                                                                                                                                                               |                 rsi++;
    0x00431bd5 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |                 rax = *(rdi);
    0x00431bd8 call qword [rax + 0x10]                                                                                                                                                                                                                                               |                 rax = uint64_t (*rax + 0x10)() ();
    0x00431bdb mov qword [rbp], rax                                                                                                                                                                                                                                                  |                 *(rbp) = rax;
    0x00431bdf cmp qword [rbp + 0x20], 0x17                                                                                                                                                                                                                                          |                 
                                                                                                                                                                                                                                                                                     |                 if (*((rbp + 0x20)) != 0x17) {
    0x00431be4 jne 0x431be9                                                                                                                                                                                                                                                          |                     goto label_4;
                                                                                                                                                                                                                                                                                     |                 }
                                                                                                                                                                                                                                                                                     |             }
    0x00431be6 mov rax, rbp                                                                                                                                                                                                                                                          |             rax = rbp;
                                                                                                                                                                                                                                                                                     | label_4:
    0x00431be9 mov rdx, qword [rbp + 0x18]                                                                                                                                                                                                                                           |             rdx = *((rbp + 0x18));
    0x00431bed inc rdx                                                                                                                                                                                                                                                               |             rdx++;
                                                                                                                                                                                                                                                                                     |             if (rdx == 0) {
    0x00431bf0 je 0x431c09                                                                                                                                                                                                                                                           |                 goto label_5;
                                                                                                                                                                                                                                                                                     |             }
    0x00431bf2 cmp qword [r12 + 0x20], 0x17                                                                                                                                                                                                                                          |             
                                                                                                                                                                                                                                                                                     |             if (*((r12 + 0x20)) != 0x17) {
    0x00431bf8 je 0x431bfe                                                                                                                                                                                                                                                           |                 
    0x00431bfa mov r12, qword [r12]                                                                                                                                                                                                                                                  |                 r12 = *(r12);
                                                                                                                                                                                                                                                                                     |             }
    0x00431bfe mov rdi, rax                                                                                                                                                                                                                                                          |             
    0x00431c01 mov rsi, r12                                                                                                                                                                                                                                                          |             
    0x00431c04 call 0x403ea0                                                                                                                                                                                                                                                         |             memcpy (rax, r12, rdx);
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_5:
    0x00431c09 mov rax, qword [r14 + 8]                                                                                                                                                                                                                                              |         rax = *((r14 + 8));
    0x00431c0d add rax, 0x38                                                                                                                                                                                                                                                         |         rax += 0x38;
    0x00431c11 mov qword [r14 + 8], rax                                                                                                                                                                                                                                              |         *((r14 + 8)) = rax;
                                                                                                                                                                                                                                                                                     | label_2:
    0x00431c15 add rax, 0xffffffffffffffc8                                                                                                                                                                                                                                           |         rax += 0xffffffffffffffc8;
    0x00431c19 add rsp, 0x38                                                                                                                                                                                                                                                         |         
    0x00431c1d pop rbx                                                                                                                                                                                                                                                               |         
    0x00431c1e pop r12                                                                                                                                                                                                                                                               |         
    0x00431c20 pop r13                                                                                                                                                                                                                                                               |         
    0x00431c22 pop r14                                                                                                                                                                                                                                                               |         
    0x00431c24 pop r15                                                                                                                                                                                                                                                               |         
    0x00431c26 pop rbp                                                                                                                                                                                                                                                               |         
    0x00431c27 ret                                                                                                                                                                                                                                                                   |         return rax;
                                                                                                                                                                                                                                                                                     |     }
    0x00431c28 inc rdi                                                                                                                                                                                                                                                               |     rdi++;
    0x00431c2b movabs rdx, 0x492492492492492                                                                                                                                                                                                                                         |     rdx = 0x492492492492492;
    0x00431c35 call 0x449ac0                                                                                                                                                                                                                                                         |     rax = bsl::Vector_Util::computeNewCapacity(unsigned long,unsigned long,unsigned long) (rdi, rsi, rdx);
    0x00431c3a mov r13, rax                                                                                                                                                                                                                                                          |     r13 = rax;
    0x00431c3d mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rdi = *((r14 + 0x18));
    0x00431c41 xorps xmm0, xmm0                                                                                                                                                                                                                                                      |     __asm ("xorps xmm0, xmm0");
    0x00431c44 movaps xmmword [rsp], xmm0                                                                                                                                                                                                                                            |     *(rsp) = xmm0;
    0x00431c48 mov qword [rsp + 0x10], 0                                                                                                                                                                                                                                             |     *((rsp + 0x10)) = 0;
    0x00431c51 mov qword [rsp + 0x18], rdi                                                                                                                                                                                                                                           |     *((rsp + 0x18)) = rdi;
    0x00431c56 imul rsi, rax, 0x38                                                                                                                                                                                                                                                   |     rsi = rax * 0x38;
    0x00431c5a mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431c5d call qword [rax + 0x10]                                                                                                                                                                                                                                               |     rax = uint64_t (*rax + 0x10)() ();
    0x00431c60 mov rbp, rax                                                                                                                                                                                                                                                          |     
    0x00431c63 mov qword [rsp + 8], rax                                                                                                                                                                                                                                              |     *((rsp + 8)) = rax;
    0x00431c68 mov qword [rsp], rax                                                                                                                                                                                                                                                  |     *(rsp) = rax;
    0x00431c6c mov qword [rsp + 0x10], r13                                                                                                                                                                                                                                           |     *((rsp + 0x10)) = r13;
    0x00431c71 mov r13, qword [r14 + 8]                                                                                                                                                                                                                                              |     r13 = *((r14 + 8));
    0x00431c75 sub r13, qword [r14]                                                                                                                                                                                                                                                  |     r13 -= *(r14);
    0x00431c78 mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rdi = *((r14 + 0x18));
    0x00431c7c mov rax, qword [rbx]                                                                                                                                                                                                                                                  |     rax = *(rbx);
    0x00431c7f mov qword [rbp + r13 + 0x30], rax                                                                                                                                                                                                                                     |     *((rbp + r13 + 0x30)) = rax;
    0x00431c84 test rdi, rdi                                                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                                                     |     if (rdi == 0) {
    0x00431c87 jne 0x431c9d                                                                                                                                                                                                                                                          |         
    0x00431c89 mov rdi, qword [rip + 0x257d30]                                                                                                                                                                                                                                       |         rdi = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00431c90 test rdi, rdi                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rdi != 0) {
    0x00431c93 jne 0x431c9d                                                                                                                                                                                                                                                          |             goto label_6;
                                                                                                                                                                                                                                                                                     |         }
    0x00431c95 call 0x43d890                                                                                                                                                                                                                                                         |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
    0x00431c9a mov rdi, rax                                                                                                                                                                                                                                                          |         rdi = rax;
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     | label_6:
    0x00431c9d lea rbx, [rbp + r13]                                                                                                                                                                                                                                                  |     rbx = rbp + r13;
    0x00431ca2 sar r13, 3                                                                                                                                                                                                                                                            |     r13 >>= 3;
    0x00431ca6 imul r13, r15                                                                                                                                                                                                                                                         |     r13 *= r15;
    0x00431caa mov rax, qword [r12 + 0x20]                                                                                                                                                                                                                                           |     rax = *((r12 + 0x20));
    0x00431caf mov qword [rbx + 0x20], rax                                                                                                                                                                                                                                           |     *((rbx + 0x20)) = rax;
    0x00431cb3 movups xmm0, xmmword [r12]                                                                                                                                                                                                                                            |     __asm ("movups xmm0, xmmword [r12]");
    0x00431cb8 movups xmm1, xmmword [r12 + 0x10]                                                                                                                                                                                                                                     |     __asm ("movups xmm1, xmmword [r12 + 0x10]");
    0x00431cbe movups xmmword [rbx + 0x10], xmm1                                                                                                                                                                                                                                     |     __asm ("movups xmmword [rbx + 0x10], xmm1");
    0x00431cc2 movups xmmword [rbx], xmm0                                                                                                                                                                                                                                            |     __asm ("movups xmmword [rbx], xmm0");
    0x00431cc5 imul r15, r13, 0x38                                                                                                                                                                                                                                                   |     r15 = r13 * 0x38;
    0x00431cc9 mov qword [rbp + r15 + 0x28], rdi                                                                                                                                                                                                                                     |     *((rbp + r15 + 0x28)) = rdi;
    0x00431cce lea r13, [rbp + r15 + 0x20]                                                                                                                                                                                                                                           |     r13 = rbp + r15 + 0x20;
    0x00431cd3 cmp qword [rbp + r15 + 0x20], 0x17                                                                                                                                                                                                                                    |     
                                                                                                                                                                                                                                                                                     |     if (*((rbp + r15 + 0x20)) != 0x17) {
    0x00431cd9 je 0x431d3d                                                                                                                                                                                                                                                           |         
    0x00431cdb mov rax, qword [r12 + 0x18]                                                                                                                                                                                                                                           |         rax = *((r12 + 0x18));
    0x00431ce0 cmp rax, 0x17                                                                                                                                                                                                                                                         |         
    0x00431ce4 mov esi, 0x17                                                                                                                                                                                                                                                         |         esi = 0x17;
                                                                                                                                                                                                                                                                                     |         if (rax > 0x17) {
    0x00431ce9 cmova rsi, rax                                                                                                                                                                                                                                                        |             rsi = rax;
                                                                                                                                                                                                                                                                                     |         }
    0x00431ced mov qword [rbx], 0                                                                                                                                                                                                                                                    |         *(rbx) = 0;
    0x00431cf4 mov qword [rbp + r15 + 0x18], rax                                                                                                                                                                                                                                     |         *((rbp + r15 + 0x18)) = rax;
    0x00431cf9 mov qword [r13], rsi                                                                                                                                                                                                                                                  |         *(r13) = rsi;
    0x00431cfd cmp rax, 0x18                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rax >= 0x18) {
    0x00431d01 jb 0x431d16                                                                                                                                                                                                                                                           |             
    0x00431d03 inc rsi                                                                                                                                                                                                                                                               |             rsi++;
    0x00431d06 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |             rax = *(rdi);
    0x00431d09 call qword [rax + 0x10]                                                                                                                                                                                                                                               |             rax = uint64_t (*rax + 0x10)() ();
    0x00431d0c mov qword [rbx], rax                                                                                                                                                                                                                                                  |             *(rbx) = rax;
    0x00431d0f cmp qword [r13], 0x17                                                                                                                                                                                                                                                 |             
                                                                                                                                                                                                                                                                                     |             if (*(r13) != 0x17) {
    0x00431d14 jne 0x431d19                                                                                                                                                                                                                                                          |                 goto label_7;
                                                                                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                                                                                     |         }
    0x00431d16 mov rax, rbx                                                                                                                                                                                                                                                          |         rax = rbx;
                                                                                                                                                                                                                                                                                     | label_7:
    0x00431d19 lea rcx, [rbp + r15 + 0x18]                                                                                                                                                                                                                                           |         rcx = rbp + r15 + 0x18;
    0x00431d1e mov rdx, qword [rcx]                                                                                                                                                                                                                                                  |         rdx = *(rcx);
    0x00431d21 inc rdx                                                                                                                                                                                                                                                               |         rdx++;
                                                                                                                                                                                                                                                                                     |         if (rdx == 0) {
    0x00431d24 je 0x431d3d                                                                                                                                                                                                                                                           |             goto label_8;
                                                                                                                                                                                                                                                                                     |         }
    0x00431d26 cmp qword [r12 + 0x20], 0x17                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (*((r12 + 0x20)) != 0x17) {
    0x00431d2c je 0x431d32                                                                                                                                                                                                                                                           |             
    0x00431d2e mov r12, qword [r12]                                                                                                                                                                                                                                                  |             r12 = *(r12);
                                                                                                                                                                                                                                                                                     |         }
    0x00431d32 mov rdi, rax                                                                                                                                                                                                                                                          |         
    0x00431d35 mov rsi, r12                                                                                                                                                                                                                                                          |         
    0x00431d38 call 0x403ea0                                                                                                                                                                                                                                                         |         memcpy (rax, r12, rdx);
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     | label_8:
    0x00431d3d mov qword [rsp + 0x28], r13                                                                                                                                                                                                                                           |     *((rsp + 0x28)) = r13;
    0x00431d42 mov r13, rbx                                                                                                                                                                                                                                                          |     r13 = rbx;
    0x00431d45 lea rax, [rbp + r15 + 0x28]                                                                                                                                                                                                                                           |     rax = rbp + r15 + 0x28;
    0x00431d4a mov qword [rsp + 0x20], rax                                                                                                                                                                                                                                           |     *((rsp + 0x20)) = rax;
    0x00431d4f mov rdi, qword [rsp]                                                                                                                                                                                                                                                  |     
    0x00431d53 mov rbx, qword [r14]                                                                                                                                                                                                                                                  |     rbx = *(r14);
    0x00431d56 mov r12, qword [r14 + 8]                                                                                                                                                                                                                                              |     r12 = *((r14 + 8));
    0x00431d5a mov rax, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rax = *((r14 + 0x18));
    0x00431d5e mov qword [rsp + 0x30], rax                                                                                                                                                                                                                                           |     *((rsp + 0x30)) = rax;
    0x00431d63 lea rcx, [rsp + 0x30]                                                                                                                                                                                                                                                 |     
    0x00431d68 mov rsi, rbx                                                                                                                                                                                                                                                          |     
    0x00431d6b mov rdx, r12                                                                                                                                                                                                                                                          |     
    0x00431d6e xor r8d, r8d                                                                                                                                                                                                                                                          |     r8d = 0;
    0x00431d71 call 0x4320d0                                                                                                                                                                                                                                                         |     voidBloombergLP::bslalg::ArrayPrimitives_Imp::moveIfNoexcept<BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>,bsl::allocator<BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>>>(BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>*,BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>*,BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>*,bsl::allocator<BloombergLP::bdlc::CompactedArray_CountedValue<bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>>>,BloombergLP::bslmf::MetaInt<0>*) (*(rsp), rbx, r12, rsp + 0x30);
    0x00431d76 cmp rbx, r12                                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (rbx != r12) {
    0x00431d79 jne 0x431dbc                                                                                                                                                                                                                                                          |         goto label_9;
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     |     do {
    0x00431d7b mov rax, qword [r14]                                                                                                                                                                                                                                                  |         rax = *(r14);
    0x00431d7e mov qword [r14 + 8], rax                                                                                                                                                                                                                                              |         *((r14 + 8)) = rax;
    0x00431d82 add r13, 0x38                                                                                                                                                                                                                                                         |         r13 += 0x38;
    0x00431d86 mov qword [rsp + 8], r13                                                                                                                                                                                                                                              |         *((rsp + 8)) = r13;
    0x00431d8b mov rsi, rsp                                                                                                                                                                                                                                                          |         
    0x00431d8e mov rdi, r14                                                                                                                                                                                                                                                          |         
    0x00431d91 call 0x449af0                                                                                                                                                                                                                                                         |         bsl::Vector_Util::swap(void*,void*) (r14, rsp);
    0x00431d96 mov rbx, qword [rsp]                                                                                                                                                                                                                                                  |         rbx = *(rsp);
    0x00431d9a test rbx, rbx                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rbx == 0) {
    0x00431d9d je 0x431e0b                                                                                                                                                                                                                                                           |             goto label_10;
                                                                                                                                                                                                                                                                                     |         }
    0x00431d9f mov rbp, qword [rsp + 8]                                                                                                                                                                                                                                              |         rbp = *((rsp + 8));
    0x00431da4 cmp rbx, rbp                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (rbx != rbp) {
    0x00431da7 jne 0x431de3                                                                                                                                                                                                                                                          |             goto label_11;
                                                                                                                                                                                                                                                                                     |         }
    0x00431da9 jmp 0x431dfd                                                                                                                                                                                                                                                          |         goto label_12;
                                                                                                                                                                                                                                                                                     | label_0:
    0x00431dab mov qword [rbx + 0x18], 0xffffffffffffffff                                                                                                                                                                                                                            |         *((rbx + 0x18)) = 0xffffffffffffffff;
    0x00431db3 add rbx, 0x38                                                                                                                                                                                                                                                         |         rbx += 0x38;
    0x00431db7 cmp r12, rbx                                                                                                                                                                                                                                                          |         
    0x00431dba je 0x431d7b                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (r12 == rbx);
                                                                                                                                                                                                                                                                                     | label_9:
    0x00431dbc cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (*((rbx + 0x20)) == 0x17) {
    0x00431dc1 je 0x431dab                                                                                                                                                                                                                                                           |         goto label_0;
                                                                                                                                                                                                                                                                                     |     }
    0x00431dc3 mov rsi, qword [rbx]                                                                                                                                                                                                                                                  |     rsi = *(rbx);
    0x00431dc6 mov rdi, qword [rbx + 0x28]                                                                                                                                                                                                                                           |     rdi = *((rbx + 0x28));
    0x00431dca mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431dcd call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x00431dd0 jmp 0x431dab                                                                                                                                                                                                                                                          |     goto label_0;
                                                                                                                                                                                                                                                                                     |     do {
                                                                                                                                                                                                                                                                                     | label_1:
    0x00431dd2 mov qword [rbx + 0x18], 0xffffffffffffffff                                                                                                                                                                                                                            |         *((rbx + 0x18)) = 0xffffffffffffffff;
    0x00431dda add rbx, 0x38                                                                                                                                                                                                                                                         |         rbx += 0x38;
    0x00431dde cmp rbp, rbx                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (rbp == rbx) {
    0x00431de1 je 0x431df9                                                                                                                                                                                                                                                           |             goto label_13;
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_11:
    0x00431de3 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |         
    0x00431de8 je 0x431dd2                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (*((rbx + 0x20)) == 0x17);
    0x00431dea mov rsi, qword [rbx]                                                                                                                                                                                                                                                  |     rsi = *(rbx);
    0x00431ded mov rdi, qword [rbx + 0x28]                                                                                                                                                                                                                                           |     rdi = *((rbx + 0x28));
    0x00431df1 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431df4 call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x00431df7 jmp 0x431dd2                                                                                                                                                                                                                                                          |     goto label_1;
                                                                                                                                                                                                                                                                                     | label_13:
    0x00431df9 mov rbx, qword [rsp]                                                                                                                                                                                                                                                  |     rbx = *(rsp);
                                                                                                                                                                                                                                                                                     | label_12:
    0x00431dfd mov rdi, qword [rsp + 0x18]                                                                                                                                                                                                                                           |     rdi = *((rsp + 0x18));
    0x00431e02 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431e05 mov rsi, rbx                                                                                                                                                                                                                                                          |     rsi = rbx;
    0x00431e08 call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                                                                     | label_10:
    0x00431e0b mov rax, qword [r14 + 8]                                                                                                                                                                                                                                              |     rax = *((r14 + 8));
    0x00431e0f jmp 0x431c15                                                                                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                                                                                     | }