void CodecRC4(unsigned char *key, int keylen, unsigned char *textin,
              int textlen, unsigned char *textout) {
  int i;
  int j;
  int t;
  unsigned char rc4[256];
  int a = 0;
  int b = 0;
  unsigned char k;
  for (i = 0; i < 256; i++) {
    rc4[i] = i;
  }
  j = 0;
  for (i = 0; i < 256; i++) {
    t = rc4[i];
    j = (j + t + key[i % keylen]) % 256;
    rc4[i] = rc4[j];
    rc4[j] = t;
  }
  for (i = 0; i < textlen; i++) {
    a = (a + 1) % 256;
    t = rc4[a];
    b = (b + t) % 256;
    rc4[a] = rc4[b];
    rc4[b] = t;
    k = rc4[(rc4[a] + rc4[b]) % 256];
    textout[i] = textin[i] ^ k;
  }
}


x86 assembly (clang, -O0):
<CodecRC4>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x144(%rbp)
movl   $0x0,-0x148(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x100,-0x2c(%rbp)
jge    1163 <CodecRC4+0x63>
mov    -0x2c(%rbp),%eax
mov    %al,%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1138 <CodecRC4+0x38>
movl   $0x0,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x100,-0x2c(%rbp)
jge    11f2 <CodecRC4+0xf2>
movslq -0x2c(%rbp),%rax
movzbl -0x140(%rbp,%rax,1),%eax
ff
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x150(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x2c(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    -0x150(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %edx,-0x30(%rbp)
movslq -0x30(%rbp),%rax
mov    -0x140(%rbp,%rax,1),%cl
movslq -0x2c(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
mov    %al,%cl
movslq -0x30(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1171 <CodecRC4+0x71>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12dc <CodecRC4+0x1dc>
mov    -0x144(%rbp),%eax
add    $0x1,%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %edx,-0x144(%rbp)
movslq -0x144(%rbp),%rax
movzbl -0x140(%rbp,%rax,1),%eax
ff
mov    %eax,-0x34(%rbp)
mov    -0x148(%rbp),%eax
add    -0x34(%rbp),%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
mov    %edx,-0x148(%rbp)
movslq -0x148(%rbp),%rax
mov    -0x140(%rbp,%rax,1),%cl
movslq -0x144(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
mov    %al,%cl
movslq -0x148(%rbp),%rax
mov    %cl,-0x140(%rbp,%rax,1)
movslq -0x144(%rbp),%rax
movzbl -0x140(%rbp,%rax,1),%eax
ff
movslq -0x148(%rbp),%rcx
movzbl -0x140(%rbp,%rcx,1),%ecx
ff
add    %ecx,%eax
mov    $0x100,%ecx
cltd
idiv   %ecx
movslq %edx,%rax
mov    -0x140(%rbp,%rax,1),%al
mov    %al,-0x149(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x149(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f9 <CodecRC4+0xf9>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<CodecRC4>:
push   %rbx
sub    $0x80,%rsp
mov    %rdx,%r9
movaps 0xeee(%rip),%xmm0
movaps %xmm0,-0x80(%rsp)
movaps 0xef2(%rip),%xmm0
movaps %xmm0,-0x70(%rsp)
movaps 0xef6(%rip),%xmm0
movaps %xmm0,-0x60(%rsp)
movaps 0xefa(%rip),%xmm0
movaps %xmm0,-0x50(%rsp)
movaps 0xefe(%rip),%xmm0
movaps %xmm0,-0x40(%rsp)
movaps 0xf02(%rip),%xmm0
movaps %xmm0,-0x30(%rsp)
movaps 0xf06(%rip),%xmm0
movaps %xmm0,-0x20(%rsp)
movaps 0xf0a(%rip),%xmm0
movaps %xmm0,-0x10(%rsp)
movaps 0xf0e(%rip),%xmm0
movaps %xmm0,(%rsp)
movaps 0xf13(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
movaps 0xf17(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
movaps 0xf1b(%rip),%xmm0
movaps %xmm0,0x30(%rsp)
movaps 0xf1f(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
movaps 0xf23(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xf27(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xf2b(%rip),%xmm0
movaps %xmm0,0x70(%rsp)
xor    %r10d,%r10d
xor    %r11d,%r11d
movzbl -0x80(%rsp,%r10,1),%ebx
add    %ebx,%r11d
mov    %r10d,%eax
cltd
idiv   %esi
movzbl (%rdi,%rdx,1),%eax
lea    (%rax,%r11,1),%edx
add    $0xff,%edx
add    %eax,%r11d
cmovns %r11d,%edx
and    $0xffffff00,%edx
sub    %edx,%r11d
movzbl -0x80(%rsp,%r11,1),%eax
mov    %al,-0x80(%rsp,%r10,1)
mov    %bl,-0x80(%rsp,%r11,1)
add    $0x1,%r10
cmp    $0x100,%r10
jne    11d0 <CodecRC4+0xd0>
test   %ecx,%ecx
jle    129f <CodecRC4+0x19f>
mov    %ecx,%r10d
xor    %ecx,%ecx
xor    %r11d,%r11d
xor    %edx,%edx
nopl   0x0(%rax)
lea    0x1(%rdx),%edi
lea    0x100(%rdx),%ebx
test   %edi,%edi
cmovns %edi,%ebx
and    $0xffffff00,%ebx
neg    %ebx
add    %ebx,%edx
add    $0x1,%edx
movslq %edx,%rdi
movzbl -0x80(%rsp,%rdi,1),%ebx
movzbl %bl,%eax
lea    (%r11,%rax,1),%esi
add    $0xff,%esi
add    %eax,%r11d
cmovns %r11d,%esi
and    $0xffffff00,%esi
sub    %esi,%r11d
movzbl -0x80(%rsp,%r11,1),%eax
mov    %al,-0x80(%rsp,%rdi,1)
mov    %bl,-0x80(%rsp,%r11,1)
movzbl -0x80(%rsp,%rdi,1),%eax
add    %ebx,%eax
movzbl %al,%eax
movzbl (%r9,%rcx,1),%ebx
xor    -0x80(%rsp,%rax,1),%bl
mov    %bl,(%r8,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1230 <CodecRC4+0x130>
add    $0x80,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @CodecRC4(i8* %0, i32 %1, i8* %2, i32 %3, i8* %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [256 x i8]
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8
store i8* %0, i8** %6
store i32 %1, i32* %7
store i8* %2, i8** %8
store i32 %3, i32* %9
store i8* %4, i8** %10
store i32 0, i32* %15
store i32 0, i32* %16
store i32 0, i32* %11
br label %18
18: ; preds = %27, %5
%19 = load i32, i32* %11
%20 = icmp slt i32 %19, 256
br i1 %20, label %21, label %30
21: ; preds = %18
%22 = load i32, i32* %11
%23 = trunc i32 %22 to i8
%24 = load i32, i32* %11
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %25
store i8 %23, i8* %26
br label %27
27: ; preds = %21
%28 = load i32, i32* %11
%29 = add nsw i32 %28, 1
store i32 %29, i32* %11
br label %18
30: ; preds = %18
store i32 0, i32* %12
store i32 0, i32* %11
br label %31
31: ; preds = %65, %30
%32 = load i32, i32* %11
%33 = icmp slt i32 %32, 256
br i1 %33, label %34, label %68
34: ; preds = %31
%35 = load i32, i32* %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %36
%38 = load i8, i8* %37
%39 = zext i8 %38 to i32
store i32 %39, i32* %13
%40 = load i32, i32* %12
%41 = load i32, i32* %13
%42 = add nsw i32 %40, %41
%43 = load i8*, i8** %6
%44 = load i32, i32* %11
%45 = load i32, i32* %7
%46 = srem i32 %44, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i8, i8* %43, i64 %47
%49 = load i8, i8* %48
%50 = zext i8 %49 to i32
%51 = add nsw i32 %42, %50
%52 = srem i32 %51, 256
store i32 %52, i32* %12
%53 = load i32, i32* %12
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %54
%56 = load i8, i8* %55
%57 = load i32, i32* %11
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %58
store i8 %56, i8* %59
%60 = load i32, i32* %13
%61 = trunc i32 %60 to i8
%62 = load i32, i32* %12
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %63
store i8 %61, i8* %64
br label %65
65: ; preds = %34
%66 = load i32, i32* %11
%67 = add nsw i32 %66, 1
store i32 %67, i32* %11
br label %31
68: ; preds = %31
store i32 0, i32* %11
br label %69
69: ; preds = %127, %68
%70 = load i32, i32* %11
%71 = load i32, i32* %9
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %130
73: ; preds = %69
%74 = load i32, i32* %15
%75 = add nsw i32 %74, 1
%76 = srem i32 %75, 256
store i32 %76, i32* %15
%77 = load i32, i32* %15
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %78
%80 = load i8, i8* %79
%81 = zext i8 %80 to i32
store i32 %81, i32* %13
%82 = load i32, i32* %16
%83 = load i32, i32* %13
%84 = add nsw i32 %82, %83
%85 = srem i32 %84, 256
store i32 %85, i32* %16
%86 = load i32, i32* %16
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = load i32, i32* %15
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %91
store i8 %89, i8* %92
%93 = load i32, i32* %13
%94 = trunc i32 %93 to i8
%95 = load i32, i32* %16
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %96
store i8 %94, i8* %97
%98 = load i32, i32* %15
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %99
%101 = load i8, i8* %100
%102 = zext i8 %101 to i32
%103 = load i32, i32* %16
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %104
%106 = load i8, i8* %105
%107 = zext i8 %106 to i32
%108 = add nsw i32 %102, %107
%109 = srem i32 %108, 256
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [256 x i8], [256 x i8]* %14, i64 0, i64 %110
%112 = load i8, i8* %111
store i8 %112, i8* %17
%113 = load i8*, i8** %8
%114 = load i32, i32* %11
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %113, i64 %115
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = load i8, i8* %17
%120 = zext i8 %119 to i32
%121 = xor i32 %118, %120
%122 = trunc i32 %121 to i8
%123 = load i8*, i8** %10
%124 = load i32, i32* %11
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
store i8 %122, i8* %126
br label %127
127: ; preds = %73
%128 = load i32, i32* %11
%129 = add nsw i32 %128, 1
store i32 %129, i32* %11
br label %69
130: ; preds = %69
ret void
}

LLVM IR (-O2):
define void @CodecRC4(i8* nocapture %0, i32 %1, i8* nocapture %2, i32 %3, i8* nocapture writeonly %4) {
%6 = alloca [256 x i8]
%7 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%8 = bitcast [256 x i8]* %6 to <16 x i8>*
store <16 x i8> <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, <16 x i8>* %8
%9 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 16
%10 = bitcast i8* %9 to <16 x i8>*
store <16 x i8> <i8 16, i8 17, i8 18, i8 19, i8 20, i8 21, i8 22, i8 23, i8 24, i8 25, i8 26, i8 27, i8 28, i8 29, i8 30, i8 31>, <16 x i8>* %10
%11 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 32
%12 = bitcast i8* %11 to <16 x i8>*
store <16 x i8> <i8 32, i8 33, i8 34, i8 35, i8 36, i8 37, i8 38, i8 39, i8 40, i8 41, i8 42, i8 43, i8 44, i8 45, i8 46, i8 47>, <16 x i8>* %12
%13 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 48
%14 = bitcast i8* %13 to <16 x i8>*
store <16 x i8> <i8 48, i8 49, i8 50, i8 51, i8 52, i8 53, i8 54, i8 55, i8 56, i8 57, i8 58, i8 59, i8 60, i8 61, i8 62, i8 63>, <16 x i8>* %14
%15 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 64
%16 = bitcast i8* %15 to <16 x i8>*
store <16 x i8> <i8 64, i8 65, i8 66, i8 67, i8 68, i8 69, i8 70, i8 71, i8 72, i8 73, i8 74, i8 75, i8 76, i8 77, i8 78, i8 79>, <16 x i8>* %16
%17 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 80
%18 = bitcast i8* %17 to <16 x i8>*
store <16 x i8> <i8 80, i8 81, i8 82, i8 83, i8 84, i8 85, i8 86, i8 87, i8 88, i8 89, i8 90, i8 91, i8 92, i8 93, i8 94, i8 95>, <16 x i8>* %18
%19 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 96
%20 = bitcast i8* %19 to <16 x i8>*
store <16 x i8> <i8 96, i8 97, i8 98, i8 99, i8 100, i8 101, i8 102, i8 103, i8 104, i8 105, i8 106, i8 107, i8 108, i8 109, i8 110, i8 111>, <16 x i8>* %20
%21 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 112
%22 = bitcast i8* %21 to <16 x i8>*
store <16 x i8> <i8 112, i8 113, i8 114, i8 115, i8 116, i8 117, i8 118, i8 119, i8 120, i8 121, i8 122, i8 123, i8 124, i8 125, i8 126, i8 127>, <16 x i8>* %22
%23 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 128
%24 = bitcast i8* %23 to <16 x i8>*
store <16 x i8> <i8 -128, i8 -127, i8 -126, i8 -125, i8 -124, i8 -123, i8 -122, i8 -121, i8 -120, i8 -119, i8 -118, i8 -117, i8 -116, i8 -115, i8 -114, i8 -113>, <16 x i8>* %24
%25 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 144
%26 = bitcast i8* %25 to <16 x i8>*
store <16 x i8> <i8 -112, i8 -111, i8 -110, i8 -109, i8 -108, i8 -107, i8 -106, i8 -105, i8 -104, i8 -103, i8 -102, i8 -101, i8 -100, i8 -99, i8 -98, i8 -97>, <16 x i8>* %26
%27 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 160
%28 = bitcast i8* %27 to <16 x i8>*
store <16 x i8> <i8 -96, i8 -95, i8 -94, i8 -93, i8 -92, i8 -91, i8 -90, i8 -89, i8 -88, i8 -87, i8 -86, i8 -85, i8 -84, i8 -83, i8 -82, i8 -81>, <16 x i8>* %28
%29 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 176
%30 = bitcast i8* %29 to <16 x i8>*
store <16 x i8> <i8 -80, i8 -79, i8 -78, i8 -77, i8 -76, i8 -75, i8 -74, i8 -73, i8 -72, i8 -71, i8 -70, i8 -69, i8 -68, i8 -67, i8 -66, i8 -65>, <16 x i8>* %30
%31 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 192
%32 = bitcast i8* %31 to <16 x i8>*
store <16 x i8> <i8 -64, i8 -63, i8 -62, i8 -61, i8 -60, i8 -59, i8 -58, i8 -57, i8 -56, i8 -55, i8 -54, i8 -53, i8 -52, i8 -51, i8 -50, i8 -49>, <16 x i8>* %32
%33 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 208
%34 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> <i8 -48, i8 -47, i8 -46, i8 -45, i8 -44, i8 -43, i8 -42, i8 -41, i8 -40, i8 -39, i8 -38, i8 -37, i8 -36, i8 -35, i8 -34, i8 -33>, <16 x i8>* %34
%35 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 224
%36 = bitcast i8* %35 to <16 x i8>*
store <16 x i8> <i8 -32, i8 -31, i8 -30, i8 -29, i8 -28, i8 -27, i8 -26, i8 -25, i8 -24, i8 -23, i8 -22, i8 -21, i8 -20, i8 -19, i8 -18, i8 -17>, <16 x i8>* %36
%37 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 240
%38 = bitcast i8* %37 to <16 x i8>*
store <16 x i8> <i8 -16, i8 -15, i8 -14, i8 -13, i8 -12, i8 -11, i8 -10, i8 -9, i8 -8, i8 -7, i8 -6, i8 -5, i8 -4, i8 -3, i8 -2, i8 -1>, <16 x i8>* %38
br label %43
39: ; preds = %43
%40 = icmp sgt i32 %3, 0
br i1 %40, label %41, label %91
41: ; preds = %39
%42 = zext i32 %3 to i64
br label %63
43: ; preds = %5, %43
%44 = phi i64 [ %61, %43 ], [ 0, %5 ]
%45 = phi i32 [ %57, %43 ], [ 0, %5 ]
%46 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %44
%47 = load i8, i8* %46
%48 = zext i8 %47 to i32
%49 = add nsw i32 %45, %48
%50 = trunc i64 %44 to i32
%51 = srem i32 %50, %1
%52 = zext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = load i8, i8* %53
%55 = zext i8 %54 to i32
%56 = add nsw i32 %49, %55
%57 = srem i32 %56, 256
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %58
%60 = load i8, i8* %59
store i8 %60, i8* %46
store i8 %47, i8* %59
%61 = add nuw nsw i64 %44, 1
%62 = icmp eq i64 %61, 256
br i1 %62, label %39, label %43
63: ; preds = %41, %63
%64 = phi i64 [ 0, %41 ], [ %89, %63 ]
%65 = phi i32 [ 0, %41 ], [ %74, %63 ]
%66 = phi i32 [ 0, %41 ], [ %68, %63 ]
%67 = add nsw i32 %66, 1
%68 = srem i32 %67, 256
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %69
%71 = load i8, i8* %70
%72 = zext i8 %71 to i32
%73 = add nsw i32 %65, %72
%74 = srem i32 %73, 256
%75 = zext i32 %74 to i64
%76 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %75
%77 = load i8, i8* %76
store i8 %77, i8* %70
store i8 %71, i8* %76
%78 = load i8, i8* %70
%79 = zext i8 %78 to i32
%80 = add nuw nsw i32 %79, %72
%81 = and i32 %80, 255
%82 = zext i32 %81 to i64
%83 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %82
%84 = load i8, i8* %83
%85 = getelementptr inbounds i8, i8* %2, i64 %64
%86 = load i8, i8* %85
%87 = xor i8 %86, %84
%88 = getelementptr inbounds i8, i8* %4, i64 %64
store i8 %87, i8* %88
%89 = add nuw nsw i64 %64, 1
%90 = icmp eq i64 %89, %42
br i1 %90, label %91, label %63
91: ; preds = %63, %39
ret void
}