; assembly                                                                                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                                                                                 | /* balb_filecleanerutil.t/none @ 0x411ef0 */
                                                                                                                                                                                                 | #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&) */
    0x00411ef0 push rbp                                                                                                                                                                          |         
    0x00411ef1 push r15                                                                                                                                                                          |         
    0x00411ef3 push r14                                                                                                                                                                          |         
    0x00411ef5 push r13                                                                                                                                                                          |         
    0x00411ef7 push r12                                                                                                                                                                          |         
    0x00411ef9 push rbx                                                                                                                                                                          |         
    0x00411efa sub rsp, 0x48                                                                                                                                                                     |         
    0x00411efe mov r14, rsi                                                                                                                                                                      |         r14 = rsi;
    0x00411f01 mov r15, rdi                                                                                                                                                                      |         r15 = rdi;
    0x00411f04 cmp qword [rdi + 0x20], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((rdi + 0x20)) == 0x17) {
    0x00411f09 jne 0x411f10                                                                                                                                                                      |             
    0x00411f0b mov rax, r15                                                                                                                                                                      |             rax = r15;
    0x00411f0e jmp 0x411f13                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x00411f10 mov rax, qword [r15]                                                                                                                                                              |             rax = *(r15);
                                                                                                                                                                                                 |         }
    0x00411f13 mov r12, qword [r15 + 0x18]                                                                                                                                                       |         r12 = *((r15 + 0x18));
    0x00411f17 mov rbx, qword [r14]                                                                                                                                                              |         rbx = *(r14);
    0x00411f1a cmp rbx, rax                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rbx < rax) {
    0x00411f1d jb 0x411fc3                                                                                                                                                                       |             goto label_0;
                                                                                                                                                                                                 |         }
    0x00411f23 add rax, r12                                                                                                                                                                      |         rax += r12;
    0x00411f26 cmp rbx, rax                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rbx >= rax) {
    0x00411f29 jae 0x411fc3                                                                                                                                                                      |             goto label_0;
                                                                                                                                                                                                 |         }
    0x00411f2f mov r14, qword [r14 + 8]                                                                                                                                                          |         r14 = *((r14 + 8));
    0x00411f33 mov rax, qword [rip + 0x25bd96]                                                                                                                                                   |         rax = BloombergLP::bslma::Default::s_defaultAllocator;
    0x00411f3a test rax, rax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (rax == 0) {
    0x00411f3d jne 0x411f44                                                                                                                                                                      |             
    0x00411f3f call 0x4173a0                                                                                                                                                                     |             rax = BloombergLP::bslma::Default::determineAndReturnDefaultAllocator() ();
                                                                                                                                                                                                 |         }
    0x00411f44 mov qword [rsp + 8], 0                                                                                                                                                            |         *((rsp + 8)) = 0;
    0x00411f4d mov qword [rsp + 0x30], rax                                                                                                                                                       |         *((rsp + 0x30)) = rax;
    0x00411f52 movaps xmm0, xmmword [rip + 0x2a557]                                                                                                                                              |         xmm0 = .comment;
    0x00411f59 movups xmmword [rsp + 0x20], xmm0                                                                                                                                                 |         __asm ("movups xmmword [rsp + 0x20], xmm0");
    0x00411f5e lea rbp, [rsp + 8]                                                                                                                                                                |         rbp = rsp + 8;
    0x00411f63 mov ecx, 0x43c9fe                                                                                                                                                                 |         
    0x00411f68 mov rdi, rbp                                                                                                                                                                      |         
    0x00411f6b mov rsi, rbx                                                                                                                                                                      |         
    0x00411f6e mov rdx, r14                                                                                                                                                                      |         
    0x00411f71 call 0x41a440                                                                                                                                                                     |         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");
    0x00411f76 mov rax, qword [rsp + 0x20]                                                                                                                                                       |         rax = *((rsp + 0x20));
    0x00411f7b cmp qword [rsp + 0x28], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((rsp + 0x28)) != 0x17) {
    0x00411f81 je 0x411f88                                                                                                                                                                       |             
    0x00411f83 mov rbp, qword [rsp + 8]                                                                                                                                                          |             rbp = *((rsp + 8));
                                                                                                                                                                                                 |         }
    0x00411f88 mov qword [rsp + 0x38], rbp                                                                                                                                                       |         *((rsp + 0x38)) = rbp;
    0x00411f8d mov qword [rsp + 0x40], rax                                                                                                                                                       |         *((rsp + 0x40)) = rax;
    0x00411f92 lea rsi, [rsp + 0x38]                                                                                                                                                             |         
    0x00411f97 mov rdi, r15                                                                                                                                                                      |         
    0x00411f9a call 0x411ef0                                                                                                                                                                     |         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);
    0x00411f9f mov r13d, eax                                                                                                                                                                     |     r13d = eax;
    0x00411fa2 cmp qword [rsp + 0x28], 0x17                                                                                                                                                      |     
                                                                                                                                                                                                 |     if (*((rsp + 0x28)) == 0x17) {
    0x00411fa8 je 0x41207d                                                                                                                                                                       |         goto label_1;
                                                                                                                                                                                                 |     }
    0x00411fae mov rsi, qword [rsp + 8]                                                                                                                                                          |     rsi = *((rsp + 8));
    0x00411fb3 mov rdi, qword [rsp + 0x30]                                                                                                                                                       |     rdi = *((rsp + 0x30));
    0x00411fb8 mov rax, qword [rdi]                                                                                                                                                              |     rax = *(rdi);
    0x00411fbb call qword [rax + 0x18]                                                                                                                                                           |     uint64_t (*rax + 0x18)() ();
    0x00411fbe jmp 0x41207d                                                                                                                                                                      |     goto label_1;
                                                                                                                                                                                                 | label_0:
    0x00411fc3 mov rbp, qword [r14 + 8]                                                                                                                                                          |     rbp = *((r14 + 8));
    0x00411fc7 mov eax, ebp                                                                                                                                                                      |     eax = ebp;
    0x00411fc9 test ebp, ebp                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (ebp >= 0) {
    0x00411fcb js 0x411fd3                                                                                                                                                                       |         
    0x00411fcd test eax, eax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (eax <= 0) {
    0x00411fcf jg 0x411fdf                                                                                                                                                                       |             
    0x00411fd1 jmp 0x411fee                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x00411fd3 mov rdi, rbx                                                                                                                                                                      |             
    0x00411fd6 call 0x404a70                                                                                                                                                                     |             eax = strlen (rbx);
    0x00411fdb test eax, eax                                                                                                                                                                     |             
                                                                                                                                                                                                 |             if (eax <= 0) {
    0x00411fdd jle 0x411fee                                                                                                                                                                      |                 goto label_2;
                                                                                                                                                                                                 |             }
                                                                                                                                                                                                 |         }
    0x00411fdf mov r13d, 0xffffffff                                                                                                                                                              |         r13d = 0xffffffff;
    0x00411fe5 cmp byte [rbx], 0x2f                                                                                                                                                              |         
                                                                                                                                                                                                 |         if (*(rbx) == 0x2f) {
    0x00411fe8 je 0x41207d                                                                                                                                                                       |             goto label_1;
                                                                                                                                                                                                 |         }
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_2:
    0x00411fee mov eax, ebp                                                                                                                                                                      |     eax = ebp;
    0x00411ff0 mov r13d, ebp                                                                                                                                                                     |     r13d = ebp;
    0x00411ff3 sar r13d, 0x1f                                                                                                                                                                    |     r13d >>= 0x1f;
    0x00411ff7 and r13d, ebp                                                                                                                                                                     |     r13d &= ebp;
    0x00411ffa nop word [rax + rax]                                                                                                                                                              |     
                                                                                                                                                                                                 |     do {
    0x00412000 test eax, eax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (eax <= 0) {
    0x00412002 jle 0x412017                                                                                                                                                                      |             goto label_3;
                                                                                                                                                                                                 |         }
    0x00412004 lea rcx, [rax - 1]                                                                                                                                                                |         rcx = rax - 1;
    0x00412008 cmp byte [rbx + rax - 1], 0x2f                                                                                                                                                    |         
    0x0041200d mov rax, rcx                                                                                                                                                                      |         rax = rcx;
    0x00412010 je 0x412000                                                                                                                                                                       |         
                                                                                                                                                                                                 |     } while (*((rbx + rax - 1)) == 0x2f);
    0x00412012 inc ecx                                                                                                                                                                           |     ecx++;
    0x00412014 mov r13d, ecx                                                                                                                                                                     |     r13d = ecx;
                                                                                                                                                                                                 | label_3:
    0x00412017 test r12, r12                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (r12 != 0) {
    0x0041201a je 0x412067                                                                                                                                                                       |         
    0x0041201c mov esi, 0x43d408                                                                                                                                                                 |         
    0x00412021 mov ecx, 1                                                                                                                                                                        |         
    0x00412026 mov rdi, r15                                                                                                                                                                      |         
    0x00412029 mov rdx, 0xffffffffffffffff                                                                                                                                                       |         
    0x00412030 call 0x41dd60                                                                                                                                                                     |         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);
    0x00412035 xor ecx, ecx                                                                                                                                                                      |         ecx = 0;
    0x00412037 cmp rax, 0xffffffffffffffff                                                                                                                                                       |         
                                                                                                                                                                                                 |         if (rax != -1) {
    0x0041203b cmovne rcx, rax                                                                                                                                                                   |             rcx = rax;
                                                                                                                                                                                                 |         }
    0x0041203f mov rdx, qword [r15 + 0x18]                                                                                                                                                       |         rdx = *((r15 + 0x18));
    0x00412043 cmp rcx, rdx                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rcx == rdx) {
    0x00412046 je 0x412067                                                                                                                                                                       |             goto label_4;
                                                                                                                                                                                                 |         }
    0x00412048 cmp qword [r15 + 0x20], 0x17                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (*((r15 + 0x20)) == 0x17) {
    0x0041204d jne 0x412054                                                                                                                                                                      |             
    0x0041204f mov rax, r15                                                                                                                                                                      |             rax = r15;
    0x00412052 jmp 0x412057                                                                                                                                                                      |             
                                                                                                                                                                                                 |         } else {
    0x00412054 mov rax, qword [r15]                                                                                                                                                              |             rax = *(r15);
                                                                                                                                                                                                 |         }
    0x00412057 lea rsi, [rax + rcx + 1]                                                                                                                                                          |         
    0x0041205c add rdx, rax                                                                                                                                                                      |         rdx += rax;
    0x0041205f mov rdi, r15                                                                                                                                                                      |         
    0x00412062 call 0x41c5e0                                                                                                                                                                     |         bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::erase(char const*,char const*) (r15, rax + rcx + 1, rdx);
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_4:
    0x00412067 mov rsi, qword [r14]                                                                                                                                                              |     
    0x0041206a mov rdi, r15                                                                                                                                                                      |     
    0x0041206d mov edx, r13d                                                                                                                                                                     |     
    0x00412070 mov ecx, 0xffffffff                                                                                                                                                               |     
    0x00412075 call 0x4120d0                                                                                                                                                                     |     BloombergLP::bdls::PathUtil::appendRaw(bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>*,char const*,int,int) (r15, *(r14), r13d, 0xffffffff);
    0x0041207a xor r13d, r13d                                                                                                                                                                    |     r13d = 0;
                                                                                                                                                                                                 | label_1:
    0x0041207d mov eax, r13d                                                                                                                                                                     |     eax = r13d;
    0x00412080 add rsp, 0x48                                                                                                                                                                     |     
    0x00412084 pop rbx                                                                                                                                                                           |     
    0x00412085 pop r12                                                                                                                                                                           |     
    0x00412087 pop r13                                                                                                                                                                           |     
    0x00412089 pop r14                                                                                                                                                                           |     
    0x0041208b pop r15                                                                                                                                                                           |     
    0x0041208d pop rbp                                                                                                                                                                           |     
    0x0041208e ret                                                                                                                                                                               |     return rax;
                                                                                                                                                                                                 | }