; assembly                                                                                                                                                               | /* r2dec pseudo code output */
                                                                                                                                                                             | /* balb_controlmanager.t/none @ 0x40a7e0 */
                                                                                                                                                                             | #include <stdint.h>
                                                                                                                                                                             |  
    ; (fcn) method.bsl::basic_stringbuf_char__std::__1::char_traits_char___bsl::allocator_char___.seekoff_long_long__std::__1::ios_base::seekdir__unsigned_int_ ()           | int64_t method_bsl::basic_stringbuf_char_std::_1::char_traits_char_bsl::allocator_char_seekoff_long_long_std::_1::ios_base::seekdir_unsigned_int_ (int64_t arg4, uint32_t arg3, int32_t arg2, uint32_t arg1) {
                                                                                                                                                                             |     rcx = arg4;
                                                                                                                                                                             |     rdx = arg3;
                                                                                                                                                                             |     rsi = arg2;
                                                                                                                                                                             |     rdi = arg1;
                                                                                                                                                                             |     /* bsl::basic_stringbuf<char, std::__1::char_traits<char>, bsl::allocator<char> >::seekoff(long long, std::__1::ios_base::seekdir, unsigned int) */
    0x0040a7e0 cmp edx, 1                                                                                                                                                    |     
                                                                                                                                                                             |     if (edx == 1) {
    0x0040a7e3 jne 0x40a7fa                                                                                                                                                  |         
    0x0040a7e5 mov eax, ecx                                                                                                                                                  |         eax = ecx;
    0x0040a7e7 and eax, 0x18                                                                                                                                                 |         eax &= 0x18;
    0x0040a7ea mov r8, 0xffffffffffffffff                                                                                                                                    |         r8 = 0xffffffffffffffff;
    0x0040a7f1 cmp eax, 0x18                                                                                                                                                 |         
                                                                                                                                                                             |         if (eax == 0x18) {
    0x0040a7f4 je 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
                                                                                                                                                                             |     }
    0x0040a7fa mov r8, 0xffffffffffffffff                                                                                                                                    |     r8 = 0xffffffffffffffff;
    0x0040a801 test cl, 8                                                                                                                                                    |     
                                                                                                                                                                             |     if ((cl & 8) != 0) {
    0x0040a804 je 0x40a8a3                                                                                                                                                   |         
    0x0040a80a test byte [rdi + 0x78], 8                                                                                                                                     |         
                                                                                                                                                                             |         if ((*((rdi + 0x78)) & 8) == 0) {
    0x0040a80e je 0x40a8a3                                                                                                                                                   |             goto label_1;
                                                                                                                                                                             |         }
    0x0040a814 cmp edx, 2                                                                                                                                                    |         
                                                                                                                                                                             |         if (edx != 2) {
    0x0040a817 je 0x40a828                                                                                                                                                   |             
    0x0040a819 cmp edx, 1                                                                                                                                                    |             
                                                                                                                                                                             |             if (edx != 1) {
    0x0040a81c je 0x40a841                                                                                                                                                   |                 
    0x0040a81e test edx, edx                                                                                                                                                 |                 
                                                                                                                                                                             |                 if (edx != 0) {
    0x0040a820 jne 0x40a84a                                                                                                                                                  |                     goto label_2;
                                                                                                                                                                             |                 }
    0x0040a822 mov r9, qword [rdi + 0x10]                                                                                                                                    |                 r9 = *((rdi + 0x10));
    0x0040a826 jmp 0x40a845                                                                                                                                                  |                 
    0x0040a828 mov r9, qword [rdi + 0x30]                                                                                                                                    |                 r9 = *((rdi + 0x30));
    0x0040a82c sub r9, qword [rdi + 0x28]                                                                                                                                    |                 r9 -= *((rdi + 0x28));
    0x0040a830 mov rax, qword [rdi + 0x70]                                                                                                                                   |                 rax = *((rdi + 0x70));
    0x0040a834 cmp rax, r9                                                                                                                                                   |                 
                                                                                                                                                                             |             } else {
                                                                                                                                                                             |             } else {
                                                                                                                                                                             |                 if (rax >= r9) {
    0x0040a837 cmovge r9, rax                                                                                                                                                |                     r9 = rax;
                                                                                                                                                                             |                 }
    0x0040a83b add r9, qword [rdi + 0x10]                                                                                                                                    |                 r9 += *((rdi + 0x10));
    0x0040a83f jmp 0x40a845                                                                                                                                                  |                 
    0x0040a841 mov r9, qword [rdi + 0x18]                                                                                                                                    |                 r9 = *((rdi + 0x18));
                                                                                                                                                                             |             }
                                                                                                                                                                             |         }
    0x0040a845 add r9, rsi                                                                                                                                                   |         r9 += rsi;
    0x0040a848 jmp 0x40a84d                                                                                                                                                  |         goto label_3;
                                                                                                                                                                             | label_2:
    0x0040a84a xor r9d, r9d                                                                                                                                                  |         r9d = 0;
                                                                                                                                                                             | label_3:
    0x0040a84d mov rax, qword [rdi + 0x10]                                                                                                                                   |         rax = *((rdi + 0x10));
    0x0040a851 mov r8, 0xffffffffffffffff                                                                                                                                    |         r8 = 0xffffffffffffffff;
    0x0040a858 cmp r9, rax                                                                                                                                                   |         
                                                                                                                                                                             |         if (r9 < rax) {
    0x0040a85b jb 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
    0x0040a861 mov r10, qword [rdi + 0x30]                                                                                                                                   |         r10 = *((rdi + 0x30));
    0x0040a865 mov r11, qword [rdi + 0x70]                                                                                                                                   |         r11 = *((rdi + 0x70));
    0x0040a869 sub r10, qword [rdi + 0x28]                                                                                                                                   |         r10 -= *((rdi + 0x28));
    0x0040a86d cmp r11, r10                                                                                                                                                  |         
                                                                                                                                                                             |         if (r11 >= r10) {
    0x0040a870 cmovge r10, r11                                                                                                                                               |             r10 = r11;
                                                                                                                                                                             |         }
    0x0040a874 add rax, r10                                                                                                                                                  |         rax += r10;
    0x0040a877 cmp r9, rax                                                                                                                                                   |         
                                                                                                                                                                             |         if (r9 > rax) {
    0x0040a87a ja 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
    0x0040a880 lea r8, [rdi + 0x40]                                                                                                                                          |         r8 = rdi + 0x40;
    0x0040a884 cmp qword [rdi + 0x60], 0x17                                                                                                                                  |         
                                                                                                                                                                             |         if (*((rdi + 0x60)) != 0x17) {
    0x0040a889 je 0x40a88e                                                                                                                                                   |             
    0x0040a88b mov r8, qword [r8]                                                                                                                                            |             r8 = *(r8);
                                                                                                                                                                             |         }
    0x0040a88e add r10, r8                                                                                                                                                   |         r10 += r8;
    0x0040a891 mov qword [rdi + 0x10], r8                                                                                                                                    |         *((rdi + 0x10)) = r8;
    0x0040a895 mov qword [rdi + 0x18], r9                                                                                                                                    |         *((rdi + 0x18)) = r9;
    0x0040a899 mov qword [rdi + 0x20], r10                                                                                                                                   |         *((rdi + 0x20)) = r10;
    0x0040a89d sub r9, r8                                                                                                                                                    |         r9 -= r8;
    0x0040a8a0 mov r8, r9                                                                                                                                                    |         r8 = r9;
                                                                                                                                                                             |     }
                                                                                                                                                                             | label_1:
    0x0040a8a3 test cl, 0x10                                                                                                                                                 |     
                                                                                                                                                                             |     if ((cl & 0x10) != 0) {
    0x0040a8a6 je 0x40a9bc                                                                                                                                                   |         
    0x0040a8ac test byte [rdi + 0x78], 0x10                                                                                                                                  |         
                                                                                                                                                                             |         if ((*((rdi + 0x78)) & 0x10) == 0) {
    0x0040a8b0 je 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
    0x0040a8b6 cmp edx, 2                                                                                                                                                    |         
                                                                                                                                                                             |         if (edx != 2) {
    0x0040a8b9 je 0x40a8ca                                                                                                                                                   |             
    0x0040a8bb cmp edx, 1                                                                                                                                                    |             
                                                                                                                                                                             |             if (edx != 1) {
    0x0040a8be je 0x40a8e8                                                                                                                                                   |                 
    0x0040a8c0 test edx, edx                                                                                                                                                 |                 
                                                                                                                                                                             |                 if (edx == 0) {
    0x0040a8c2 jne 0x40a8ee                                                                                                                                                  |                     
    0x0040a8c4 add rsi, qword [rdi + 0x28]                                                                                                                                   |                     rsi += *((rdi + 0x28));
    0x0040a8c8 jmp 0x40a8f0                                                                                                                                                  |                     
                                                                                                                                                                             |                 } else {
    0x0040a8ca mov rax, qword [rdi + 0x28]                                                                                                                                   |                     rax = *((rdi + 0x28));
    0x0040a8ce mov rcx, qword [rdi + 0x30]                                                                                                                                   |                     rcx = *((rdi + 0x30));
    0x0040a8d2 sub rcx, rax                                                                                                                                                  |                     rcx -= rax;
    0x0040a8d5 mov rdx, qword [rdi + 0x70]                                                                                                                                   |                     rdx = *((rdi + 0x70));
    0x0040a8d9 cmp rdx, rcx                                                                                                                                                  |                     
                                                                                                                                                                             |                     if (rdx >= rcx) {
    0x0040a8dc cmovge rcx, rdx                                                                                                                                               |                         rcx = rdx;
                                                                                                                                                                             |                     }
    0x0040a8e0 add rcx, rax                                                                                                                                                  |                     rcx += rax;
    0x0040a8e3 add rsi, rcx                                                                                                                                                  |                     rsi += rcx;
    0x0040a8e6 jmp 0x40a8f0                                                                                                                                                  |                     
    0x0040a8e8 add rsi, qword [rdi + 0x30]                                                                                                                                   |                     rsi += *((rdi + 0x30));
    0x0040a8ec jmp 0x40a8f0                                                                                                                                                  |                     
                                                                                                                                                                             |                 } else {
                                                                                                                                                                             |                 } else {
    0x0040a8ee xor esi, esi                                                                                                                                                  |                     esi = 0;
                                                                                                                                                                             |                 }
                                                                                                                                                                             |             }
                                                                                                                                                                             |         }
    0x0040a8f0 mov rax, qword [rdi + 0x28]                                                                                                                                   |         rax = *((rdi + 0x28));
    0x0040a8f4 mov r8, 0xffffffffffffffff                                                                                                                                    |         r8 = 0xffffffffffffffff;
    0x0040a8fb cmp rsi, rax                                                                                                                                                  |         
                                                                                                                                                                             |         if (rsi < rax) {
    0x0040a8fe jb 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
    0x0040a904 mov rcx, qword [rdi + 0x30]                                                                                                                                   |         rcx = *((rdi + 0x30));
    0x0040a908 mov rdx, qword [rdi + 0x70]                                                                                                                                   |         rdx = *((rdi + 0x70));
    0x0040a90c sub rcx, rax                                                                                                                                                  |         rcx -= rax;
    0x0040a90f cmp rdx, rcx                                                                                                                                                  |         
                                                                                                                                                                             |         if (rdx >= rcx) {
    0x0040a912 cmovge rcx, rdx                                                                                                                                               |             rcx = rdx;
                                                                                                                                                                             |         }
    0x0040a916 add rcx, rax                                                                                                                                                  |         rcx += rax;
    0x0040a919 cmp rsi, rcx                                                                                                                                                  |         
                                                                                                                                                                             |         if (rsi > rcx) {
    0x0040a91c ja 0x40a9bc                                                                                                                                                   |             goto label_0;
                                                                                                                                                                             |         }
    0x0040a922 lea r8, [rdi + 0x40]                                                                                                                                          |         r8 = rdi + 0x40;
    0x0040a926 cmp qword [rdi + 0x60], 0x17                                                                                                                                  |         
                                                                                                                                                                             |         if (*((rdi + 0x60)) != 0x17) {
    0x0040a92b je 0x40a930                                                                                                                                                   |             
    0x0040a92d mov r8, qword [r8]                                                                                                                                            |             r8 = *(r8);
                                                                                                                                                                             |         }
    0x0040a930 sub rsi, r8                                                                                                                                                   |         rsi -= r8;
    0x0040a933 mov rax, qword [rdi + 0x58]                                                                                                                                   |         rax = *((rdi + 0x58));
    0x0040a937 add rax, r8                                                                                                                                                   |         rax += r8;
    0x0040a93a mov qword [rdi + 0x30], r8                                                                                                                                    |         *((rdi + 0x30)) = r8;
    0x0040a93e mov qword [rdi + 0x28], r8                                                                                                                                    |         *((rdi + 0x28)) = r8;
    0x0040a942 mov qword [rdi + 0x38], rax                                                                                                                                   |         *((rdi + 0x38)) = rax;
    0x0040a946 mov eax, 0x80000000                                                                                                                                           |         eax = 0x80000000;
    0x0040a94b cmp rsi, rax                                                                                                                                                  |         
                                                                                                                                                                             |         if (rsi >= rax) {
    0x0040a94e jl 0x40a9a8                                                                                                                                                   |             
    0x0040a950 mov eax, 0xfffffffe                                                                                                                                           |             eax = 0xfffffffe;
    0x0040a955 cmp rsi, rax                                                                                                                                                  |             
                                                                                                                                                                             |             if (rsi < rax) {
    0x0040a958 cmovl rax, rsi                                                                                                                                                |                 rax = rsi;
                                                                                                                                                                             |             }
    0x0040a95c neg rax                                                                                                                                                       |             rax = -rax;
    0x0040a95f lea rcx, [rsi + rax + 0x7ffffffe]                                                                                                                             |             rcx = rsi + rax + 0x7ffffffe;
    0x0040a967 movabs rdx, 0x200000005                                                                                                                                       |             rdx = 0x200000005;
    0x0040a971 mov rax, rcx                                                                                                                                                  |             rax = rcx;
    0x0040a974 mul rdx                                                                                                                                                       |             rdx:rax = rax * rdx;
    0x0040a977 sub rcx, rdx                                                                                                                                                  |             rcx -= rdx;
    0x0040a97a shr rcx, 1                                                                                                                                                    |             rcx >>= 1;
    0x0040a97d add rcx, rdx                                                                                                                                                  |             rcx += rdx;
    0x0040a980 shr rcx, 0x1e                                                                                                                                                 |             rcx >>= 0x1e;
    0x0040a984 mov rdx, rcx                                                                                                                                                  |             rdx = rcx;
    0x0040a987 shl rdx, 0x1f                                                                                                                                                 |             rdx <<= 0x1f;
    0x0040a98b sub rdx, rcx                                                                                                                                                  |             rdx -= rcx;
    0x0040a98e lea r8, [rdx + r8 + 0x7fffffff]                                                                                                                               |             r8 = rdx + r8 + 0x7fffffff;
    0x0040a996 mov rax, rsi                                                                                                                                                  |             rax = rsi;
    0x0040a999 sub rax, rdx                                                                                                                                                  |             rax -= rdx;
    0x0040a99c add rax, 0xffffffff80000001                                                                                                                                   |             rax += 0xffffffff80000001;
    0x0040a9a2 mov qword [rdi + 0x30], r8                                                                                                                                    |             *((rdi + 0x30)) = r8;
    0x0040a9a6 jmp 0x40a9ab                                                                                                                                                  |             
                                                                                                                                                                             |         } else {
    0x0040a9a8 mov rax, rsi                                                                                                                                                  |             rax = rsi;
                                                                                                                                                                             |         }
    0x0040a9ab test rax, rax                                                                                                                                                 |         
                                                                                                                                                                             |         if (rax != 0) {
    0x0040a9ae je 0x40a9b9                                                                                                                                                   |             
    0x0040a9b0 cdqe                                                                                                                                                          |             rax = (int64_t) eax;
    0x0040a9b2 add r8, rax                                                                                                                                                   |             r8 += rax;
    0x0040a9b5 mov qword [rdi + 0x30], r8                                                                                                                                    |             *((rdi + 0x30)) = r8;
                                                                                                                                                                             |         }
    0x0040a9b9 mov r8, rsi                                                                                                                                                   |         r8 = rsi;
                                                                                                                                                                             |     }
                                                                                                                                                                             | label_0:
    0x0040a9bc xor eax, eax                                                                                                                                                  |     eax = 0;
    0x0040a9be mov rdx, r8                                                                                                                                                   |     rdx = r8;
    0x0040a9c1 ret                                                                                                                                                           |     return rax;
                                                                                                                                                                             | }