; assembly                                                                                                                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                             | /* ball_record.t/assume @ 0x413430 */
                                                                                                                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                                                                                                                             |  
    ; (fcn) method.BloombergLP::ball::UserFieldValue_bsl::vector_BloombergLP::ball::UserFieldValue__bsl::allocator_BloombergLP::ball::UserFieldValue___::emplace_back_bsl::vector_char__bsl.allocator_char____const__bsl::vector_char__bsl::allocator_char____const_ ()      | int64_t method_BloombergLP::ball::UserFieldValue_bsl::vector_BloombergLP::ball::UserFieldValue_bsl::allocator_BloombergLP::ball::UserFieldValue_::emplace_back_bsl::vector_char_bsl_allocator_char_const_bsl::vector_char_bsl::allocator_char_const_ (int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                                                                                             |     int64_t var_8h;
                                                                                                                                                                                                                                                                             |     int64_t var_10h;
                                                                                                                                                                                                                                                                             |     int64_t var_18h;
                                                                                                                                                                                                                                                                             |     int64_t var_28h;
                                                                                                                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                                                                                                                             |     /* BloombergLP::ball::UserFieldValue& bsl::vector<BloombergLP::ball::UserFieldValue, bsl::allocator<BloombergLP::ball::UserFieldValue> >::emplace_back<bsl::vector<char, bsl::allocator<char> > const&>(bsl::vector<char, bsl::allocator<char> > const&) */
    0x00413430 push r15                                                                                                                                                                                                                                                      |     
    0x00413432 push r14                                                                                                                                                                                                                                                      |     
    0x00413434 push r13                                                                                                                                                                                                                                                      |     
    0x00413436 push r12                                                                                                                                                                                                                                                      |     
    0x00413438 push rbx                                                                                                                                                                                                                                                      |     
    0x00413439 sub rsp, 0x30                                                                                                                                                                                                                                                 |     
    0x0041343d mov r14, rsi                                                                                                                                                                                                                                                  |     r14 = rsi;
    0x00413440 mov r12, rdi                                                                                                                                                                                                                                                  |     r12 = rdi;
    0x00413443 mov rbx, qword [rdi + 8]                                                                                                                                                                                                                                      |     rbx = *((rdi + 8));
    0x00413447 mov rsi, qword [rdi + 0x10]                                                                                                                                                                                                                                   |     rsi = *((rdi + 0x10));
    0x0041344b mov rdi, rbx                                                                                                                                                                                                                                                  |     rdi = rbx;
    0x0041344e sub rdi, qword [r12]                                                                                                                                                                                                                                          |     rdi -= *(r12);
    0x00413452 sar rdi, 6                                                                                                                                                                                                                                                    |     rdi >>= 6;
    0x00413456 cmp rsi, rdi                                                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                                                             |     if (rsi > rdi) {
    0x00413459 jbe 0x4134cf                                                                                                                                                                                                                                                  |         
    0x0041345b mov rax, qword [r12 + 0x18]                                                                                                                                                                                                                                   |         rax = *((r12 + 0x18));
    0x00413460 mov dword [rbx + 0x30], 5                                                                                                                                                                                                                                     |         *((rbx + 0x30)) = 5;
    0x00413467 test rax, rax                                                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                                                             |         if (rax != 0) {
    0x0041346a je 0x413472                                                                                                                                                                                                                                                   |             
    0x0041346c mov qword [rbx + 0x38], rax                                                                                                                                                                                                                                   |             *((rbx + 0x38)) = rax;
    0x00413470 jmp 0x41349d                                                                                                                                                                                                                                                  |             
                                                                                                                                                                                                                                                                             |         } else {
    0x00413472 mov rax, qword [rip + 0x26ea57]                                                                                                                                                                                                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00413479 test rax, rax                                                                                                                                                                                                                                                 |             
                                                                                                                                                                                                                                                                             |             if (rax == 0) {
    0x0041347c jne 0x413483                                                                                                                                                                                                                                                  |                 
    0x0041347e call 0x424c00                                                                                                                                                                                                                                                 |                 rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                                                             |             }
    0x00413483 mov qword [rbx + 0x38], rax                                                                                                                                                                                                                                   |             *((rbx + 0x38)) = rax;
    0x00413487 test rax, rax                                                                                                                                                                                                                                                 |             
                                                                                                                                                                                                                                                                             |             if (rax != 0) {
    0x0041348a jne 0x41349d                                                                                                                                                                                                                                                  |                 goto label_1;
                                                                                                                                                                                                                                                                             |             }
    0x0041348c mov rax, qword [rip + 0x26ea3d]                                                                                                                                                                                                                               |             rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00413493 test rax, rax                                                                                                                                                                                                                                                 |             
                                                                                                                                                                                                                                                                             |             if (rax != 0) {
    0x00413496 jne 0x41349d                                                                                                                                                                                                                                                  |                 goto label_1;
                                                                                                                                                                                                                                                                             |             }
    0x00413498 call 0x424c00                                                                                                                                                                                                                                                 |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                                                             |         }
                                                                                                                                                                                                                                                                             | label_1:
    0x0041349d mov qword [rsp], rax                                                                                                                                                                                                                                          |         *(rsp) = rax;
    0x004134a1 mov rdx, rsp                                                                                                                                                                                                                                                  |         
    0x004134a4 mov rdi, rbx                                                                                                                                                                                                                                                  |         
    0x004134a7 mov rsi, r14                                                                                                                                                                                                                                                  |         
    0x004134aa call 0x4340f0                                                                                                                                                                                                                                                 |         bsl::vector<char,bsl::allocator<char>>::vector(bsl::vector<char,bsl::allocator<char>>const&,bsl::allocator<char>const&) (rbx, r14, rsp);
    0x004134af mov rax, qword [r12 + 8]                                                                                                                                                                                                                                      |         rax = *((r12 + 8));
    0x004134b4 add rax, 0x40                                                                                                                                                                                                                                                 |         rax += 0x40;
    0x004134b8 mov qword [r12 + 8], rax                                                                                                                                                                                                                                      |         *((r12 + 8)) = rax;
                                                                                                                                                                                                                                                                             | label_0:
    0x004134bd add rax, 0xffffffffffffffc0                                                                                                                                                                                                                                   |         rax += 0xffffffffffffffc0;
    0x004134c1 add rsp, 0x30                                                                                                                                                                                                                                                 |         
    0x004134c5 pop rbx                                                                                                                                                                                                                                                       |         
    0x004134c6 pop r12                                                                                                                                                                                                                                                       |         
    0x004134c8 pop r13                                                                                                                                                                                                                                                       |         
    0x004134ca pop r14                                                                                                                                                                                                                                                       |         
    0x004134cc pop r15                                                                                                                                                                                                                                                       |         
    0x004134ce ret                                                                                                                                                                                                                                                           |         return rax;
                                                                                                                                                                                                                                                                             |     }
    0x004134cf inc rdi                                                                                                                                                                                                                                                       |     rdi++;
    0x004134d2 movabs rdx, 0x3ffffffffffffff                                                                                                                                                                                                                                 |     rdx = 0x3ffffffffffffff;
    0x004134dc call 0x430810                                                                                                                                                                                                                                                 |     rax = bsl::Vector_Util::computeNewCapacity(unsigned long,unsigned long,unsigned long) (rdi, rsi, rdx);
    0x004134e1 mov rbx, rax                                                                                                                                                                                                                                                  |     rbx = rax;
    0x004134e4 mov rdi, qword [r12 + 0x18]                                                                                                                                                                                                                                   |     rdi = *((r12 + 0x18));
    0x004134e9 xorps xmm0, xmm0                                                                                                                                                                                                                                              |     __asm ("xorps xmm0, xmm0");
    0x004134ec movaps xmmword [rsp], xmm0                                                                                                                                                                                                                                    |     *(rsp) = xmm0;
    0x004134f0 mov qword [rsp + 0x10], 0                                                                                                                                                                                                                                     |     *((rsp + 0x10)) = 0;
    0x004134f9 mov qword [rsp + 0x18], rdi                                                                                                                                                                                                                                   |     *((rsp + 0x18)) = rdi;
    0x004134fe mov rsi, rax                                                                                                                                                                                                                                                  |     rsi = rax;
    0x00413501 shl rsi, 6                                                                                                                                                                                                                                                    |     rsi <<= 6;
    0x00413505 mov rax, qword [rdi]                                                                                                                                                                                                                                          |     rax = *(rdi);
    0x00413508 call qword [rax + 0x10]                                                                                                                                                                                                                                       |     rax = uint64_t (*rax + 0x10)() ();
    0x0041350b mov r15, rax                                                                                                                                                                                                                                                  |     r15 = rax;
    0x0041350e mov qword [rsp + 8], rax                                                                                                                                                                                                                                      |     *((rsp + 8)) = rax;
    0x00413513 mov qword [rsp], rax                                                                                                                                                                                                                                          |     *(rsp) = rax;
    0x00413517 mov qword [rsp + 0x10], rbx                                                                                                                                                                                                                                   |     *((rsp + 0x10)) = rbx;
    0x0041351c mov r13, qword [r12 + 8]                                                                                                                                                                                                                                      |     r13 = *((r12 + 8));
    0x00413521 sub r13, qword [r12]                                                                                                                                                                                                                                          |     r13 -= *(r12);
    0x00413525 mov rax, qword [r12 + 0x18]                                                                                                                                                                                                                                   |     rax = *((r12 + 0x18));
    0x0041352a mov rbx, r13                                                                                                                                                                                                                                                  |     rbx = r13;
    0x0041352d sar rbx, 6                                                                                                                                                                                                                                                    |     rbx >>= 6;
    0x00413531 mov dword [r15 + r13 + 0x30], 5                                                                                                                                                                                                                               |     *((r15 + r13 + 0x30)) = 5;
    0x0041353a test rax, rax                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                             |     if (rax != 0) {
    0x0041353d je 0x41354a                                                                                                                                                                                                                                                   |         
    0x0041353f shl rbx, 6                                                                                                                                                                                                                                                    |         rbx <<= 6;
    0x00413543 mov qword [r15 + rbx + 0x38], rax                                                                                                                                                                                                                             |         *((r15 + rbx + 0x38)) = rax;
    0x00413548 jmp 0x41357a                                                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                                                             |     } else {
    0x0041354a mov rax, qword [rip + 0x26e97f]                                                                                                                                                                                                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00413551 test rax, rax                                                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                                                             |         if (rax == 0) {
    0x00413554 jne 0x41355b                                                                                                                                                                                                                                                  |             
    0x00413556 call 0x424c00                                                                                                                                                                                                                                                 |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                                                             |         }
    0x0041355b shl rbx, 6                                                                                                                                                                                                                                                    |         rbx <<= 6;
    0x0041355f mov qword [r15 + rbx + 0x38], rax                                                                                                                                                                                                                             |         *((r15 + rbx + 0x38)) = rax;
    0x00413564 test rax, rax                                                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                                                             |         if (rax != 0) {
    0x00413567 jne 0x41357a                                                                                                                                                                                                                                                  |             goto label_2;
                                                                                                                                                                                                                                                                             |         }
    0x00413569 mov rax, qword [rip + 0x26e960]                                                                                                                                                                                                                               |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00413570 test rax, rax                                                                                                                                                                                                                                                 |         
                                                                                                                                                                                                                                                                             |         if (rax != 0) {
    0x00413573 jne 0x41357a                                                                                                                                                                                                                                                  |             goto label_2;
                                                                                                                                                                                                                                                                             |         }
    0x00413575 call 0x424c00                                                                                                                                                                                                                                                 |         rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                                                             | label_2:
    0x0041357a add r15, r13                                                                                                                                                                                                                                                  |     r15 += r13;
    0x0041357d mov qword [rsp + 0x28], rax                                                                                                                                                                                                                                   |     *((rsp + 0x28)) = rax;
    0x00413582 lea rdx, [rsp + 0x28]                                                                                                                                                                                                                                         |     
    0x00413587 mov rdi, r15                                                                                                                                                                                                                                                  |     
    0x0041358a mov rsi, r14                                                                                                                                                                                                                                                  |     
    0x0041358d call 0x4340f0                                                                                                                                                                                                                                                 |     bsl::vector<char,bsl::allocator<char>>::vector(bsl::vector<char,bsl::allocator<char>>const&,bsl::allocator<char>const&) (r15, r14, rsp + 0x28);
    0x00413592 mov rdi, qword [rsp]                                                                                                                                                                                                                                          |     
    0x00413596 mov rbx, qword [r12]                                                                                                                                                                                                                                          |     rbx = *(r12);
    0x0041359a mov r14, qword [r12 + 8]                                                                                                                                                                                                                                      |     r14 = *((r12 + 8));
    0x0041359f mov rax, qword [r12 + 0x18]                                                                                                                                                                                                                                   |     rax = *((r12 + 0x18));
    0x004135a4 mov qword [rsp + 0x28], rax                                                                                                                                                                                                                                   |     *((rsp + 0x28)) = rax;
    0x004135a9 lea rcx, [rsp + 0x28]                                                                                                                                                                                                                                         |     
    0x004135ae mov rsi, rbx                                                                                                                                                                                                                                                  |     
    0x004135b1 mov rdx, r14                                                                                                                                                                                                                                                  |     
    0x004135b4 xor r8d, r8d                                                                                                                                                                                                                                                  |     r8d = 0;
    0x004135b7 call 0x412910                                                                                                                                                                                                                                                 |     voidBloombergLP::bslalg::ArrayPrimitives_Imp::moveIfNoexcept<BloombergLP::ball::UserFieldValue,bsl::allocator<BloombergLP::ball::UserFieldValue>>(BloombergLP::ball::UserFieldValue*,BloombergLP::ball::UserFieldValue*,BloombergLP::ball::UserFieldValue*,bsl::allocator<BloombergLP::ball::UserFieldValue>,BloombergLP::bslmf::MetaInt<0>*) (*(rsp), rbx, r14, rsp + 0x28);
    0x004135bc cmp rbx, r14                                                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                                                             |     if (rbx == r14) {
    0x004135bf je 0x4135d2                                                                                                                                                                                                                                                   |         goto label_3;
                                                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                                                             |     do {
    0x004135c1 mov rdi, rbx                                                                                                                                                                                                                                                  |         
    0x004135c4 call 0x412ba0                                                                                                                                                                                                                                                 |         BloombergLP::bdlb::VariantImp<BloombergLP::bslmf::TypeList<long long,double,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,BloombergLP::bdlt::DatetimeTz,bsl::vector<char,bsl::allocator<char>>>>::reset() (rbx, rsi);
    0x004135c9 add rbx, 0x40                                                                                                                                                                                                                                                 |         rbx += 0x40;
    0x004135cd cmp r14, rbx                                                                                                                                                                                                                                                  |         
    0x004135d0 jne 0x4135c1                                                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                                                             |     } while (r14 != rbx);
                                                                                                                                                                                                                                                                             | label_3:
    0x004135d2 mov rax, qword [r12]                                                                                                                                                                                                                                          |     rax = *(r12);
    0x004135d6 mov qword [r12 + 8], rax                                                                                                                                                                                                                                      |     *((r12 + 8)) = rax;
    0x004135db add r15, 0x40                                                                                                                                                                                                                                                 |     r15 += 0x40;
    0x004135df mov qword [rsp + 8], r15                                                                                                                                                                                                                                      |     *((rsp + 8)) = r15;
    0x004135e4 mov rsi, rsp                                                                                                                                                                                                                                                  |     
    0x004135e7 mov rdi, r12                                                                                                                                                                                                                                                  |     
    0x004135ea call 0x430840                                                                                                                                                                                                                                                 |     bsl::Vector_Util::swap(void*,void*) (r12, rsp);
    0x004135ef mov rbx, qword [rsp]                                                                                                                                                                                                                                          |     rbx = *(rsp);
    0x004135f3 test rbx, rbx                                                                                                                                                                                                                                                 |     
                                                                                                                                                                                                                                                                             |     if (rbx == 0) {
    0x004135f6 je 0x413625                                                                                                                                                                                                                                                   |         goto label_4;
                                                                                                                                                                                                                                                                             |     }
    0x004135f8 mov r14, qword [rsp + 8]                                                                                                                                                                                                                                      |     r14 = *((rsp + 8));
    0x004135fd cmp rbx, r14                                                                                                                                                                                                                                                  |     
                                                                                                                                                                                                                                                                             |     if (rbx == r14) {
    0x00413600 je 0x413617                                                                                                                                                                                                                                                   |         goto label_5;
                                                                                                                                                                                                                                                                             |     }
                                                                                                                                                                                                                                                                             |     do {
    0x00413602 mov rdi, rbx                                                                                                                                                                                                                                                  |         
    0x00413605 call 0x412ba0                                                                                                                                                                                                                                                 |         BloombergLP::bdlb::VariantImp<BloombergLP::bslmf::TypeList<long long,double,bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>,BloombergLP::bdlt::DatetimeTz,bsl::vector<char,bsl::allocator<char>>>>::reset() (rbx, rsi);
    0x0041360a add rbx, 0x40                                                                                                                                                                                                                                                 |         rbx += 0x40;
    0x0041360e cmp r14, rbx                                                                                                                                                                                                                                                  |         
    0x00413611 jne 0x413602                                                                                                                                                                                                                                                  |         
                                                                                                                                                                                                                                                                             |     } while (r14 != rbx);
    0x00413613 mov rbx, qword [rsp]                                                                                                                                                                                                                                          |     rbx = *(rsp);
                                                                                                                                                                                                                                                                             | label_5:
    0x00413617 mov rdi, qword [rsp + 0x18]                                                                                                                                                                                                                                   |     rdi = *((rsp + 0x18));
    0x0041361c mov rax, qword [rdi]                                                                                                                                                                                                                                          |     rax = *(rdi);
    0x0041361f mov rsi, rbx                                                                                                                                                                                                                                                  |     rsi = rbx;
    0x00413622 call qword [rax + 0x18]                                                                                                                                                                                                                                       |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                                                             | label_4:
    0x00413625 mov rax, qword [r12 + 8]                                                                                                                                                                                                                                      |     rax = *((r12 + 8));
    0x0041362a jmp 0x4134bd                                                                                                                                                                                                                                                  |     goto label_0;
                                                                                                                                                                                                                                                                             | }