; assembly                                                                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                     | /* bdlc_compactedarray.t/assume @ 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;
                                                                                                                                                                                                                                                                                     |     signed 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 r12, rdx                                                                                                                                                                                                                                                          |     r12 = rdx;
    0x00431b31 mov rbx, rsi                                                                                                                                                                                                                                                          |     rbx = 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 r13, 0x6db6db6db6db6db7                                                                                                                                                                                                                                        |     r13 = 0x6db6db6db6db6db7;
    0x00431b53 imul rdi, r13                                                                                                                                                                                                                                                         |     rdi *= r13;
    0x00431b57 cmp rsi, rdi                                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (rsi > rdi) {
    0x00431b5a jbe 0x431c08                                                                                                                                                                                                                                                          |         
    0x00431b60 mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |         rdi = *((r14 + 0x18));
    0x00431b64 mov rax, qword [r12]                                                                                                                                                                                                                                                  |         rax = *(r12);
    0x00431b68 mov qword [rbp + 0x30], rax                                                                                                                                                                                                                                           |         *((rbp + 0x30)) = rax;
    0x00431b6c movups xmm0, xmmword [rbx]                                                                                                                                                                                                                                            |         __asm ("movups xmm0, xmmword [rbx]");
    0x00431b6f movups xmm1, xmmword [rbx + 0x10]                                                                                                                                                                                                                                     |         __asm ("movups xmm1, xmmword [rbx + 0x10]");
    0x00431b73 movups xmmword [rbp], xmm0                                                                                                                                                                                                                                            |         __asm ("movups xmmword [rbp], xmm0");
    0x00431b77 movups xmmword [rbp + 0x10], xmm1                                                                                                                                                                                                                                     |         __asm ("movups xmmword [rbp + 0x10], xmm1");
    0x00431b7b mov rax, qword [rbx + 0x20]                                                                                                                                                                                                                                           |         rax = *((rbx + 0x20));
    0x00431b7f mov qword [rbp + 0x20], rax                                                                                                                                                                                                                                           |         *((rbp + 0x20)) = rax;
    0x00431b83 mov qword [rbp + 0x28], rdi                                                                                                                                                                                                                                           |         *((rbp + 0x28)) = rdi;
    0x00431b87 cmp rax, 0x17                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rax != 0x17) {
    0x00431b8b je 0x431be9                                                                                                                                                                                                                                                           |             
    0x00431b8d mov rax, qword [rbx + 0x18]                                                                                                                                                                                                                                           |             rax = *((rbx + 0x18));
    0x00431b91 cmp rax, 0x17                                                                                                                                                                                                                                                         |             
    0x00431b95 mov esi, 0x17                                                                                                                                                                                                                                                         |             esi = 0x17;
                                                                                                                                                                                                                                                                                     |             if (rax > 0x17) {
    0x00431b9a cmova rsi, rax                                                                                                                                                                                                                                                        |                 rsi = rax;
                                                                                                                                                                                                                                                                                     |             }
    0x00431b9e mov qword [rbp], 0                                                                                                                                                                                                                                                    |             *(rbp) = 0;
    0x00431ba6 mov qword [rbp + 0x18], rax                                                                                                                                                                                                                                           |             *((rbp + 0x18)) = rax;
    0x00431baa mov qword [rbp + 0x20], rsi                                                                                                                                                                                                                                           |             *((rbp + 0x20)) = rsi;
    0x00431bae cmp rax, 0x18                                                                                                                                                                                                                                                         |             
                                                                                                                                                                                                                                                                                     |             if (rax >= 0x18) {
    0x00431bb2 jb 0x431bc8                                                                                                                                                                                                                                                           |                 
    0x00431bb4 inc rsi                                                                                                                                                                                                                                                               |                 rsi++;
    0x00431bb7 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |                 rax = *(rdi);
    0x00431bba call qword [rax + 0x10]                                                                                                                                                                                                                                               |                 rax = uint64_t (*rax + 0x10)() ();
    0x00431bbd mov qword [rbp], rax                                                                                                                                                                                                                                                  |                 *(rbp) = rax;
    0x00431bc1 cmp qword [rbp + 0x20], 0x17                                                                                                                                                                                                                                          |                 
                                                                                                                                                                                                                                                                                     |                 if (*((rbp + 0x20)) != 0x17) {
    0x00431bc6 jne 0x431bcb                                                                                                                                                                                                                                                          |                     goto label_3;
                                                                                                                                                                                                                                                                                     |                 }
                                                                                                                                                                                                                                                                                     |             }
    0x00431bc8 mov rax, rbp                                                                                                                                                                                                                                                          |             rax = rbp;
                                                                                                                                                                                                                                                                                     | label_3:
    0x00431bcb mov rdx, qword [rbp + 0x18]                                                                                                                                                                                                                                           |             rdx = *((rbp + 0x18));
    0x00431bcf inc rdx                                                                                                                                                                                                                                                               |             rdx++;
                                                                                                                                                                                                                                                                                     |             if (rdx == 0) {
    0x00431bd2 je 0x431be9                                                                                                                                                                                                                                                           |                 goto label_4;
                                                                                                                                                                                                                                                                                     |             }
    0x00431bd4 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |             
                                                                                                                                                                                                                                                                                     |             if (*((rbx + 0x20)) != 0x17) {
    0x00431bd9 je 0x431bde                                                                                                                                                                                                                                                           |                 
    0x00431bdb mov rbx, qword [rbx]                                                                                                                                                                                                                                                  |                 rbx = *(rbx);
                                                                                                                                                                                                                                                                                     |             }
    0x00431bde mov rdi, rax                                                                                                                                                                                                                                                          |             
    0x00431be1 mov rsi, rbx                                                                                                                                                                                                                                                          |             
    0x00431be4 call 0x403ea0                                                                                                                                                                                                                                                         |             memcpy (rax, rbx, rdx);
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_4:
    0x00431be9 mov rax, qword [r14 + 8]                                                                                                                                                                                                                                              |         rax = *((r14 + 8));
    0x00431bed add rax, 0x38                                                                                                                                                                                                                                                         |         rax += 0x38;
    0x00431bf1 mov qword [r14 + 8], rax                                                                                                                                                                                                                                              |         *((r14 + 8)) = rax;
                                                                                                                                                                                                                                                                                     | label_2:
    0x00431bf5 add rax, 0xffffffffffffffc8                                                                                                                                                                                                                                           |         rax += 0xffffffffffffffc8;
    0x00431bf9 add rsp, 0x38                                                                                                                                                                                                                                                         |         
    0x00431bfd pop rbx                                                                                                                                                                                                                                                               |         
    0x00431bfe pop r12                                                                                                                                                                                                                                                               |         
    0x00431c00 pop r13                                                                                                                                                                                                                                                               |         
    0x00431c02 pop r14                                                                                                                                                                                                                                                               |         
    0x00431c04 pop r15                                                                                                                                                                                                                                                               |         
    0x00431c06 pop rbp                                                                                                                                                                                                                                                               |         
    0x00431c07 ret                                                                                                                                                                                                                                                                   |         return rax;
                                                                                                                                                                                                                                                                                     |     }
    0x00431c08 inc rdi                                                                                                                                                                                                                                                               |     rdi++;
    0x00431c0b movabs rdx, 0x492492492492492                                                                                                                                                                                                                                         |     rdx = 0x492492492492492;
    0x00431c15 call 0x4497b0                                                                                                                                                                                                                                                         |     rax = bsl::Vector_Util::computeNewCapacity(unsigned long,unsigned long,unsigned long) (rdi, rsi, rdx);
    0x00431c1a mov rbp, rax                                                                                                                                                                                                                                                          |     
    0x00431c1d mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rdi = *((r14 + 0x18));
    0x00431c21 xorps xmm0, xmm0                                                                                                                                                                                                                                                      |     __asm ("xorps xmm0, xmm0");
    0x00431c24 movaps xmmword [rsp], xmm0                                                                                                                                                                                                                                            |     *(rsp) = xmm0;
    0x00431c28 mov qword [rsp + 0x10], 0                                                                                                                                                                                                                                             |     *((rsp + 0x10)) = 0;
    0x00431c31 mov qword [rsp + 0x18], rdi                                                                                                                                                                                                                                           |     *((rsp + 0x18)) = rdi;
    0x00431c36 imul rsi, rax, 0x38                                                                                                                                                                                                                                                   |     rsi = rax * 0x38;
    0x00431c3a mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431c3d call qword [rax + 0x10]                                                                                                                                                                                                                                               |     rax = uint64_t (*rax + 0x10)() ();
    0x00431c40 mov r15, rax                                                                                                                                                                                                                                                          |     r15 = rax;
    0x00431c43 mov qword [rsp + 8], rax                                                                                                                                                                                                                                              |     *((rsp + 8)) = rax;
    0x00431c48 mov qword [rsp], rax                                                                                                                                                                                                                                                  |     *(rsp) = rax;
    0x00431c4c mov qword [rsp + 0x10], rbp                                                                                                                                                                                                                                           |     *((rsp + 0x10)) = rbp;
    0x00431c51 mov rbp, qword [r14 + 8]                                                                                                                                                                                                                                              |     rbp = *((r14 + 8));
    0x00431c55 mov rdi, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rdi = *((r14 + 0x18));
    0x00431c59 sub rbp, qword [r14]                                                                                                                                                                                                                                                  |     rbp -= *(r14);
    0x00431c5c mov rax, rbp                                                                                                                                                                                                                                                          |     rax = rbp;
    0x00431c5f sar rax, 3                                                                                                                                                                                                                                                            |     rax >>= 3;
    0x00431c63 imul rax, r13                                                                                                                                                                                                                                                         |     rax *= r13;
    0x00431c67 mov qword [rsp + 0x28], rax                                                                                                                                                                                                                                           |     *((rsp + 0x28)) = rax;
    0x00431c6c lea r13, [r15 + rbp]                                                                                                                                                                                                                                                  |     r13 = r15 + rbp;
    0x00431c70 mov rax, qword [r12]                                                                                                                                                                                                                                                  |     rax = *(r12);
    0x00431c74 mov qword [r15 + rbp + 0x30], rax                                                                                                                                                                                                                                     |     *((r15 + rbp + 0x30)) = rax;
    0x00431c79 movups xmm0, xmmword [rbx]                                                                                                                                                                                                                                            |     __asm ("movups xmm0, xmmword [rbx]");
    0x00431c7c movups xmm1, xmmword [rbx + 0x10]                                                                                                                                                                                                                                     |     __asm ("movups xmm1, xmmword [rbx + 0x10]");
    0x00431c80 movups xmmword [r15 + rbp], xmm0                                                                                                                                                                                                                                      |     __asm ("movups xmmword [r15 + rbp], xmm0");
    0x00431c85 movups xmmword [r15 + rbp + 0x10], xmm1                                                                                                                                                                                                                               |     __asm ("movups xmmword [r15 + rbp + 0x10], xmm1");
    0x00431c8b mov rax, qword [rbx + 0x20]                                                                                                                                                                                                                                           |     rax = *((rbx + 0x20));
    0x00431c8f mov qword [r15 + rbp + 0x20], rax                                                                                                                                                                                                                                     |     *((r15 + rbp + 0x20)) = rax;
    0x00431c94 lea rcx, [r15 + rbp + 0x20]                                                                                                                                                                                                                                           |     rcx = r15 + rbp + 0x20;
    0x00431c99 mov qword [rsp + 0x20], rcx                                                                                                                                                                                                                                           |     *((rsp + 0x20)) = rcx;
    0x00431c9e mov qword [r15 + rbp + 0x28], rdi                                                                                                                                                                                                                                     |     *((r15 + rbp + 0x28)) = rdi;
    0x00431ca3 cmp rax, 0x17                                                                                                                                                                                                                                                         |     
                                                                                                                                                                                                                                                                                     |     if (rax != 0x17) {
    0x00431ca7 je 0x431d18                                                                                                                                                                                                                                                           |         
    0x00431ca9 mov rax, qword [rbx + 0x18]                                                                                                                                                                                                                                           |         rax = *((rbx + 0x18));
    0x00431cad cmp rax, 0x17                                                                                                                                                                                                                                                         |         
    0x00431cb1 mov esi, 0x17                                                                                                                                                                                                                                                         |         esi = 0x17;
                                                                                                                                                                                                                                                                                     |         if (rax > 0x17) {
    0x00431cb6 cmova rsi, rax                                                                                                                                                                                                                                                        |             rsi = rax;
                                                                                                                                                                                                                                                                                     |         }
    0x00431cba mov qword [r13], 0                                                                                                                                                                                                                                                    |         *(r13) = 0;
    0x00431cc2 imul r12, qword [rsp + 0x28], 0x38                                                                                                                                                                                                                                    |         r12 = *((rsp + 0x28)) * 0x38;
    0x00431cc8 mov qword [r15 + r12 + 0x18], rax                                                                                                                                                                                                                                     |         *((r15 + r12 + 0x18)) = rax;
    0x00431ccd mov rcx, qword [rsp + 0x20]                                                                                                                                                                                                                                           |         rcx = *((rsp + 0x20));
    0x00431cd2 mov qword [rcx], rsi                                                                                                                                                                                                                                                  |         *(rcx) = rsi;
    0x00431cd5 cmp rax, 0x18                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rax >= 0x18) {
    0x00431cd9 jb 0x431cf3                                                                                                                                                                                                                                                           |             
    0x00431cdb inc rsi                                                                                                                                                                                                                                                               |             rsi++;
    0x00431cde mov rax, qword [rdi]                                                                                                                                                                                                                                                  |             rax = *(rdi);
    0x00431ce1 call qword [rax + 0x10]                                                                                                                                                                                                                                               |             rax = uint64_t (*rax + 0x10)() ();
    0x00431ce4 mov qword [r13], rax                                                                                                                                                                                                                                                  |             *(r13) = rax;
    0x00431ce8 mov rcx, qword [rsp + 0x20]                                                                                                                                                                                                                                           |             rcx = *((rsp + 0x20));
    0x00431ced cmp qword [rcx], 0x17                                                                                                                                                                                                                                                 |             
                                                                                                                                                                                                                                                                                     |             if (*(rcx) != 0x17) {
    0x00431cf1 jne 0x431cf6                                                                                                                                                                                                                                                          |                 goto label_5;
                                                                                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                                                                                     |         }
    0x00431cf3 mov rax, r13                                                                                                                                                                                                                                                          |         rax = r13;
                                                                                                                                                                                                                                                                                     | label_5:
    0x00431cf6 lea rcx, [r15 + r12 + 0x18]                                                                                                                                                                                                                                           |         rcx = r15 + r12 + 0x18;
    0x00431cfb mov rdx, qword [rcx]                                                                                                                                                                                                                                                  |         rdx = *(rcx);
    0x00431cfe inc rdx                                                                                                                                                                                                                                                               |         rdx++;
                                                                                                                                                                                                                                                                                     |         if (rdx == 0) {
    0x00431d01 je 0x431d18                                                                                                                                                                                                                                                           |             goto label_6;
                                                                                                                                                                                                                                                                                     |         }
    0x00431d03 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (*((rbx + 0x20)) != 0x17) {
    0x00431d08 je 0x431d0d                                                                                                                                                                                                                                                           |             
    0x00431d0a mov rbx, qword [rbx]                                                                                                                                                                                                                                                  |             rbx = *(rbx);
                                                                                                                                                                                                                                                                                     |         }
    0x00431d0d mov rdi, rax                                                                                                                                                                                                                                                          |         
    0x00431d10 mov rsi, rbx                                                                                                                                                                                                                                                          |         
    0x00431d13 call 0x403ea0                                                                                                                                                                                                                                                         |         memcpy (rax, rbx, rdx);
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     | label_6:
    0x00431d18 lea rbp, [r15 + rbp + 0x28]                                                                                                                                                                                                                                           |     rbp = r15 + rbp + 0x28;
    0x00431d1d mov rdi, qword [rsp]                                                                                                                                                                                                                                                  |     
    0x00431d21 mov rbx, qword [r14]                                                                                                                                                                                                                                                  |     rbx = *(r14);
    0x00431d24 mov r12, qword [r14 + 8]                                                                                                                                                                                                                                              |     r12 = *((r14 + 8));
    0x00431d28 mov rax, qword [r14 + 0x18]                                                                                                                                                                                                                                           |     rax = *((r14 + 0x18));
    0x00431d2c mov qword [rsp + 0x30], rax                                                                                                                                                                                                                                           |     *((rsp + 0x30)) = rax;
    0x00431d31 lea rcx, [rsp + 0x30]                                                                                                                                                                                                                                                 |     
    0x00431d36 mov rsi, rbx                                                                                                                                                                                                                                                          |     
    0x00431d39 mov rdx, r12                                                                                                                                                                                                                                                          |     
    0x00431d3c xor r8d, r8d                                                                                                                                                                                                                                                          |     r8d = 0;
    0x00431d3f call 0x4320a0                                                                                                                                                                                                                                                         |     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);
    0x00431d44 cmp rbx, r12                                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (rbx != r12) {
    0x00431d47 jne 0x431d8a                                                                                                                                                                                                                                                          |         goto label_7;
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     |     do {
    0x00431d49 mov rax, qword [r14]                                                                                                                                                                                                                                                  |         rax = *(r14);
    0x00431d4c mov qword [r14 + 8], rax                                                                                                                                                                                                                                              |         *((r14 + 8)) = rax;
    0x00431d50 add r13, 0x38                                                                                                                                                                                                                                                         |         r13 += 0x38;
    0x00431d54 mov qword [rsp + 8], r13                                                                                                                                                                                                                                              |         *((rsp + 8)) = r13;
    0x00431d59 mov rsi, rsp                                                                                                                                                                                                                                                          |         
    0x00431d5c mov rdi, r14                                                                                                                                                                                                                                                          |         
    0x00431d5f call 0x4497e0                                                                                                                                                                                                                                                         |         bsl::Vector_Util::swap(void*,void*) (r14, rsp);
    0x00431d64 mov rbx, qword [rsp]                                                                                                                                                                                                                                                  |         rbx = *(rsp);
    0x00431d68 test rbx, rbx                                                                                                                                                                                                                                                         |         
                                                                                                                                                                                                                                                                                     |         if (rbx == 0) {
    0x00431d6b je 0x431dd9                                                                                                                                                                                                                                                           |             goto label_8;
                                                                                                                                                                                                                                                                                     |         }
    0x00431d6d mov rbp, qword [rsp + 8]                                                                                                                                                                                                                                              |         rbp = *((rsp + 8));
    0x00431d72 cmp rbx, rbp                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (rbx != rbp) {
    0x00431d75 jne 0x431db1                                                                                                                                                                                                                                                          |             goto label_9;
                                                                                                                                                                                                                                                                                     |         }
    0x00431d77 jmp 0x431dcb                                                                                                                                                                                                                                                          |         goto label_10;
                                                                                                                                                                                                                                                                                     | label_0:
    0x00431d79 mov qword [rbx + 0x18], 0xffffffffffffffff                                                                                                                                                                                                                            |         *((rbx + 0x18)) = 0xffffffffffffffff;
    0x00431d81 add rbx, 0x38                                                                                                                                                                                                                                                         |         rbx += 0x38;
    0x00431d85 cmp r12, rbx                                                                                                                                                                                                                                                          |         
    0x00431d88 je 0x431d49                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (r12 == rbx);
                                                                                                                                                                                                                                                                                     | label_7:
    0x00431d8a cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (*((rbx + 0x20)) == 0x17) {
    0x00431d8f je 0x431d79                                                                                                                                                                                                                                                           |         goto label_0;
                                                                                                                                                                                                                                                                                     |     }
    0x00431d91 mov rsi, qword [rbx]                                                                                                                                                                                                                                                  |     rsi = *(rbx);
    0x00431d94 mov rdi, qword [rbx + 0x28]                                                                                                                                                                                                                                           |     rdi = *((rbx + 0x28));
    0x00431d98 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431d9b call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x00431d9e jmp 0x431d79                                                                                                                                                                                                                                                          |     goto label_0;
                                                                                                                                                                                                                                                                                     |     do {
                                                                                                                                                                                                                                                                                     | label_1:
    0x00431da0 mov qword [rbx + 0x18], 0xffffffffffffffff                                                                                                                                                                                                                            |         *((rbx + 0x18)) = 0xffffffffffffffff;
    0x00431da8 add rbx, 0x38                                                                                                                                                                                                                                                         |         rbx += 0x38;
    0x00431dac cmp rbp, rbx                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (rbp == rbx) {
    0x00431daf je 0x431dc7                                                                                                                                                                                                                                                           |             goto label_11;
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     | label_9:
    0x00431db1 cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |         
    0x00431db6 je 0x431da0                                                                                                                                                                                                                                                           |         
                                                                                                                                                                                                                                                                                     |     } while (*((rbx + 0x20)) == 0x17);
    0x00431db8 mov rsi, qword [rbx]                                                                                                                                                                                                                                                  |     rsi = *(rbx);
    0x00431dbb mov rdi, qword [rbx + 0x28]                                                                                                                                                                                                                                           |     rdi = *((rbx + 0x28));
    0x00431dbf mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431dc2 call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
    0x00431dc5 jmp 0x431da0                                                                                                                                                                                                                                                          |     goto label_1;
                                                                                                                                                                                                                                                                                     | label_11:
    0x00431dc7 mov rbx, qword [rsp]                                                                                                                                                                                                                                                  |     rbx = *(rsp);
                                                                                                                                                                                                                                                                                     | label_10:
    0x00431dcb mov rdi, qword [rsp + 0x18]                                                                                                                                                                                                                                           |     rdi = *((rsp + 0x18));
    0x00431dd0 mov rax, qword [rdi]                                                                                                                                                                                                                                                  |     rax = *(rdi);
    0x00431dd3 mov rsi, rbx                                                                                                                                                                                                                                                          |     rsi = rbx;
    0x00431dd6 call qword [rax + 0x18]                                                                                                                                                                                                                                               |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                                                                     | label_8:
    0x00431dd9 mov rax, qword [r14 + 8]                                                                                                                                                                                                                                              |     rax = *((r14 + 8));
    0x00431ddd jmp 0x431bf5                                                                                                                                                                                                                                                          |     goto label_2;
                                                                                                                                                                                                                                                                                     | }