CheckAsciiPos(short&):                    # @CheckAsciiPos(short&)
        movzx   eax, word ptr [rdi]
        mov     cx, -256
        cmp     ax, 127
        jg      .LBB0_2
        movsx   edx, ax
        mov     cx, 256
        cmp     edx, -129
        jg      .LBB0_3
.LBB0_2:
        movsx   ecx, cx
        add     ecx, eax
        mov     word ptr [rdi], cx
.LBB0_3:
        ret
encrypt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >): # @encrypt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
        push    rbp
        push    r15
        push    r14
        push    r13
        push    r12
        push    rbx
        sub     rsp, 40
        mov     qword ptr [rsp + 32], rdx # 8-byte Spill
        mov     r14, rdi
        lea     rax, [rdi + 16]
        mov     qword ptr [rsp + 16], rax # 8-byte Spill
        mov     qword ptr [rdi], rax
        mov     qword ptr [rdi + 8], 0
        mov     byte ptr [rdi + 16], 0
        cmp     qword ptr [rsi + 8], 0
        je      .LBB1_18
        mov     cx, 1
        xor     eax, eax
        mov     ebp, 1
        xor     r13d, r13d
        mov     qword ptr [rsp + 24], rsi # 8-byte Spill
.LBB1_2:                                # =>This Inner Loop Header: Depth=1
        mov     dword ptr [rsp + 12], ebp # 4-byte Spill
        movsxd  rbp, r13d
        mov     rbx, qword ptr [rsp + 32] # 8-byte Reload
        mov     rdx, qword ptr [rbx]
        cmp     qword ptr [rbx + 8], rbp
        ja      .LBB1_4
        xor     r13d, r13d
.LBB1_4:                                #   in Loop: Header=BB1_2 Depth=1
        movsx   ebp, cx
        mov     ebx, 0
        cmp     ebp, 255
        jg      .LBB1_6
        mov     ebx, ecx
.LBB1_6:                                #   in Loop: Header=BB1_2 Depth=1
        movsxd  rcx, r13d
        movsx   ecx, byte ptr [rdx + rcx]
        mov     edx, ecx
        add     edx, ebx
        movsx   ebp, dx
        cmp     ebp, 128
        jl      .LBB1_8
        mov     ebp, ebx
        add     edx, -256
        jmp     .LBB1_9
.LBB1_8:                                #   in Loop: Header=BB1_2 Depth=1
        mov     ebp, ebx
        lea     ebx, [rdx + 256]
        cmp     dx, -128
        cmovge  ebx, edx
        mov     edx, ebx
.LBB1_9:                                #   in Loop: Header=BB1_2 Depth=1
        movsx   ecx, cx
        xor     ecx, edx
        mov     rdx, qword ptr [rsi]
        movsx   r15d, byte ptr [rdx + rax]
        xor     r15d, ecx
        add     r15d, ecx
        movsx   eax, r15w
        cmp     eax, 128
        jl      .LBB1_11
        add     r15d, -256
        jmp     .LBB1_12
.LBB1_11:                               #   in Loop: Header=BB1_2 Depth=1
        lea     eax, [r15 + 256]
        cmp     r15w, -128
        cmovge  eax, r15d
        mov     r15d, eax
.LBB1_12:                               #   in Loop: Header=BB1_2 Depth=1
        mov     rax, qword ptr [r14]
        mov     rbx, qword ptr [r14 + 8]
        lea     r12, [rbx + 1]
        mov     ecx, 15
        cmp     rax, qword ptr [rsp + 16] # 8-byte Folded Reload
        je      .LBB1_14
        mov     rcx, qword ptr [r14 + 16]
.LBB1_14:                               #   in Loop: Header=BB1_2 Depth=1
        cmp     r12, rcx
        jbe     .LBB1_17
        mov     r8d, 1
        mov     rdi, r14
        mov     rsi, rbx
        xor     edx, edx
        xor     ecx, ecx
        call    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate(unsigned long, unsigned long, char const*, unsigned long)
        mov     rax, qword ptr [r14]
.LBB1_17:                               #   in Loop: Header=BB1_2 Depth=1
        mov     byte ptr [rax + rbx], r15b
        mov     qword ptr [r14 + 8], r12
        mov     rax, qword ptr [r14]
        mov     byte ptr [rax + rbx + 1], 0
        add     r13d, 1
        mov     ecx, ebp
        add     ecx, 1
        mov     ebp, dword ptr [rsp + 12] # 4-byte Reload
        mov     eax, ebp
        add     ebp, 1
        mov     rsi, qword ptr [rsp + 24] # 8-byte Reload
        cmp     qword ptr [rsi + 8], rax
        ja      .LBB1_2
