; assembly                                                                                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                                                                                 | /* balb_filecleanerutil.t/assume @ 0x411f70 */
                                                                                                                                                                                                 | #include <stdint.h>
                                                                                                                                                                                                 |  
    ; (fcn) method.BloombergLP::bdls::PathUtil.appendIfValid_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____BloombergLP::bslstl::StringRefImp_char__const_ ()      | int64_t method_BloombergLP::bdls::PathUtil_appendIfValid_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_BloombergLP::bslstl::StringRefImp_char_const_ (char * arg2, uint32_t arg1) {
                                                                                                                                                                                                 |     int64_t var_8h;
                                                                                                                                                                                                 |     int64_t var_20h;
                                                                                                                                                                                                 |     uint32_t var_28h;
                                                                                                                                                                                                 |     int64_t var_30h;
                                                                                                                                                                                                 |     int64_t var_38h;
                                                                                                                                                                                                 |     int64_t var_40h;
                                                                                                                                                                                                 |     rsi = arg2;
                                                                                                                                                                                                 |     rdi = arg1;
                                                                                                                                                                                                 |     do {
                                                                                                                                                                                                 |         /* BloombergLP::bdls::PathUtil::appendIfValid(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >*, BloombergLP::bslstl::StringRefImp<char> const&) */
    0x00411f70 push rbp                                                                                                                                                                          |         
    0x00411f71 push r15                                                                                                                                                                          |         
    0x00411f73 push r14                                                                                                                                                                          |         
    0x00411f75 push r13                                                                                                                                                                          |         
    0x00411f77 push r12                                                                                                                                                                          |         
    0x00411f79 push rbx                                                                                                                                                                          |         
    0x00411f7a sub rsp, 0x48                                                                                                                                                                     |         
    0x00411f7e mov r14, rsi                                                                                                                                                                      |         r14 = rsi;
    0x00411f81 mov r15, rdi                                                                                                                                                                      |         r15 = rdi;
    0x00411f84 cmp qword [rdi + 0x20], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((rdi + 0x20)) == 0x17) {
    0x00411f89 jne 0x411f90                                                                                                                                                                      |             
    0x00411f8b mov rax, r15                                                                                                                                                                      |             rax = r15;
    0x00411f8e jmp 0x411f93                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x00411f90 mov rax, qword [r15]                                                                                                                                                              |             rax = *(r15);
                                                                                                                                                                                                 |         }
    0x00411f93 mov r12, qword [r15 + 0x18]                                                                                                                                                       |         r12 = *((r15 + 0x18));
    0x00411f97 mov rbx, qword [r14]                                                                                                                                                              |         rbx = *(r14);
    0x00411f9a cmp rbx, rax                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rbx < rax) {
    0x00411f9d jb 0x412043                                                                                                                                                                       |             goto label_0;
                                                                                                                                                                                                 |         }
    0x00411fa3 add rax, r12                                                                                                                                                                      |         rax += r12;
    0x00411fa6 cmp rbx, rax                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rbx >= rax) {
    0x00411fa9 jae 0x412043                                                                                                                                                                      |             goto label_0;
                                                                                                                                                                                                 |         }
    0x00411faf mov r14, qword [r14 + 8]                                                                                                                                                          |         r14 = *((r14 + 8));
    0x00411fb3 mov rax, qword [rip + 0x25bd16]                                                                                                                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00411fba test rax, rax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (rax == 0) {
    0x00411fbd jne 0x411fc4                                                                                                                                                                      |             
    0x00411fbf call 0x4171b0                                                                                                                                                                     |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                 |         }
    0x00411fc4 mov qword [rsp + 8], 0                                                                                                                                                            |         *((rsp + 8)) = 0;
    0x00411fcd mov qword [rsp + 0x30], rax                                                                                                                                                       |         *((rsp + 0x30)) = rax;
    0x00411fd2 movaps xmm0, xmmword [rip + 0x2a2a7]                                                                                                                                              |         xmm0 = .comment;
    0x00411fd9 movups xmmword [rsp + 0x20], xmm0                                                                                                                                                 |         __asm ("movups xmmword [rsp + 0x20], xmm0");
    0x00411fde lea rbp, [rsp + 8]                                                                                                                                                                |         rbp = rsp + 8;
    0x00411fe3 mov ecx, 0x43c7d0                                                                                                                                                                 |         
    0x00411fe8 mov rdi, rbp                                                                                                                                                                      |         
    0x00411feb mov rsi, rbx                                                                                                                                                                      |         
    0x00411fee mov rdx, r14                                                                                                                                                                      |         
    0x00411ff1 call 0x41a250                                                                                                                                                                     |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (rbp, rbx, r14, "string<...>::assign(char*...): string too long");
    0x00411ff6 mov rax, qword [rsp + 0x20]                                                                                                                                                       |         rax = *((rsp + 0x20));
    0x00411ffb cmp qword [rsp + 0x28], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((rsp + 0x28)) != 0x17) {
    0x00412001 je 0x412008                                                                                                                                                                       |             
    0x00412003 mov rbp, qword [rsp + 8]                                                                                                                                                          |             rbp = *((rsp + 8));
                                                                                                                                                                                                 |         }
    0x00412008 mov qword [rsp + 0x38], rbp                                                                                                                                                       |         *((rsp + 0x38)) = rbp;
    0x0041200d mov qword [rsp + 0x40], rax                                                                                                                                                       |         *((rsp + 0x40)) = rax;
    0x00412012 lea rsi, [rsp + 0x38]                                                                                                                                                             |         
    0x00412017 mov rdi, r15                                                                                                                                                                      |         
    0x0041201a call 0x411f70                                                                                                                                                                     |         eax = BloombergLP::bdls::PathUtil::appendIfValid(bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>*,BloombergLP::bslstl::StringRefImp<char>const&) (r15, rsp + 0x38);
                                                                                                                                                                                                 |     } while (1);
    0x0041201f mov r13d, eax                                                                                                                                                                     |     r13d = eax;
    0x00412022 cmp qword [rsp + 0x28], 0x17                                                                                                                                                      |     
                                                                                                                                                                                                 |     if (*((rsp + 0x28)) == 0x17) {
    0x00412028 je 0x4120f7                                                                                                                                                                       |         goto label_1;
                                                                                                                                                                                                 |     }
    0x0041202e mov rsi, qword [rsp + 8]                                                                                                                                                          |     rsi = *((rsp + 8));
    0x00412033 mov rdi, qword [rsp + 0x30]                                                                                                                                                       |     rdi = *((rsp + 0x30));
    0x00412038 mov rax, qword [rdi]                                                                                                                                                              |     rax = *(rdi);
    0x0041203b call qword [rax + 0x18]                                                                                                                                                           |     uint64_t (*rax + 0x18)() ();
    0x0041203e jmp 0x4120f7                                                                                                                                                                      |     goto label_1;
                                                                                                                                                                                                 | label_0:
    0x00412043 mov ebp, dword [r14 + 8]                                                                                                                                                          |     ebp = *((r14 + 8));
    0x00412047 mov eax, ebp                                                                                                                                                                      |     eax = *((r14 + 8));
    0x00412049 test ebp, ebp                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (ebp >= 0) {
    0x0041204b js 0x412053                                                                                                                                                                       |         
    0x0041204d test eax, eax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (eax <= 0) {
    0x0041204f jg 0x41205f                                                                                                                                                                       |             
    0x00412051 jmp 0x41206e                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x00412053 mov rdi, rbx                                                                                                                                                                      |             
    0x00412056 call 0x404a70                                                                                                                                                                     |             eax = strlen (rbx);
    0x0041205b test eax, eax                                                                                                                                                                     |             
                                                                                                                                                                                                 |             if (eax <= 0) {
    0x0041205d jle 0x41206e                                                                                                                                                                      |                 goto label_2;
                                                                                                                                                                                                 |             }
                                                                                                                                                                                                 |         }
    0x0041205f mov r13d, 0xffffffff                                                                                                                                                              |         r13d = 0xffffffff;
    0x00412065 cmp byte [rbx], 0x2f                                                                                                                                                              |         
                                                                                                                                                                                                 |         if (*(rbx) == 0x2f) {
    0x00412068 je 0x4120f7                                                                                                                                                                       |             goto label_1;
                                                                                                                                                                                                 |         }
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_2:
    0x0041206e mov r13d, ebp                                                                                                                                                                     |     r13d = ebp;
    0x00412071 sar r13d, 0x1f                                                                                                                                                                    |     r13d >>= 0x1f;
    0x00412075 and r13d, ebp                                                                                                                                                                     |     r13d &= ebp;
    0x00412078 nop dword [rax + rax]                                                                                                                                                             |     
                                                                                                                                                                                                 |     do {
    0x00412080 test ebp, ebp                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (ebp <= 0) {
    0x00412082 jle 0x412091                                                                                                                                                                      |             goto label_3;
                                                                                                                                                                                                 |         }
    0x00412084 dec ebp                                                                                                                                                                           |         ebp--;
    0x00412086 cmp byte [rbx + rbp], 0x2f                                                                                                                                                        |         
    0x0041208a je 0x412080                                                                                                                                                                       |         
                                                                                                                                                                                                 |     } while (*((rbx + rbp)) == 0x2f);
    0x0041208c inc ebp                                                                                                                                                                           |     ebp++;
    0x0041208e mov r13d, ebp                                                                                                                                                                     |     r13d = ebp;
                                                                                                                                                                                                 | label_3:
    0x00412091 test r12, r12                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (r12 != 0) {
    0x00412094 je 0x4120e1                                                                                                                                                                       |         
    0x00412096 mov esi, 0x43d1d8                                                                                                                                                                 |         
    0x0041209b mov ecx, 1                                                                                                                                                                        |         
    0x004120a0 mov rdi, r15                                                                                                                                                                      |         
    0x004120a3 mov rdx, 0xffffffffffffffff                                                                                                                                                       |         
    0x004120aa call 0x41db70                                                                                                                                                                     |         rax = bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::find_last_not_of(char const*,unsigned long,unsigned long)const (r15, method.BloombergLP::bdls._anonymous_namespace_::k_separators, 0xffffffffffffffff, 1);
    0x004120af xor ecx, ecx                                                                                                                                                                      |         ecx = 0;
    0x004120b1 cmp rax, 0xffffffffffffffff                                                                                                                                                       |         
                                                                                                                                                                                                 |         if (rax != -1) {
    0x004120b5 cmovne rcx, rax                                                                                                                                                                   |             rcx = rax;
                                                                                                                                                                                                 |         }
    0x004120b9 mov rdx, qword [r15 + 0x18]                                                                                                                                                       |         rdx = *((r15 + 0x18));
    0x004120bd cmp rcx, rdx                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rcx == rdx) {
    0x004120c0 je 0x4120e1                                                                                                                                                                       |             goto label_4;
                                                                                                                                                                                                 |         }
    0x004120c2 cmp qword [r15 + 0x20], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((r15 + 0x20)) == 0x17) {
    0x004120c7 jne 0x4120ce                                                                                                                                                                      |             
    0x004120c9 mov rax, r15                                                                                                                                                                      |             rax = r15;
    0x004120cc jmp 0x4120d1                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x004120ce mov rax, qword [r15]                                                                                                                                                              |             rax = *(r15);
                                                                                                                                                                                                 |         }
    0x004120d1 lea rsi, [rax + rcx + 1]                                                                                                                                                          |         
    0x004120d6 add rdx, rax                                                                                                                                                                      |         rdx += rax;
    0x004120d9 mov rdi, r15                                                                                                                                                                      |         
    0x004120dc call 0x41c3f0                                                                                                                                                                     |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::erase(char const*,char const*) (r15, rax + rcx + 1, rdx);
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_4:
    0x004120e1 mov rsi, qword [r14]                                                                                                                                                              |     
    0x004120e4 mov rdi, r15                                                                                                                                                                      |     
    0x004120e7 mov edx, r13d                                                                                                                                                                     |     
    0x004120ea mov ecx, 0xffffffff                                                                                                                                                               |     
    0x004120ef call 0x412140                                                                                                                                                                     |     BloombergLP::bdls::PathUtil::appendRaw(bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>*,char const*,int,int) (r15, *(r14), r13d, 0xffffffff);
    0x004120f4 xor r13d, r13d                                                                                                                                                                    |     r13d = 0;
                                                                                                                                                                                                 | label_1:
    0x004120f7 mov eax, r13d                                                                                                                                                                     |     eax = r13d;
    0x004120fa add rsp, 0x48                                                                                                                                                                     |     
    0x004120fe pop rbx                                                                                                                                                                           |     
    0x004120ff pop r12                                                                                                                                                                           |     
    0x00412101 pop r13                                                                                                                                                                           |     
    0x00412103 pop r14                                                                                                                                                                           |     
    0x00412105 pop r15                                                                                                                                                                           |     
    0x00412107 pop rbp                                                                                                                                                                           |     
    0x00412108 ret                                                                                                                                                                               |     return rax;
                                                                                                                                                                                                 | }