; assembly                                                                                                                                                                                   | /* r2dec pseudo code output */
                                                                                                                                                                                                 | /* balb_filecleanerutil.t/none @ 0x4124b0 */
                                                                                                                                                                                                 | #include <stdint.h>
                                                                                                                                                                                                 |  
    ; (fcn) method.BloombergLP::bdls::PathUtil.getLeaf_bsl::basic_string_char__std::__1::char_traits_char___bsl::allocator_char_____BloombergLP::bslstl::StringRefImp_char__const__int_ ()       | int64_t method_BloombergLP::bdls::PathUtil_getLeaf_bsl::basic_string_char_std::_1::char_traits_char_bsl::allocator_char_BloombergLP::bslstl::StringRefImp_char_const_int_ (int64_t arg3, int64_t arg2, int64_t arg1) {
                                                                                                                                                                                                 |     rdx = arg3;
                                                                                                                                                                                                 |     rsi = arg2;
                                                                                                                                                                                                 |     rdi = arg1;
                                                                                                                                                                                                 |     /* BloombergLP::bdls::PathUtil::getLeaf(bsl::basic_string<char, std::__1::char_traits<char>, bsl::allocator<char> >*, BloombergLP::bslstl::StringRefImp<char> const&, int) */
    0x004124b0 push rbp                                                                                                                                                                          |     
    0x004124b1 push r15                                                                                                                                                                          |     
    0x004124b3 push r14                                                                                                                                                                          |     
    0x004124b5 push r13                                                                                                                                                                          |     
    0x004124b7 push r12                                                                                                                                                                          |     
    0x004124b9 push rbx                                                                                                                                                                          |     
    0x004124ba push rax                                                                                                                                                                          |     
    0x004124bb mov ebx, edx                                                                                                                                                                      |     ebx = edx;
    0x004124bd mov r12, rsi                                                                                                                                                                      |     r12 = rsi;
    0x004124c0 mov rsi, rdi                                                                                                                                                                      |     rsi = rdi;
    0x004124c3 mov r13, qword [r12]                                                                                                                                                              |     r13 = *(r12);
    0x004124c7 mov r15, qword [r12 + 8]                                                                                                                                                          |     r15 = *((r12 + 8));
    0x004124cc mov ebp, r15d                                                                                                                                                                     |     
    0x004124cf mov ecx, edx                                                                                                                                                                      |     ecx = edx;
    0x004124d1 test edx, edx                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (edx < 0) {
    0x004124d3 js 0x4125e9                                                                                                                                                                       |         goto label_3;
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_0:
    0x004124d9 mov r14d, r15d                                                                                                                                                                    |     r14d = r15d;
    0x004124dc sar r14d, 0x1f                                                                                                                                                                    |     r14d >>= 0x1f;
    0x004124e0 and r14d, r15d                                                                                                                                                                    |     r14d &= r15d;
    0x004124e3 mov rax, rbp                                                                                                                                                                      |     rax = rbp;
    0x004124e6 nop word cs:[rax + rax]                                                                                                                                                           |     
                                                                                                                                                                                                 |     do {
    0x004124f0 test eax, eax                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (eax <= 0) {
    0x004124f2 jle 0x412507                                                                                                                                                                      |             goto label_4;
                                                                                                                                                                                                 |         }
    0x004124f4 lea rdx, [rax - 1]                                                                                                                                                                |         rdx = rax - 1;
    0x004124f8 cmp byte [r13 + rax - 1], 0x2f                                                                                                                                                    |         
    0x004124fe mov rax, rdx                                                                                                                                                                      |         rax = rdx;
    0x00412501 je 0x4124f0                                                                                                                                                                       |         
                                                                                                                                                                                                 |     } while (*((r13 + rax - 1)) == 0x2f);
    0x00412503 inc edx                                                                                                                                                                           |     edx++;
    0x00412505 jmp 0x41250a                                                                                                                                                                      |     goto label_5;
                                                                                                                                                                                                 | label_4:
    0x00412507 mov edx, r14d                                                                                                                                                                     |     edx = r14d;
                                                                                                                                                                                                 | label_5:
    0x0041250a mov eax, 0xffffffff                                                                                                                                                               |     eax = 0xffffffff;
    0x0041250f cmp ecx, edx                                                                                                                                                                      |     
                                                                                                                                                                                                 |     if (ecx >= edx) {
    0x00412511 jge 0x4125da                                                                                                                                                                      |         goto label_6;
                                                                                                                                                                                                 |     }
    0x00412517 mov r13, rsi                                                                                                                                                                      |     r13 = rsi;
    0x0041251a mov rdi, rsi                                                                                                                                                                      |     
    0x0041251d xor esi, esi                                                                                                                                                                      |     esi = 0;
    0x0041251f call 0x41a800                                                                                                                                                                     |     bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateClear(bool) (rsi);
    0x00412524 mov r12, qword [r12]                                                                                                                                                              |     r12 = *(r12);
    0x00412528 test r15d, r15d                                                                                                                                                                   |     
                                                                                                                                                                                                 |     if (r15d < 0) {
    0x0041252b jns 0x412538                                                                                                                                                                      |         
    0x0041252d mov rdi, r12                                                                                                                                                                      |         
    0x00412530 call 0x404a70                                                                                                                                                                     |         rax = strlen (r12);
    0x00412535 mov r15, rax                                                                                                                                                                      |         r15 = rax;
                                                                                                                                                                                                 |     }
    0x00412538 mov ecx, r15d                                                                                                                                                                     |     ecx = r15d;
    0x0041253b mov eax, r15d                                                                                                                                                                     |     eax = r15d;
    0x0041253e sar eax, 0x1f                                                                                                                                                                     |     eax >>= 0x1f;
    0x00412541 and eax, r15d                                                                                                                                                                     |     eax &= r15d;
    0x00412544 nop word cs:[rax + rax]                                                                                                                                                           |     
    0x0041254e nop                                                                                                                                                                               |     
                                                                                                                                                                                                 |     do {
    0x00412550 test ecx, ecx                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (ecx <= 0) {
    0x00412552 jle 0x412567                                                                                                                                                                      |             goto label_7;
                                                                                                                                                                                                 |         }
    0x00412554 lea rdx, [rcx - 1]                                                                                                                                                                |         rdx = rcx - 1;
    0x00412558 cmp byte [r12 + rcx - 1], 0x2f                                                                                                                                                    |         
    0x0041255e mov rcx, rdx                                                                                                                                                                      |         rcx = rdx;
    0x00412561 je 0x412550                                                                                                                                                                       |         
                                                                                                                                                                                                 |     } while (*((r12 + rcx - 1)) == 0x2f);
    0x00412563 inc edx                                                                                                                                                                           |     edx++;
    0x00412565 mov eax, edx                                                                                                                                                                      |     eax = edx;
                                                                                                                                                                                                 | label_7:
    0x00412567 cdqe                                                                                                                                                                              |     rax = (int64_t) eax;
    0x00412569 movsxd rcx, ebx                                                                                                                                                                   |     rcx = (int64_t) ebx;
    0x0041256c add rcx, r12                                                                                                                                                                      |     rcx += r12;
    0x0041256f lea rdx, [rax + r12 - 1]                                                                                                                                                          |     rdx = rax + r12 - 1;
    0x00412574 nop word cs:[rax + rax]                                                                                                                                                           |     
    0x0041257e nop                                                                                                                                                                               |     
                                                                                                                                                                                                 |     do {
    0x00412580 mov rax, rdx                                                                                                                                                                      |         rax = rdx;
    0x00412583 cmp rdx, rcx                                                                                                                                                                      |         
                                                                                                                                                                                                 |         if (rdx <= rcx) {
    0x00412586 jbe 0x412591                                                                                                                                                                      |             goto label_8;
                                                                                                                                                                                                 |         }
    0x00412588 lea rdx, [rax - 1]                                                                                                                                                                |         rdx = rax - 1;
    0x0041258c cmp byte [rax], 0x2f                                                                                                                                                              |         
    0x0041258f jne 0x412580                                                                                                                                                                      |         
                                                                                                                                                                                                 |     } while (*(rax) != 0x2f);
                                                                                                                                                                                                 | label_8:
    0x00412591 lea rsi, [rax + 1]                                                                                                                                                                |     rsi = rax + 1;
    0x00412595 nop word cs:[rax + rax]                                                                                                                                                           |     
    0x0041259f nop                                                                                                                                                                               |     
                                                                                                                                                                                                 |     do {
    0x004125a0 test ebp, ebp                                                                                                                                                                     |         
                                                                                                                                                                                                 |         if (ebp <= 0) {
    0x004125a2 jle 0x4125b8                                                                                                                                                                      |             goto label_9;
                                                                                                                                                                                                 |         }
    0x004125a4 lea rcx, [rbp - 1]                                                                                                                                                                |         rcx = rbp - 1;
    0x004125a8 cmp byte [r12 + rbp - 1], 0x2f                                                                                                                                                    |         
    0x004125ae mov rbp, rcx                                                                                                                                                                      |         
    0x004125b1 je 0x4125a0                                                                                                                                                                       |         
                                                                                                                                                                                                 |     } while (*((r12 + rbp - 1)) == 0x2f);
    0x004125b3 inc ecx                                                                                                                                                                           |     ecx++;
    0x004125b5 mov r14d, ecx                                                                                                                                                                     |     r14d = ecx;
                                                                                                                                                                                                 | label_9:
    0x004125b8 cmp byte [rax], 0x2f                                                                                                                                                              |     
                                                                                                                                                                                                 |     if (*(rax) != 0x2f) {
    0x004125bb cmovne rsi, rax                                                                                                                                                                   |         rsi = rax;
                                                                                                                                                                                                 |     }
    0x004125bf movsxd rax, r14d                                                                                                                                                                  |     rax = (int64_t) r14d;
    0x004125c2 add r12, rax                                                                                                                                                                      |     r12 += rax;
    0x004125c5 sub r12, rsi                                                                                                                                                                      |     r12 -= rsi;
    0x004125c8 mov ecx, 0x43d40d                                                                                                                                                                 |     
    0x004125cd mov rdi, r13                                                                                                                                                                      |     
    0x004125d0 mov rdx, r12                                                                                                                                                                      |     
    0x004125d3 call 0x41a440                                                                                                                                                                     |     eax = bsl::basic_string<char,std::_1::char_traits<char>,bsl::allocator<char>>::privateAppend(char const*,unsigned long,char const*) (r13, rsi, r12, "string<...>::append<Iter>(i,j): string too long");
    0x004125d8 xor eax, eax                                                                                                                                                                      |     eax = 0;
                                                                                                                                                                                                 | label_6:
    0x004125da add rsp, 8                                                                                                                                                                        |     
    0x004125de pop rbx                                                                                                                                                                           |     
    0x004125df pop r12                                                                                                                                                                           |     
    0x004125e1 pop r13                                                                                                                                                                           |     
    0x004125e3 pop r14                                                                                                                                                                           |     
    0x004125e5 pop r15                                                                                                                                                                           |     
    0x004125e7 pop rbp                                                                                                                                                                           |     
    0x004125e8 ret                                                                                                                                                                               |     return rax;
                                                                                                                                                                                                 | label_3:
    0x004125e9 mov eax, r15d                                                                                                                                                                     |     eax = r15d;
    0x004125ec test r15d, r15d                                                                                                                                                                   |     
                                                                                                                                                                                                 |     if (r15d < 0) {
    0x004125ef js 0x41261e                                                                                                                                                                       |         goto label_10;
                                                                                                                                                                                                 |     }
    0x004125f1 test eax, eax                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (eax <= 0) {
    0x004125f3 jle 0x412630                                                                                                                                                                      |         goto label_11;
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_1:
    0x004125f5 mov eax, eax                                                                                                                                                                      |     
    0x004125f7 xor ebx, ebx                                                                                                                                                                      |     ebx = 0;
    0x004125f9 nop dword [rax]                                                                                                                                                                   |     
                                                                                                                                                                                                 |     do {
    0x00412600 cmp byte [r13 + rbx], 0x2f                                                                                                                                                        |         
                                                                                                                                                                                                 |         if (*((r13 + rbx)) != 0x2f) {
    0x00412606 jne 0x412613                                                                                                                                                                      |             goto label_12;
                                                                                                                                                                                                 |         }
    0x00412608 inc rbx                                                                                                                                                                           |         rbx++;
    0x0041260b cmp rax, rbx                                                                                                                                                                      |         
    0x0041260e jne 0x412600                                                                                                                                                                      |         
                                                                                                                                                                                                 |     } while (rax != rbx);
    0x00412610 mov rbx, rax                                                                                                                                                                      |     rbx = rax;
                                                                                                                                                                                                 | label_12:
    0x00412613 test ebx, ebx                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (ebx < 0) {
    0x00412615 js 0x412639                                                                                                                                                                       |         goto label_13;
                                                                                                                                                                                                 |     }
    0x00412617 mov ecx, ebx                                                                                                                                                                      |     ecx = ebx;
    0x00412619 jmp 0x4124d9                                                                                                                                                                      |     goto label_0;
                                                                                                                                                                                                 | label_10:
    0x0041261e mov rdi, r13                                                                                                                                                                      |     
    0x00412621 mov rbx, rsi                                                                                                                                                                      |     rbx = rsi;
    0x00412624 call 0x404a70                                                                                                                                                                     |     eax = strlen (r13);
    0x00412629 mov rsi, rbx                                                                                                                                                                      |     rsi = rbx;
    0x0041262c test eax, eax                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (eax > 0) {
    0x0041262e jg 0x4125f5                                                                                                                                                                       |         goto label_1;
                                                                                                                                                                                                 |     }
                                                                                                                                                                                                 | label_11:
    0x00412630 xor ebx, ebx                                                                                                                                                                      |     ebx = 0;
    0x00412632 xor ecx, ecx                                                                                                                                                                      |     ecx = 0;
    0x00412634 jmp 0x4124d9                                                                                                                                                                      |     goto label_0;
                                                                                                                                                                                                 | label_13:
    0x00412639 mov eax, r15d                                                                                                                                                                     |     eax = r15d;
    0x0041263c test r15d, r15d                                                                                                                                                                   |     
                                                                                                                                                                                                 |     if (r15d < 0) {
    0x0041263f jns 0x41264f                                                                                                                                                                      |         
    0x00412641 mov rdi, r13                                                                                                                                                                      |         
    0x00412644 mov r14, rsi                                                                                                                                                                      |         r14 = rsi;
    0x00412647 call 0x404a70                                                                                                                                                                     |         eax = strlen (r13);
    0x0041264c mov rsi, r14                                                                                                                                                                      |         rsi = r14;
                                                                                                                                                                                                 |     }
    0x0041264f test eax, eax                                                                                                                                                                     |     
                                                                                                                                                                                                 |     if (eax <= 0) {
    0x00412651 jle 0x41267c                                                                                                                                                                      |         goto label_14;
                                                                                                                                                                                                 |     }
    0x00412653 mov eax, eax                                                                                                                                                                      |     
    0x00412655 xor ecx, ecx                                                                                                                                                                      |     ecx = 0;
    0x00412657 nop word [rax + rax]                                                                                                                                                              |     
                                                                                                                                                                                                 | label_2:
    0x00412660 cmp byte [r13 + rcx], 0x2f                                                                                                                                                        |     
                                                                                                                                                                                                 |     if (*((r13 + rcx)) != 0x2f) {
    0x00412666 jne 0x4124d9                                                                                                                                                                      |         goto label_0;
                                                                                                                                                                                                 |     }
    0x0041266c inc rcx                                                                                                                                                                           |     rcx++;
    0x0041266f cmp rax, rcx                                                                                                                                                                      |     
                                                                                                                                                                                                 |     if (rax != rcx) {
    0x00412672 jne 0x412660                                                                                                                                                                      |         goto label_2;
                                                                                                                                                                                                 |     }
    0x00412674 mov rcx, rax                                                                                                                                                                      |     rcx = rax;
    0x00412677 jmp 0x4124d9                                                                                                                                                                      |     goto label_0;
                                                                                                                                                                                                 | label_14:
    0x0041267c xor ecx, ecx                                                                                                                                                                      |     ecx = 0;
    0x0041267e jmp 0x4124d9                                                                                                                                                                      |     goto label_0;
                                                                                                                                                                                                 | }