; assembly                                                                                                                                                                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                 | /* ball_log.t/assume @ 0x4988f0 */
                                                                                                                                                                                                                                                                                 | #include <stdint.h>
                                                                                                                                                                                                                                                                                 |  
    ; (fcn) method.BloombergLP::ball::UserFieldValue_bsl::vector_BloombergLP::ball::UserFieldValue__bsl::allocator_BloombergLP::ball::UserFieldValue___::emplace_back_std::__1::basic_string_view_char__std::__1.char_traits_char____const__std::__1::basic_string_view_ ()      | int64_t method_BloombergLP::ball::UserFieldValue_bsl::vector_BloombergLP::ball::UserFieldValue_bsl::allocator_BloombergLP::ball::UserFieldValue_::emplace_back_std::_1::basic_string_view_char_std::_1_char_traits_char_const_std::_1::basic_string_view_ (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<std::__1::basic_string_view<char, std::__1::char_traits<char> > const&>(std::__1::basic_string_view<char, std::__1::char_traits<char> > const&) */
    0x004988f0 push r15                                                                                                                                                                                                                                                          |     
    0x004988f2 push r14                                                                                                                                                                                                                                                          |     
    0x004988f4 push r13                                                                                                                                                                                                                                                          |     
    0x004988f6 push r12                                                                                                                                                                                                                                                          |     
    0x004988f8 push rbx                                                                                                                                                                                                                                                          |     
    0x004988f9 sub rsp, 0x30                                                                                                                                                                                                                                                     |     
    0x004988fd mov r15, rsi                                                                                                                                                                                                                                                      |     r15 = rsi;
    0x00498900 mov rbx, rdi                                                                                                                                                                                                                                                      |     rbx = rdi;
    0x00498903 mov rax, qword [rdi + 8]                                                                                                                                                                                                                                          |     rax = *((rdi + 8));
    0x00498907 mov rsi, qword [rdi + 0x10]                                                                                                                                                                                                                                       |     rsi = *((rdi + 0x10));
    0x0049890b mov rdi, rax                                                                                                                                                                                                                                                      |     rdi = rax;
    0x0049890e sub rdi, qword [rbx]                                                                                                                                                                                                                                              |     rdi -= *(rbx);
    0x00498911 sar rdi, 6                                                                                                                                                                                                                                                        |     rdi >>= 6;
    0x00498915 cmp rsi, rdi                                                                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                                                                 |     if (rsi > rdi) {
    0x00498918 jbe 0x498947                                                                                                                                                                                                                                                      |         
    0x0049891a lea rdi, [rbx + 0x18]                                                                                                                                                                                                                                             |         
    0x0049891e mov rsi, rax                                                                                                                                                                                                                                                      |         
    0x00498921 mov rdx, r15                                                                                                                                                                                                                                                      |         
    0x00498924 call 0x498ad0                                                                                                                                                                                                                                                     |         voidbsl::allocator_traits<bsl::allocator<BloombergLP::ball::UserFieldValue>>::construct<BloombergLP::ball::UserFieldValue,std::_1::basic_string_view<char,std::_1::char_traits<char>>const&>(bsl::allocator<BloombergLP::ball::UserFieldValue>&,BloombergLP::ball::UserFieldValue*,std::_1::basic_string_view<char,std::_1::char_traits<char>>const&) (rbx + 0x18, rax, r15);
    0x00498929 mov rax, qword [rbx + 8]                                                                                                                                                                                                                                          |         rax = *((rbx + 8));
    0x0049892d add rax, 0x40                                                                                                                                                                                                                                                     |         rax += 0x40;
    0x00498931 mov qword [rbx + 8], rax                                                                                                                                                                                                                                          |         *((rbx + 8)) = rax;
                                                                                                                                                                                                                                                                                 | label_0:
    0x00498935 add rax, 0xffffffffffffffc0                                                                                                                                                                                                                                       |         rax += 0xffffffffffffffc0;
    0x00498939 add rsp, 0x30                                                                                                                                                                                                                                                     |         
    0x0049893d pop rbx                                                                                                                                                                                                                                                           |         
    0x0049893e pop r12                                                                                                                                                                                                                                                           |         
    0x00498940 pop r13                                                                                                                                                                                                                                                           |         
    0x00498942 pop r14                                                                                                                                                                                                                                                           |         
    0x00498944 pop r15                                                                                                                                                                                                                                                           |         
    0x00498946 ret                                                                                                                                                                                                                                                               |         return rax;
                                                                                                                                                                                                                                                                                 |     }
    0x00498947 inc rdi                                                                                                                                                                                                                                                           |     rdi++;
    0x0049894a movabs rdx, 0x3ffffffffffffff                                                                                                                                                                                                                                     |     rdx = 0x3ffffffffffffff;
    0x00498954 call 0x4e8200                                                                                                                                                                                                                                                     |     rax = bsl::Vector_Util::computeNewCapacity(unsigned long,unsigned long,unsigned long) (rdi, rsi, rdx);
    0x00498959 mov r14, rax                                                                                                                                                                                                                                                      |     r14 = rax;
    0x0049895c mov rdi, qword [rbx + 0x18]                                                                                                                                                                                                                                       |     rdi = *((rbx + 0x18));
    0x00498960 xorps xmm0, xmm0                                                                                                                                                                                                                                                  |     __asm ("xorps xmm0, xmm0");
    0x00498963 movaps xmmword [rsp], xmm0                                                                                                                                                                                                                                        |     *(rsp) = xmm0;
    0x00498967 mov qword [rsp + 0x10], 0                                                                                                                                                                                                                                         |     *((rsp + 0x10)) = 0;
    0x00498970 mov qword [rsp + 0x18], rdi                                                                                                                                                                                                                                       |     *((rsp + 0x18)) = rdi;
    0x00498975 mov rsi, rax                                                                                                                                                                                                                                                      |     rsi = rax;
    0x00498978 shl rsi, 6                                                                                                                                                                                                                                                        |     rsi <<= 6;
    0x0049897c mov rax, qword [rdi]                                                                                                                                                                                                                                              |     rax = *(rdi);
    0x0049897f call qword [rax + 0x10]                                                                                                                                                                                                                                           |     rax = uint64_t (*rax + 0x10)() ();
    0x00498982 mov r12, rax                                                                                                                                                                                                                                                      |     r12 = rax;
    0x00498985 mov qword [rsp + 8], rax                                                                                                                                                                                                                                          |     *((rsp + 8)) = rax;
    0x0049898a mov qword [rsp], rax                                                                                                                                                                                                                                              |     *(rsp) = rax;
    0x0049898e mov qword [rsp + 0x10], r14                                                                                                                                                                                                                                       |     *((rsp + 0x10)) = r14;
    0x00498993 mov r14, qword [rbx + 8]                                                                                                                                                                                                                                          |     r14 = *((rbx + 8));
    0x00498997 sub r14, qword [rbx]                                                                                                                                                                                                                                              |     r14 -= *(rbx);
    0x0049899a add r14, rax                                                                                                                                                                                                                                                      |     r14 += rax;
    0x0049899d lea rdi, [rbx + 0x18]                                                                                                                                                                                                                                             |     
    0x004989a1 mov rsi, r14                                                                                                                                                                                                                                                      |     
    0x004989a4 mov rdx, r15                                                                                                                                                                                                                                                      |     
    0x004989a7 call 0x498ad0                                                                                                                                                                                                                                                     |     voidbsl::allocator_traits<bsl::allocator<BloombergLP::ball::UserFieldValue>>::construct<BloombergLP::ball::UserFieldValue,std::_1::basic_string_view<char,std::_1::char_traits<char>>const&>(bsl::allocator<BloombergLP::ball::UserFieldValue>&,BloombergLP::ball::UserFieldValue*,std::_1::basic_string_view<char,std::_1::char_traits<char>>const&) (rbx + 0x18, r14, r15);
    0x004989ac mov r15, qword [rbx]                                                                                                                                                                                                                                              |     r15 = *(rbx);
    0x004989af mov r13, qword [rbx + 8]                                                                                                                                                                                                                                          |     r13 = *((rbx + 8));
    0x004989b3 mov rax, qword [rbx + 0x18]                                                                                                                                                                                                                                       |     rax = *((rbx + 0x18));
    0x004989b7 mov qword [rsp + 0x28], rax                                                                                                                                                                                                                                       |     *((rsp + 0x28)) = rax;
    0x004989bc lea rcx, [rsp + 0x28]                                                                                                                                                                                                                                             |     
    0x004989c1 mov rdi, r12                                                                                                                                                                                                                                                      |     
    0x004989c4 mov rsi, r15                                                                                                                                                                                                                                                      |     
    0x004989c7 mov rdx, r13                                                                                                                                                                                                                                                      |     
    0x004989ca xor r8d, r8d                                                                                                                                                                                                                                                      |     r8d = 0;
    0x004989cd call 0x498c00                                                                                                                                                                                                                                                     |     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>*) (r12, r15, r13, rsp + 0x28);
    0x004989d2 cmp r15, r13                                                                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                                                                 |     if (r15 == r13) {
    0x004989d5 je 0x4989e8                                                                                                                                                                                                                                                       |         goto label_1;
                                                                                                                                                                                                                                                                                 |     }
                                                                                                                                                                                                                                                                                 |     do {
    0x004989d7 mov rdi, r15                                                                                                                                                                                                                                                      |         
    0x004989da call 0x498b90                                                                                                                                                                                                                                                     |         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() (r15, rsi, rdx, rcx, r8, r9);
    0x004989df add r15, 0x40                                                                                                                                                                                                                                                     |         r15 += 0x40;
    0x004989e3 cmp r13, r15                                                                                                                                                                                                                                                      |         
    0x004989e6 jne 0x4989d7                                                                                                                                                                                                                                                      |         
                                                                                                                                                                                                                                                                                 |     } while (r13 != r15);
                                                                                                                                                                                                                                                                                 | label_1:
    0x004989e8 mov rax, qword [rbx]                                                                                                                                                                                                                                              |     rax = *(rbx);
    0x004989eb mov qword [rbx + 8], rax                                                                                                                                                                                                                                          |     *((rbx + 8)) = rax;
    0x004989ef add r14, 0x40                                                                                                                                                                                                                                                     |     r14 += 0x40;
    0x004989f3 mov qword [rsp + 8], r14                                                                                                                                                                                                                                          |     *((rsp + 8)) = r14;
    0x004989f8 mov rsi, rsp                                                                                                                                                                                                                                                      |     
    0x004989fb mov rdi, rbx                                                                                                                                                                                                                                                      |     
    0x004989fe call 0x4e8230                                                                                                                                                                                                                                                     |     bsl::Vector_Util::swap(void*,void*) (rbx, rsp);
    0x00498a03 mov r14, qword [rsp]                                                                                                                                                                                                                                              |     r14 = *(rsp);
    0x00498a07 test r14, r14                                                                                                                                                                                                                                                     |     
                                                                                                                                                                                                                                                                                 |     if (r14 == 0) {
    0x00498a0a je 0x498a39                                                                                                                                                                                                                                                       |         goto label_2;
                                                                                                                                                                                                                                                                                 |     }
    0x00498a0c mov r15, qword [rsp + 8]                                                                                                                                                                                                                                          |     r15 = *((rsp + 8));
    0x00498a11 cmp r14, r15                                                                                                                                                                                                                                                      |     
                                                                                                                                                                                                                                                                                 |     if (r14 == r15) {
    0x00498a14 je 0x498a2b                                                                                                                                                                                                                                                       |         goto label_3;
                                                                                                                                                                                                                                                                                 |     }
                                                                                                                                                                                                                                                                                 |     do {
    0x00498a16 mov rdi, r14                                                                                                                                                                                                                                                      |         
    0x00498a19 call 0x498b90                                                                                                                                                                                                                                                     |         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() (r14, rsi, rdx, rcx, r8, r9);
    0x00498a1e add r14, 0x40                                                                                                                                                                                                                                                     |         r14 += 0x40;
    0x00498a22 cmp r15, r14                                                                                                                                                                                                                                                      |         
    0x00498a25 jne 0x498a16                                                                                                                                                                                                                                                      |         
                                                                                                                                                                                                                                                                                 |     } while (r15 != r14);
    0x00498a27 mov r14, qword [rsp]                                                                                                                                                                                                                                              |     r14 = *(rsp);
                                                                                                                                                                                                                                                                                 | label_3:
    0x00498a2b mov rdi, qword [rsp + 0x18]                                                                                                                                                                                                                                       |     rdi = *((rsp + 0x18));
    0x00498a30 mov rax, qword [rdi]                                                                                                                                                                                                                                              |     rax = *(rdi);
    0x00498a33 mov rsi, r14                                                                                                                                                                                                                                                      |     rsi = r14;
    0x00498a36 call qword [rax + 0x18]                                                                                                                                                                                                                                           |     uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                                                                 | label_2:
    0x00498a39 mov rax, qword [rbx + 8]                                                                                                                                                                                                                                          |     rax = *((rbx + 8));
    0x00498a3d jmp 0x498935                                                                                                                                                                                                                                                      |     goto label_0;
                                                                                                                                                                                                                                                                                 | }