; assembly                                                                                                                                                                                                                                                                       | /* r2dec pseudo code output */
                                                                                                                                                                                                                                                                                     | /* ball_attribute.t/none @ 0x414cf0 */
                                                                                                                                                                                                                                                                                     | #include <stdint.h>
                                                                                                                                                                                                                                                                                     |  
    ; (fcn) method.BloombergLP::bdlb::VariantImp_BloombergLP::bslmf::TypeList_int__long_long__bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_______.operator_BloombergLP::bdlb::VariantImp_BloombergLP::bslmf::TypeList_int__long_long__bsl::ba ()         | int64_t method_BloombergLP::bdlb::VariantImp_BloombergLP::bslmf::TypeList_int_long_long_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_operator_BloombergLP::bdlb::VariantImp_BloombergLP::bslmf::TypeList_int_long_long_bsl::ba (char * arg2, uint32_t arg1) {
                                                                                                                                                                                                                                                                                     |     int64_t var_8h;
                                                                                                                                                                                                                                                                                     |     rsi = arg2;
                                                                                                                                                                                                                                                                                     |     rdi = arg1;
                                                                                                                                                                                                                                                                                     |     /* BloombergLP::bdlb::VariantImp<BloombergLP::bslmf::TypeList<int, long long, bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > >::operator=(BloombergLP::bdlb::VariantImp<BloombergLP::bslmf::TypeList<int, long long, bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> > > > const&) */
    0x00414cf0 push r15                                                                                                                                                                                                                                                              |     
    0x00414cf2 push r14                                                                                                                                                                                                                                                              |     
    0x00414cf4 push rbx                                                                                                                                                                                                                                                              |     
    0x00414cf5 sub rsp, 0x10                                                                                                                                                                                                                                                         |     
    0x00414cf9 mov rbx, rdi                                                                                                                                                                                                                                                          |     rbx = rdi;
    0x00414cfc cmp rsi, rdi                                                                                                                                                                                                                                                          |     
                                                                                                                                                                                                                                                                                     |     if (rsi != rdi) {
    0x00414cff je 0x414dba                                                                                                                                                                                                                                                           |         
    0x00414d05 mov r14, rsi                                                                                                                                                                                                                                                          |         r14 = rsi;
    0x00414d08 mov eax, dword [rbx + 0x30]                                                                                                                                                                                                                                           |         eax = *((rbx + 0x30));
    0x00414d0b mov ecx, dword [rsi + 0x30]                                                                                                                                                                                                                                           |         ecx = *((rsi + 0x30));
    0x00414d0e cmp eax, ecx                                                                                                                                                                                                                                                          |         
                                                                                                                                                                                                                                                                                     |         if (eax == ecx) {
    0x00414d10 jne 0x414d33                                                                                                                                                                                                                                                          |             
    0x00414d12 cmp eax, 3                                                                                                                                                                                                                                                            |             
                                                                                                                                                                                                                                                                                     |             if (eax != 3) {
    0x00414d15 je 0x414d88                                                                                                                                                                                                                                                           |                 
    0x00414d17 cmp eax, 2                                                                                                                                                                                                                                                            |                 
                                                                                                                                                                                                                                                                                     |                 if (eax != 2) {
    0x00414d1a je 0x414db4                                                                                                                                                                                                                                                           |                     
    0x00414d20 cmp eax, 1                                                                                                                                                                                                                                                            |                     
                                                                                                                                                                                                                                                                                     |                     if (eax != 1) {
    0x00414d23 jne 0x414dba                                                                                                                                                                                                                                                          |                         goto label_0;
                                                                                                                                                                                                                                                                                     |                     }
    0x00414d29 mov eax, dword [r14]                                                                                                                                                                                                                                                  |                     eax = *(r14);
    0x00414d2c mov dword [rbx], eax                                                                                                                                                                                                                                                  |                     *(rbx) = eax;
    0x00414d2e jmp 0x414dba                                                                                                                                                                                                                                                          |                     
    0x00414d33 test eax, eax                                                                                                                                                                                                                                                         |                     
                                                                                                                                                                                                                                                                                     |                 } else {
                                                                                                                                                                                                                                                                                     |                 } else {
                                                                                                                                                                                                                                                                                     |                 } else {
                                                                                                                                                                                                                                                                                     |                     if (eax != 0) {
    0x00414d35 je 0x414d63                                                                                                                                                                                                                                                           |                         
    0x00414d37 cmp eax, 3                                                                                                                                                                                                                                                            |                         
                                                                                                                                                                                                                                                                                     |                         if (eax == 3) {
    0x00414d3a jne 0x414d58                                                                                                                                                                                                                                                          |                             
    0x00414d3c cmp qword [rbx + 0x20], 0x17                                                                                                                                                                                                                                          |                             
                                                                                                                                                                                                                                                                                     |                             if (*((rbx + 0x20)) != 0x17) {
    0x00414d41 je 0x414d50                                                                                                                                                                                                                                                           |                                 
    0x00414d43 mov rsi, qword [rbx]                                                                                                                                                                                                                                                  |                                 rsi = *(rbx);
    0x00414d46 mov rdi, qword [rbx + 0x28]                                                                                                                                                                                                                                           |                                 rdi = *((rbx + 0x28));
    0x00414d4a mov rax, qword [rdi]                                                                                                                                                                                                                                                  |                                 rax = *(rdi);
    0x00414d4d call qword [rax + 0x18]                                                                                                                                                                                                                                               |                                 uint64_t (*rax + 0x18)() ();
                                                                                                                                                                                                                                                                                     |                             }
    0x00414d50 mov qword [rbx + 0x18], 0xffffffffffffffff                                                                                                                                                                                                                            |                             *((rbx + 0x18)) = 0xffffffffffffffff;
                                                                                                                                                                                                                                                                                     |                         }
    0x00414d58 mov dword [rbx + 0x30], 0                                                                                                                                                                                                                                             |                         *((rbx + 0x30)) = 0;
    0x00414d5f mov ecx, dword [r14 + 0x30]                                                                                                                                                                                                                                           |                         ecx = *((r14 + 0x30));
                                                                                                                                                                                                                                                                                     |                     }
    0x00414d63 test ecx, ecx                                                                                                                                                                                                                                                         |                     
                                                                                                                                                                                                                                                                                     |                     if (ecx == 0) {
    0x00414d65 je 0x414dba                                                                                                                                                                                                                                                           |                         goto label_0;
                                                                                                                                                                                                                                                                                     |                     }
    0x00414d67 mov rax, qword [rbx + 0x38]                                                                                                                                                                                                                                           |                     rax = *((rbx + 0x38));
    0x00414d6b mov qword [rsp], rbx                                                                                                                                                                                                                                                  |                     *(rsp) = rbx;
    0x00414d6f mov qword [rsp + 8], rax                                                                                                                                                                                                                                              |                     *((rsp + 8)) = rax;
    0x00414d74 mov rsi, rsp                                                                                                                                                                                                                                                          |                     rsi = rsp;
    0x00414d77 mov rdi, r14                                                                                                                                                                                                                                                          |                     rdi = r14;
    0x00414d7a call 0x414c00                                                                                                                                                                                                                                                         |                     _ZNK11BloombergLP4bdlb10VariantImpINS_5bslmf8TypeListIJixN3bsl12basic_stringIcNSt3_111char_traitsIcEENS4_9allocatorIcEEEEEEEE5applyINS0_28Variant_CopyConstructVisitorEEENS4_9enable_ifIXeqsr25Variant_ReturnValueHelperIT_EE5valueLi0EEvE4typeERSH_ ();
    0x00414d7f mov eax, dword [r14 + 0x30]                                                                                                                                                                                                                                           |                     eax = *((r14 + 0x30));
    0x00414d83 mov dword [rbx + 0x30], eax                                                                                                                                                                                                                                           |                     *((rbx + 0x30)) = eax;
    0x00414d86 jmp 0x414dba                                                                                                                                                                                                                                                          |                     
    0x00414d88 mov rdx, qword [r14 + 0x18]                                                                                                                                                                                                                                           |                     rdx = *((r14 + 0x18));
    0x00414d8c cmp qword [r14 + 0x20], 0x17                                                                                                                                                                                                                                          |                     
                                                                                                                                                                                                                                                                                     |                 }
                                                                                                                                                                                                                                                                                     |             }
                                                                                                                                                                                                                                                                                     |         }
                                                                                                                                                                                                                                                                                     |     }
                                                                                                                                                                                                                                                                                     |     if (*((r14 + 0x20)) != 0x17) {
    0x00414d91 je 0x414d96                                                                                                                                                                                                                                                           |         
    0x00414d93 mov r14, qword [r14]                                                                                                                                                                                                                                                  |         r14 = *(r14);
                                                                                                                                                                                                                                                                                     |     }
    0x00414d96 mov r15, qword [rbx + 0x18]                                                                                                                                                                                                                                           |     r15 = *((rbx + 0x18));
    0x00414d9a mov qword [rbx + 0x18], 0                                                                                                                                                                                                                                             |     *((rbx + 0x18)) = 0;
    0x00414da2 mov ecx, 0x4284ec                                                                                                                                                                                                                                                     |     
    0x00414da7 mov rdi, rbx                                                                                                                                                                                                                                                          |     
    0x00414daa mov rsi, r14                                                                                                                                                                                                                                                          |     
    0x00414dad call 0x41cd10                                                                                                                                                                                                                                                         |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (rbx, r14, rdx, "string<...>::operator=(const string&...): string too long");
    0x00414db2 jmp 0x414dba                                                                                                                                                                                                                                                          |     
    0x00414db4 mov rax, qword [r14]                                                                                                                                                                                                                                                  |     rax = *(r14);
    0x00414db7 mov qword [rbx], rax                                                                                                                                                                                                                                                  |     *(rbx) = rax;
                                                                                                                                                                                                                                                                                     | label_0:
    0x00414dba mov rax, rbx                                                                                                                                                                                                                                                          |     rax = rbx;
    0x00414dbd add rsp, 0x10                                                                                                                                                                                                                                                         |     
    0x00414dc1 pop rbx                                                                                                                                                                                                                                                               |     
    0x00414dc2 pop r14                                                                                                                                                                                                                                                               |     
    0x00414dc4 pop r15                                                                                                                                                                                                                                                               |     
    0x00414dc6 ret                                                                                                                                                                                                                                                                   |     return rax;
                                                                                                                                                                                                                                                                                     | }