void NFuseDecode(char *src, int length, unsigned char *dst) {
  unsigned char a;
  int i;
  length /= 2;
  for (i = 0; i < length; i++) {
    a = src[i * 2];
    a -= 1;
    a <<= 4;
    a += src[i * 2 + 1];
    a -= 0x41;
    dst[i] = a;
  }
  for (i = length; i >= 0; i--) {
    a = dst[i - 1];
    a ^= dst[i];
    a ^= 0xA5;
    dst[i] = a;
  }
  dst[length] = '\0';
}


x86 assembly (clang, -O0):
<NFuseDecode>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119a <NFuseDecode+0x9a>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
sub    $0x1,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
shl    $0x4,%eax
mov    %al,-0x19(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%ecx
movzbl -0x19(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
sub    $0x41,%eax
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1124 <NFuseDecode+0x24>
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     11fa <NFuseDecode+0xfa>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%ecx
movzbl -0x19(%rbp),%eax
xor    %ecx,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
xor    $0xa5,%eax
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%dl
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    11a0 <NFuseDecode+0xa0>
mov    -0x18(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
pop    %rbp
ret

x86 assembly (clang, -O2):
<NFuseDecode>:
mov    %esi,%r8d
shr    $0x1f,%r8d
add    %esi,%r8d
sar    %r8d
cmp    $0x2,%esi
jl     118b <NFuseDecode+0x8b>
mov    %r8d,%r9d
cmp    $0x8,%r8d
jb     1135 <NFuseDecode+0x35>
lea    (%rdi,%r9,2),%rax
cmp    %rdx,%rax
jbe    123a <NFuseDecode+0x13a>
lea    (%rdx,%r9,1),%rax
cmp    %rdi,%rax
jbe    123a <NFuseDecode+0x13a>
xor    %ecx,%ecx
mov    %rcx,%r10
not    %r10
test   $0x1,%r9b
je     1156 <NFuseDecode+0x56>
mov    (%rdi,%rcx,2),%al
shl    $0x4,%al
add    0x1(%rdi,%rcx,2),%al
add    $0xaf,%al
mov    %al,(%rdx,%rcx,1)
or     $0x1,%rcx
add    %r9,%r10
je     118b <NFuseDecode+0x8b>
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rcx,2),%eax
shl    $0x4,%al
add    0x1(%rdi,%rcx,2),%al
add    $0xaf,%al
mov    %al,(%rdx,%rcx,1)
movzbl 0x2(%rdi,%rcx,2),%eax
shl    $0x4,%al
add    0x3(%rdi,%rcx,2),%al
add    $0xaf,%al
mov    %al,0x1(%rdx,%rcx,1)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1160 <NFuseDecode+0x60>
movslq %r8d,%r9
cmp    $0xffffffff,%esi
jl     1234 <NFuseDecode+0x134>
mov    (%rdx,%r9,1),%al
lea    0x1(%r8),%r10d
and    $0x3,%r10
je     11d3 <NFuseDecode+0xd3>
mov    %r9,%rsi
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rsi),%rdi
movzbl -0x1(%rdx,%rsi,1),%ecx
xor    %cl,%al
xor    $0xa5,%al
mov    %al,(%rdx,%rsi,1)
mov    %ecx,%eax
mov    %rdi,%rsi
add    $0xffffffffffffffff,%r10
jne    11b0 <NFuseDecode+0xb0>
cmp    $0x3,%r8d
jae    11de <NFuseDecode+0xde>
jmp    1234 <NFuseDecode+0x134>
mov    %eax,%ecx
mov    %r9,%rdi
cmp    $0x3,%r8d
jb     1234 <NFuseDecode+0x134>
add    $0x4,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x5(%rdx,%rdi,1),%eax
xor    %al,%cl
xor    $0xa5,%cl
mov    %cl,-0x4(%rdx,%rdi,1)
movzbl -0x6(%rdx,%rdi,1),%esi
xor    %sil,%al
xor    $0xa5,%al
mov    %al,-0x5(%rdx,%rdi,1)
movzbl -0x8(%rdx,%rdi,1),%ecx
movzbl -0x7(%rdx,%rdi,1),%eax
xor    %al,%sil
xor    $0xa5,%sil
mov    %sil,-0x6(%rdx,%rdi,1)
xor    %cl,%al
xor    $0xa5,%al
mov    %al,-0x7(%rdx,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    $0x3,%rdi
jg     11f0 <NFuseDecode+0xf0>
movb   $0x0,(%rdx,%r9,1)
ret
cmp    $0x10,%r8d
jae    12b7 <NFuseDecode+0x1b7>
xor    %ecx,%ecx
mov    %rcx,%rax
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
movdqa 0xdad(%rip),%xmm0
movdqa 0xdb5(%rip),%xmm1
movdqa 0xdcd(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu (%rdi,%rax,2),%xmm3
movdqa %xmm3,%xmm4
pand   %xmm0,%xmm4
packuswb %xmm4,%xmm4
psrlw  $0x8,%xmm3
packuswb %xmm3,%xmm3
psllw  $0x4,%xmm4
pand   %xmm1,%xmm4
paddb  %xmm3,%xmm4
paddb  %xmm2,%xmm4
movq   %xmm4,(%rdx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rcx
jne    1270 <NFuseDecode+0x170>
cmp    %r9,%rcx
jne    1137 <NFuseDecode+0x37>
jmp    118b <NFuseDecode+0x8b>
mov    %r9d,%ecx
and    $0xfffffff0,%ecx
lea    -0x10(%rcx),%rax
mov    %rax,%r10
shr    $0x4,%r10
add    $0x1,%r10
test   %rax,%rax
je     1403 <NFuseDecode+0x303>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %eax,%eax
movdqa 0xd1a(%rip),%xmm0
movdqa 0xd22(%rip),%xmm1
movdqa 0xd2a(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
movdqu (%rdi,%rax,2),%xmm3
movdqu 0x10(%rdi,%rax,2),%xmm4
movdqa %xmm4,%xmm5
pand   %xmm0,%xmm5
movdqa %xmm3,%xmm6
pand   %xmm0,%xmm6
packuswb %xmm5,%xmm6
psrlw  $0x8,%xmm4
psrlw  $0x8,%xmm3
packuswb %xmm4,%xmm3
psllw  $0x4,%xmm6
pand   %xmm1,%xmm6
paddb  %xmm2,%xmm3
paddb  %xmm6,%xmm3
movdqu %xmm3,(%rdx,%rax,1)
movdqu 0x20(%rdi,%rax,2),%xmm3
movdqu 0x30(%rdi,%rax,2),%xmm4
movdqa %xmm4,%xmm5
pand   %xmm0,%xmm5
movdqa %xmm3,%xmm6
pand   %xmm0,%xmm6
packuswb %xmm5,%xmm6
psrlw  $0x8,%xmm4
psrlw  $0x8,%xmm3
packuswb %xmm4,%xmm3
psllw  $0x4,%xmm6
pand   %xmm1,%xmm6
paddb  %xmm2,%xmm3
paddb  %xmm6,%xmm3
movdqu %xmm3,0x10(%rdx,%rax,1)
add    $0x20,%rax
add    $0xfffffffffffffffe,%r11
jne    1300 <NFuseDecode+0x200>
test   $0x1,%r10b
je     13eb <NFuseDecode+0x2eb>
movdqu (%rdi,%rax,2),%xmm0
movdqu 0x10(%rdi,%rax,2),%xmm1
movdqa 0xc51(%rip),%xmm2
movdqa %xmm1,%xmm3
pand   %xmm2,%xmm3
pand   %xmm0,%xmm2
packuswb %xmm3,%xmm2
psrlw  $0x8,%xmm1
psrlw  $0x8,%xmm0
packuswb %xmm1,%xmm0
psllw  $0x4,%xmm2
pand   0xc36(%rip),%xmm2
paddb  %xmm0,%xmm2
paddb  0xc3a(%rip),%xmm2
movdqu %xmm2,(%rdx,%rax,1)
cmp    %r9,%rcx
je     118b <NFuseDecode+0x8b>
test   $0x8,%r9b
jne    1242 <NFuseDecode+0x142>
jmp    1137 <NFuseDecode+0x37>
xor    %eax,%eax
test   $0x1,%r10b
jne    139c <NFuseDecode+0x29c>
jmp    13eb <NFuseDecode+0x2eb>

LLVM IR (-O0):
define void @NFuseDecode(i8* %0, i32 %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i8* %2, i8** %6
%9 = load i32, i32* %5
%10 = sdiv i32 %9, 2
store i32 %10, i32* %5
store i32 0, i32* %8
br label %11
11: ; preds = %51, %3
%12 = load i32, i32* %8
%13 = load i32, i32* %5
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %54
15: ; preds = %11
%16 = load i8*, i8** %4
%17 = load i32, i32* %8
%18 = mul nsw i32 %17, 2
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i8, i8* %16, i64 %19
%21 = load i8, i8* %20
store i8 %21, i8* %7
%22 = load i8, i8* %7
%23 = zext i8 %22 to i32
%24 = sub nsw i32 %23, 1
%25 = trunc i32 %24 to i8
store i8 %25, i8* %7
%26 = load i8, i8* %7
%27 = zext i8 %26 to i32
%28 = shl i32 %27, 4
%29 = trunc i32 %28 to i8
store i8 %29, i8* %7
%30 = load i8*, i8** %4
%31 = load i32, i32* %8
%32 = mul nsw i32 %31, 2
%33 = add nsw i32 %32, 1
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %30, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = load i8, i8* %7
%39 = zext i8 %38 to i32
%40 = add nsw i32 %39, %37
%41 = trunc i32 %40 to i8
store i8 %41, i8* %7
%42 = load i8, i8* %7
%43 = zext i8 %42 to i32
%44 = sub nsw i32 %43, 65
%45 = trunc i32 %44 to i8
store i8 %45, i8* %7
%46 = load i8, i8* %7
%47 = load i8*, i8** %6
%48 = load i32, i32* %8
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
store i8 %46, i8* %50
br label %51
51: ; preds = %15
%52 = load i32, i32* %8
%53 = add nsw i32 %52, 1
store i32 %53, i32* %8
br label %11
54: ; preds = %11
%55 = load i32, i32* %5
store i32 %55, i32* %8
br label %56
56: ; preds = %85, %54
%57 = load i32, i32* %8
%58 = icmp sge i32 %57, 0
br i1 %58, label %59, label %88
59: ; preds = %56
%60 = load i8*, i8** %6
%61 = load i32, i32* %8
%62 = sub nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i8, i8* %60, i64 %63
%65 = load i8, i8* %64
store i8 %65, i8* %7
%66 = load i8*, i8** %6
%67 = load i32, i32* %8
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %66, i64 %68
%70 = load i8, i8* %69
%71 = zext i8 %70 to i32
%72 = load i8, i8* %7
%73 = zext i8 %72 to i32
%74 = xor i32 %73, %71
%75 = trunc i32 %74 to i8
store i8 %75, i8* %7
%76 = load i8, i8* %7
%77 = zext i8 %76 to i32
%78 = xor i32 %77, 165
%79 = trunc i32 %78 to i8
store i8 %79, i8* %7
%80 = load i8, i8* %7
%81 = load i8*, i8** %6
%82 = load i32, i32* %8
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds i8, i8* %81, i64 %83
store i8 %80, i8* %84
br label %85
85: ; preds = %59
%86 = load i32, i32* %8
%87 = add nsw i32 %86, -1
store i32 %87, i32* %8
br label %56
88: ; preds = %56
%89 = load i8*, i8** %6
%90 = load i32, i32* %5
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
store i8 0, i8* %92
ret void
}

LLVM IR (-O2):
define void @NFuseDecode(i8* nocapture %0, i32 %1, i8* nocapture %2) {
%4 = sdiv i32 %1, 2
%5 = icmp sgt i32 %1, 1
br i1 %5, label %6, label %117
6: ; preds = %3
%7 = zext i32 %4 to i64
%8 = icmp ult i32 %4, 8
br i1 %8, label %96, label %9
9: ; preds = %6
%10 = getelementptr i8, i8* %2, i64 %7
%11 = shl nuw nsw i64 %7, 1
%12 = getelementptr i8, i8* %0, i64 %11
%13 = icmp ugt i8* %12, %2
%14 = icmp ugt i8* %10, %0
%15 = and i1 %13, %14
br i1 %15, label %96, label %16
16: ; preds = %9
%17 = icmp ult i32 %4, 16
br i1 %17, label %76, label %18
18: ; preds = %16
%19 = and i64 %7, 4294967280
%20 = add nsw i64 %19, -16
%21 = lshr exact i64 %20, 4
%22 = add nuw nsw i64 %21, 1
%23 = and i64 %22, 1
%24 = icmp eq i64 %20, 0
br i1 %24, label %56, label %25
25: ; preds = %18
%26 = and i64 %22, 2305843009213693950
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %53, %27 ]
%29 = phi i64 [ 0, %25 ], [ %54, %27 ]
%30 = shl nuw nsw i64 %28, 1
%31 = getelementptr inbounds i8, i8* %0, i64 %30
%32 = bitcast i8* %31 to <32 x i8>*
%33 = load <32 x i8>, <32 x i8>* %32
%34 = shufflevector <32 x i8> %33, <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
%35 = shufflevector <32 x i8> %33, <32 x i8> poison, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
%36 = shl <16 x i8> %34, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%37 = add <16 x i8> %36, <i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81>
%38 = add <16 x i8> %37, %35
%39 = getelementptr inbounds i8, i8* %2, i64 %28
%40 = bitcast i8* %39 to <16 x i8>*
store <16 x i8> %38, <16 x i8>* %40
%41 = or i64 %28, 16
%42 = shl nuw nsw i64 %41, 1
%43 = getelementptr inbounds i8, i8* %0, i64 %42
%44 = bitcast i8* %43 to <32 x i8>*
%45 = load <32 x i8>, <32 x i8>* %44
%46 = shufflevector <32 x i8> %45, <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
%47 = shufflevector <32 x i8> %45, <32 x i8> poison, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
%48 = shl <16 x i8> %46, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%49 = add <16 x i8> %48, <i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81>
%50 = add <16 x i8> %49, %47
%51 = getelementptr inbounds i8, i8* %2, i64 %41
%52 = bitcast i8* %51 to <16 x i8>*
store <16 x i8> %50, <16 x i8>* %52
%53 = add nuw i64 %28, 32
%54 = add i64 %29, 2
%55 = icmp eq i64 %54, %26
br i1 %55, label %56, label %27
56: ; preds = %27, %18
%57 = phi i64 [ 0, %18 ], [ %53, %27 ]
%58 = icmp eq i64 %23, 0
br i1 %58, label %71, label %59
59: ; preds = %56
%60 = shl nuw nsw i64 %57, 1
%61 = getelementptr inbounds i8, i8* %0, i64 %60
%62 = bitcast i8* %61 to <32 x i8>*
%63 = load <32 x i8>, <32 x i8>* %62
%64 = shufflevector <32 x i8> %63, <32 x i8> poison, <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
%65 = shufflevector <32 x i8> %63, <32 x i8> poison, <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
%66 = shl <16 x i8> %64, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%67 = add <16 x i8> %66, <i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81>
%68 = add <16 x i8> %67, %65
%69 = getelementptr inbounds i8, i8* %2, i64 %57
%70 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %68, <16 x i8>* %70
br label %71
71: ; preds = %56, %59
%72 = icmp eq i64 %19, %7
br i1 %72, label %117, label %73
73: ; preds = %71
%74 = and i64 %7, 8
%75 = icmp eq i64 %74, 0
br i1 %75, label %96, label %76
76: ; preds = %16, %73
%77 = phi i64 [ %19, %73 ], [ 0, %16 ]
%78 = and i64 %7, 4294967288
br label %79
79: ; preds = %79, %76
%80 = phi i64 [ %77, %76 ], [ %92, %79 ]
%81 = shl nuw nsw i64 %80, 1
%82 = getelementptr inbounds i8, i8* %0, i64 %81
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = shufflevector <16 x i8> %84, <16 x i8> poison, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
%86 = shufflevector <16 x i8> %84, <16 x i8> poison, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
%87 = shl <8 x i8> %85, <i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4, i8 4>
%88 = add <8 x i8> %87, <i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81, i8 -81>
%89 = add <8 x i8> %88, %86
%90 = getelementptr inbounds i8, i8* %2, i64 %80
%91 = bitcast i8* %90 to <8 x i8>*
store <8 x i8> %89, <8 x i8>* %91
%92 = add nuw i64 %80, 8
%93 = icmp eq i64 %92, %78
br i1 %93, label %94, label %79
94: ; preds = %79
%95 = icmp eq i64 %78, %7
br i1 %95, label %117, label %96
96: ; preds = %9, %6, %73, %94
%97 = phi i64 [ 0, %6 ], [ 0, %9 ], [ %19, %73 ], [ %78, %94 ]
%98 = xor i64 %97, -1
%99 = and i64 %7, 1
%100 = icmp eq i64 %99, 0
br i1 %100, label %113, label %101
101: ; preds = %96
%102 = shl nuw nsw i64 %97, 1
%103 = getelementptr inbounds i8, i8* %0, i64 %102
%104 = load i8, i8* %103
%105 = shl i8 %104, 4
%106 = or i64 %102, 1
%107 = getelementptr inbounds i8, i8* %0, i64 %106
%108 = load i8, i8* %107
%109 = add i8 %105, -81
%110 = add i8 %109, %108
%111 = getelementptr inbounds i8, i8* %2, i64 %97
store i8 %110, i8* %111
%112 = or i64 %97, 1
br label %113
113: ; preds = %101, %96
%114 = phi i64 [ %97, %96 ], [ %112, %101 ]
%115 = sub nsw i64 0, %7
%116 = icmp eq i64 %98, %115
br i1 %116, label %117, label %142
117: ; preds = %113, %142, %71, %94, %3
%118 = icmp sgt i32 %1, -2
%119 = sext i32 %4 to i64
br i1 %118, label %120, label %195
120: ; preds = %117
%121 = getelementptr inbounds i8, i8* %2, i64 %119
%122 = load i8, i8* %121
%123 = add nsw i64 %119, 1
%124 = and i64 %123, 3
%125 = icmp eq i64 %124, 0
br i1 %125, label %138, label %126
126: ; preds = %120, %126
%127 = phi i8 [ %132, %126 ], [ %122, %120 ]
%128 = phi i64 [ %130, %126 ], [ %119, %120 ]
%129 = phi i64 [ %136, %126 ], [ 0, %120 ]
%130 = add nsw i64 %128, -1
%131 = getelementptr inbounds i8, i8* %2, i64 %130
%132 = load i8, i8* %131
%133 = getelementptr inbounds i8, i8* %2, i64 %128
%134 = xor i8 %132, %127
%135 = xor i8 %134, -91
store i8 %135, i8* %133
%136 = add i64 %129, 1
%137 = icmp eq i64 %136, %124
br i1 %137, label %138, label %126
138: ; preds = %126, %120
%139 = phi i8 [ %122, %120 ], [ %132, %126 ]
%140 = phi i64 [ %119, %120 ], [ %130, %126 ]
%141 = icmp ult i32 %4, 3
br i1 %141, label %195, label %167
142: ; preds = %113, %142
%143 = phi i64 [ %165, %142 ], [ %114, %113 ]
%144 = shl nuw nsw i64 %143, 1
%145 = getelementptr inbounds i8, i8* %0, i64 %144
%146 = load i8, i8* %145
%147 = shl i8 %146, 4
%148 = or i64 %144, 1
%149 = getelementptr inbounds i8, i8* %0, i64 %148
%150 = load i8, i8* %149
%151 = add i8 %147, -81
%152 = add i8 %151, %150
%153 = getelementptr inbounds i8, i8* %2, i64 %143
store i8 %152, i8* %153
%154 = add nuw nsw i64 %143, 1
%155 = shl nuw nsw i64 %154, 1
%156 = getelementptr inbounds i8, i8* %0, i64 %155
%157 = load i8, i8* %156
%158 = shl i8 %157, 4
%159 = or i64 %155, 1
%160 = getelementptr inbounds i8, i8* %0, i64 %159
%161 = load i8, i8* %160
%162 = add i8 %158, -81
%163 = add i8 %162, %161
%164 = getelementptr inbounds i8, i8* %2, i64 %154
store i8 %163, i8* %164
%165 = add nuw nsw i64 %143, 2
%166 = icmp eq i64 %165, %7
br i1 %166, label %117, label %142
167: ; preds = %138, %167
%168 = phi i8 [ %190, %167 ], [ %139, %138 ]
%169 = phi i64 [ %188, %167 ], [ %140, %138 ]
%170 = add nsw i64 %169, -1
%171 = getelementptr inbounds i8, i8* %2, i64 %170
%172 = load i8, i8* %171
%173 = getelementptr inbounds i8, i8* %2, i64 %169
%174 = xor i8 %172, %168
%175 = xor i8 %174, -91
store i8 %175, i8* %173
%176 = add nsw i64 %169, -2
%177 = getelementptr inbounds i8, i8* %2, i64 %176
%178 = load i8, i8* %177
%179 = getelementptr inbounds i8, i8* %2, i64 %170
%180 = xor i8 %178, %172
%181 = xor i8 %180, -91
store i8 %181, i8* %179
%182 = add nsw i64 %169, -3
%183 = getelementptr inbounds i8, i8* %2, i64 %182
%184 = load i8, i8* %183
%185 = getelementptr inbounds i8, i8* %2, i64 %176
%186 = xor i8 %184, %178
%187 = xor i8 %186, -91
store i8 %187, i8* %185
%188 = add nsw i64 %169, -4
%189 = getelementptr inbounds i8, i8* %2, i64 %188
%190 = load i8, i8* %189
%191 = getelementptr inbounds i8, i8* %2, i64 %182
%192 = xor i8 %190, %184
%193 = xor i8 %192, -91
store i8 %193, i8* %191
%194 = icmp sgt i64 %169, 3
br i1 %194, label %167, label %195
195: ; preds = %138, %167, %117
%196 = getelementptr inbounds i8, i8* %2, i64 %119
store i8 0, i8* %196
ret void
}