.LBB1_18:
        mov     rax, r14
        add     rsp, 40
        pop     rbx
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        pop     rbp
        ret
        mov     rbx, rax
        mov     rdi, qword ptr [r14]
        cmp     rdi, qword ptr [rsp + 16] # 8-byte Folded Reload
        je      .LBB1_21
        call    operator delete(void*)
.LBB1_21:
        mov     rdi, rbx
        call    _Unwind_Resume
decrypt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >): # @decrypt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)
        push    rbp
        push    r15
        push    r14
        push    r13
        push    r12
        push    rbx
        sub     rsp, 40
        mov     qword ptr [rsp + 32], rdx # 8-byte Spill
        mov     r14, rdi
        lea     rax, [rdi + 16]
        mov     qword ptr [rsp + 16], rax # 8-byte Spill
        mov     qword ptr [rdi], rax
        mov     qword ptr [rdi + 8], 0
        mov     byte ptr [rdi + 16], 0
        cmp     qword ptr [rsi + 8], 0
        je      .LBB2_18
        mov     cx, 1
        xor     eax, eax
        mov     ebp, 1
        xor     r13d, r13d
        mov     qword ptr [rsp + 24], rsi # 8-byte Spill
.LBB2_2:                                # =>This Inner Loop Header: Depth=1
        mov     dword ptr [rsp + 12], ebp # 4-byte Spill
        movsxd  rbp, r13d
        mov     rbx, qword ptr [rsp + 32] # 8-byte Reload
        mov     rdx, qword ptr [rbx]
        cmp     qword ptr [rbx + 8], rbp
        ja      .LBB2_4
        xor     r13d, r13d
.LBB2_4:                                #   in Loop: Header=BB2_2 Depth=1
        movsx   ebp, cx
        mov     ebx, 0
        cmp     ebp, 255
        jg      .LBB2_6
        mov     ebx, ecx
.LBB2_6:                                #   in Loop: Header=BB2_2 Depth=1
        movsxd  rcx, r13d
        movsx   ecx, byte ptr [rdx + rcx]
        mov     edx, ecx
        add     edx, ebx
        movsx   ebp, dx
        cmp     ebp, 128
        jl      .LBB2_8
        mov     ebp, ebx
        add     edx, -256
        jmp     .LBB2_9
.LBB2_8:                                #   in Loop: Header=BB2_2 Depth=1
        mov     ebp, ebx
        lea     ebx, [rdx + 256]
        cmp     dx, -128
        cmovge  ebx, edx
        mov     edx, ebx
.LBB2_9:                                #   in Loop: Header=BB2_2 Depth=1
        movsx   ecx, cx
        xor     ecx, edx
        mov     rdx, qword ptr [rsi]
        movsx   r15d, byte ptr [rdx + rax]
        sub     r15d, ecx
        xor     r15d, ecx
        movsx   eax, r15w
        cmp     eax, 128
        jl      .LBB2_11
        add     r15d, -256
        jmp     .LBB2_12
.LBB2_11:                               #   in Loop: Header=BB2_2 Depth=1
        lea     eax, [r15 + 256]
        cmp     r15w, -128
        cmovge  eax, r15d
        mov     r15d, eax
.LBB2_12:                               #   in Loop: Header=BB2_2 Depth=1
        mov     rax, qword ptr [r14]
        mov     rbx, qword ptr [r14 + 8]
        lea     r12, [rbx + 1]
        mov     ecx, 15
        cmp     rax, qword ptr [rsp + 16] # 8-byte Folded Reload
        je      .LBB2_14
        mov     rcx, qword ptr [r14 + 16]
.LBB2_14:                               #   in Loop: Header=BB2_2 Depth=1
        cmp     r12, rcx
        jbe     .LBB2_17
        mov     r8d, 1
        mov     rdi, r14
        mov     rsi, rbx
        xor     edx, edx
        xor     ecx, ecx
        call    std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >::_M_mutate(unsigned long, unsigned long, char const*, unsigned long)
        mov     rax, qword ptr [r14]
.LBB2_17:                               #   in Loop: Header=BB2_2 Depth=1
        mov     byte ptr [rax + rbx], r15b
        mov     qword ptr [r14 + 8], r12
        mov     rax, qword ptr [r14]
        mov     byte ptr [rax + rbx + 1], 0
        add     r13d, 1
        mov     ecx, ebp
        add     ecx, 1
        mov     ebp, dword ptr [rsp + 12] # 4-byte Reload
        mov     eax, ebp
        add     ebp, 1
        mov     rsi, qword ptr [rsp + 24] # 8-byte Reload
        cmp     qword ptr [rsi + 8], rax
        ja      .LBB2_2
.LBB2_18:
        mov     rax, r14
        add     rsp, 40
        pop     rbx
        pop     r12
        pop     r13
        pop     r14
        pop     r15
        pop     rbp
        ret