void decrypt_8bits(unsigned long long *state, unsigned int *plaintextword,
                   unsigned int ciphertextword, unsigned int *ks,
                   unsigned int ca, unsigned int cb) {
  unsigned long long f;
  unsigned long long word_244, word_23, word_160, word_111, word_66, word_196,
      word_0, word_107, word_230;
  unsigned long long word_12, word_154, word_235, word_61, word_193;
  word_12 = state[0] >> 12;
  word_235 = state[5] >> 5;
  word_244 = state[5] >> 14;
  word_23 = state[0] >> 23;
  word_160 = state[3] >> 6;
  word_111 = state[2] >> 4;
  word_66 = state[1] >> 5;
  word_196 = state[4] >> 3;
  state[6] ^= (state[5] ^ word_235) & 0xff;
  state[5] ^= (state[4] ^ word_196) & 0xff;
  state[4] ^= (state[3] ^ word_160) & 0xff;
  state[3] ^= (state[2] ^ word_111) & 0xff;
  state[2] ^= (state[1] ^ word_66) & 0xff;
  state[1] ^= (state[0] ^ word_23) & 0xff;
  word_0 = state[0];
  word_107 = state[2];
  word_230 = state[5];
  word_154 = state[3];
  word_61 = state[1];
  word_193 = state[4];
  *ks = word_12 ^ state[3] ^
        (((word_235) & (state[1])) ^ ((word_235) & (state[4])) ^
         ((state[1]) & (state[4])));
  *ks &= 0xff;
  f = state[0] ^ (state[2] ^ 0xffffffff) ^
      (((word_244) & (word_23)) ^ ((word_244) & (word_160)) ^
       ((word_23) & (word_160))) ^
      (((state[5]) & (word_111)) ^ ((~state[5]) & (word_66))) ^
      (word_196 & ca) ^ (cb & *ks);
  *plaintextword = ciphertextword ^ *ks;
  f = (f ^ *plaintextword) & 0xff;
  state[6] = state[6] ^ (f << 4);
  state[0] = (state[0] >> 8) | ((state[1] & 0xff) << (29 + 24));
  state[1] = (state[1] >> 8) | ((state[2] & 0xff) << (14 + 24));
  state[2] = (state[2] >> 8) | ((state[3] & 0xff) << (15 + 24));
  state[3] = (state[3] >> 8) | ((state[4] & 0xff) << (7 + 24));
  state[4] = (state[4] >> 8) | ((state[5] & 0xff) << (5 + 24));
  state[5] = (state[5] >> 8) | ((state[6] & 0xff) << (27 + 24));
  state[6] = state[6] >> 8;
  return;
}


x86 assembly (clang, -O0):
<decrypt_8bits>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
shr    $0xc,%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
shr    $0x5,%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
shr    $0xe,%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
shr    $0x17,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
shr    $0x6,%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
shr    $0x4,%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
shr    $0x5,%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
shr    $0x3,%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rcx
xor    -0x90(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x30(%rax),%rcx
mov    %rcx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rcx
xor    -0x60(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x28(%rax),%rcx
mov    %rcx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rcx
xor    -0x48(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x20(%rax),%rcx
mov    %rcx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rcx
xor    -0x50(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x18(%rax),%rcx
mov    %rcx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
xor    -0x58(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x10(%rax),%rcx
mov    %rcx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
xor    -0x40(%rbp),%rcx
and    $0xff,%rcx
mov    -0x8(%rbp),%rax
xor    0x8(%rax),%rcx
mov    %rcx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x80(%rbp),%rax
mov    -0x8(%rbp),%rcx
xor    0x18(%rcx),%rax
mov    -0x90(%rbp),%rcx
mov    -0x8(%rbp),%rdx
and    0x8(%rdx),%rcx
mov    -0x90(%rbp),%rdx
mov    -0x8(%rbp),%rsi
and    0x20(%rsi),%rdx
xor    %rdx,%rcx
mov    -0x8(%rbp),%rdx
mov    0x8(%rdx),%rdx
mov    -0x8(%rbp),%rsi
and    0x20(%rsi),%rdx
xor    %rdx,%rcx
xor    %rcx,%rax
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
and    $0xff,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rdx
movabs $0xffffffff,%rcx
xor    0x10(%rdx),%rcx
xor    %rcx,%rax
mov    -0x38(%rbp),%rcx
and    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rdx
and    -0x48(%rbp),%rdx
xor    %rdx,%rcx
mov    -0x40(%rbp),%rdx
and    -0x48(%rbp),%rdx
xor    %rdx,%rcx
xor    %rcx,%rax
mov    -0x8(%rbp),%rcx
mov    0x28(%rcx),%rcx
and    -0x50(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    0x28(%rdx),%rdx
xor    $0xffffffffffffffff,%rdx
and    -0x58(%rbp),%rdx
xor    %rdx,%rcx
xor    %rcx,%rax
mov    -0x60(%rbp),%rcx
mov    -0x24(%rbp),%edx
and    %rdx,%rcx
xor    %rcx,%rax
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rdx
and    (%rdx),%ecx
mov    %ecx,%ecx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
xor    %rcx,%rax
and    $0xff,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rcx
mov    -0x30(%rbp),%rax
shl    $0x4,%rax
xor    %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
and    $0xff,%rax
shl    $0x35,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
and    $0xff,%rax
shl    $0x26,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
and    $0xff,%rax
shl    $0x27,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
and    $0xff,%rax
shl    $0x1f,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
and    $0xff,%rax
shl    $0x1d,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rax
and    $0xff,%rax
shl    $0x33,%rax
or     %rax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rcx
shr    $0x8,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<decrypt_8bits>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r9d,-0x3c(%rsp)
mov    %r8d,%r14d
mov    %rcx,-0x10(%rsp)
mov    %edx,%r11d
mov    %rsi,-0x8(%rsp)
mov    %rdi,%r9
mov    (%rdi),%r15
mov    %r15,%rbx
shr    $0xc,%rbx
mov    %r15,%r12
shr    $0x17,%r12
mov    0x18(%rdi),%rcx
mov    %rcx,%rax
mov    %rcx,%rdx
mov    %rcx,-0x18(%rsp)
shr    $0x6,%rax
mov    0x10(%rdi),%rcx
mov    %rcx,%r13
mov    %rcx,%rsi
mov    %rcx,-0x20(%rsp)
shr    $0x4,%r13
mov    0x20(%rdi),%rdi
mov    %rdi,-0x28(%rsp)
mov    %eax,%ecx
xor    %edx,%ecx
movzbl %cl,%ecx
xor    %rdi,%rcx
mov    %rcx,%rdi
mov    %r13d,%ecx
xor    %esi,%ecx
movzbl %cl,%ecx
xor    %rdx,%rcx
mov    %rcx,%rbp
mov    %rcx,-0x38(%rsp)
mov    %eax,%ecx
xor    %r12d,%ecx
and    %r12d,%eax
xor    %r15d,%r12d
movzbl %r12b,%edx
mov    0x8(%r9),%rsi
xor    %rsi,%rdx
mov    %rdi,-0x30(%rsp)
mov    %edi,%r12d
and    %edx,%r12d
xor    %ebp,%ebx
xor    %r12d,%ebx
mov    0x28(%r9),%r8
mov    %r8,%r12
shr    $0x5,%r12
mov    %edi,%r10d
xor    %edx,%r10d
and    %r12d,%r10d
xor    %r10d,%ebx
xor    %r8d,%r12d
movzbl %r12b,%r10d
xor    0x30(%r9),%r10
movzbl %bl,%r12d
mov    -0x10(%rsp),%rdi
mov    %r12d,(%rdi)
mov    %r8,%rdi
shr    $0xe,%rdi
and    %ecx,%edi
and    -0x3c(%rsp),%ebx
mov    %r11d,%ebp
xor    %r12d,%ebp
mov    -0x8(%rsp),%rcx
mov    %ebp,(%rcx)
xor    %r15d,%eax
xor    %edi,%eax
mov    -0x28(%rsp),%r12
mov    %r12,%rcx
shr    $0x3,%rcx
and    %ecx,%r14d
xor    %r14d,%eax
mov    %rsi,%rdi
shr    $0x5,%rdi
xor    %r12d,%ecx
mov    %r12,%r14
movzbl %cl,%r12d
xor    %r8,%r12
xor    %edi,%r13d
and    %r12d,%r13d
xor    %edi,%r13d
xor    %esi,%edi
movzbl %dil,%ecx
mov    -0x20(%rsp),%r11
xor    %r11,%rcx
mov    %ecx,%edi
xor    %eax,%edi
xor    %r13d,%edi
xor    %ebx,%edi
xor    %ebp,%edi
movzbl %dil,%eax
shl    $0x4,%rax
xor    %r10,%rax
shr    $0x8,%r15
movzbl %dl,%edx
shl    $0x35,%rdx
or     %r15,%rdx
mov    %rdx,(%r9)
movzbl %cl,%ecx
shr    $0x8,%rsi
shl    $0x26,%rcx
or     %rsi,%rcx
mov    %rcx,0x8(%r9)
shr    $0x8,%r11
movzbl -0x38(%rsp),%ecx
shl    $0x27,%rcx
or     %r11,%rcx
mov    %rcx,0x10(%r9)
movzbl -0x30(%rsp),%ecx
mov    -0x18(%rsp),%rdx
shr    $0x8,%rdx
shl    $0x1f,%rcx
or     %rdx,%rcx
mov    %rcx,0x18(%r9)
shr    $0x8,%r14
movzbl %r12b,%ecx
shl    $0x1d,%rcx
or     %r14,%rcx
xor    $0xff0,%rax
mov    %rcx,0x20(%r9)
shr    $0x8,%r8
movzbl %al,%ecx
shl    $0x33,%rcx
or     %r8,%rcx
mov    %rcx,0x28(%r9)
shr    $0x8,%rax
mov    %rax,0x30(%r9)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @decrypt_8bits(i64* %0, i32* %1, i32 %2, i32* %3, i32 %4, i32 %5) {
%7 = alloca i64*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64
%21 = alloca i64
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
store i64* %0, i64** %7
store i32* %1, i32** %8
store i32 %2, i32* %9
store i32* %3, i32** %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%28 = load i64*, i64** %7
%29 = getelementptr inbounds i64, i64* %28, i64 0
%30 = load i64, i64* %29
%31 = lshr i64 %30, 12
store i64 %31, i64* %23
%32 = load i64*, i64** %7
%33 = getelementptr inbounds i64, i64* %32, i64 5
%34 = load i64, i64* %33
%35 = lshr i64 %34, 5
store i64 %35, i64* %25
%36 = load i64*, i64** %7
%37 = getelementptr inbounds i64, i64* %36, i64 5
%38 = load i64, i64* %37
%39 = lshr i64 %38, 14
store i64 %39, i64* %14
%40 = load i64*, i64** %7
%41 = getelementptr inbounds i64, i64* %40, i64 0
%42 = load i64, i64* %41
%43 = lshr i64 %42, 23
store i64 %43, i64* %15
%44 = load i64*, i64** %7
%45 = getelementptr inbounds i64, i64* %44, i64 3
%46 = load i64, i64* %45
%47 = lshr i64 %46, 6
store i64 %47, i64* %16
%48 = load i64*, i64** %7
%49 = getelementptr inbounds i64, i64* %48, i64 2
%50 = load i64, i64* %49
%51 = lshr i64 %50, 4
store i64 %51, i64* %17
%52 = load i64*, i64** %7
%53 = getelementptr inbounds i64, i64* %52, i64 1
%54 = load i64, i64* %53
%55 = lshr i64 %54, 5
store i64 %55, i64* %18
%56 = load i64*, i64** %7
%57 = getelementptr inbounds i64, i64* %56, i64 4
%58 = load i64, i64* %57
%59 = lshr i64 %58, 3
store i64 %59, i64* %19
%60 = load i64*, i64** %7
%61 = getelementptr inbounds i64, i64* %60, i64 5
%62 = load i64, i64* %61
%63 = load i64, i64* %25
%64 = xor i64 %62, %63
%65 = and i64 %64, 255
%66 = load i64*, i64** %7
%67 = getelementptr inbounds i64, i64* %66, i64 6
%68 = load i64, i64* %67
%69 = xor i64 %68, %65
store i64 %69, i64* %67
%70 = load i64*, i64** %7
%71 = getelementptr inbounds i64, i64* %70, i64 4
%72 = load i64, i64* %71
%73 = load i64, i64* %19
%74 = xor i64 %72, %73
%75 = and i64 %74, 255
%76 = load i64*, i64** %7
%77 = getelementptr inbounds i64, i64* %76, i64 5
%78 = load i64, i64* %77
%79 = xor i64 %78, %75
store i64 %79, i64* %77
%80 = load i64*, i64** %7
%81 = getelementptr inbounds i64, i64* %80, i64 3
%82 = load i64, i64* %81
%83 = load i64, i64* %16
%84 = xor i64 %82, %83
%85 = and i64 %84, 255
%86 = load i64*, i64** %7
%87 = getelementptr inbounds i64, i64* %86, i64 4
%88 = load i64, i64* %87
%89 = xor i64 %88, %85
store i64 %89, i64* %87
%90 = load i64*, i64** %7
%91 = getelementptr inbounds i64, i64* %90, i64 2
%92 = load i64, i64* %91
%93 = load i64, i64* %17
%94 = xor i64 %92, %93
%95 = and i64 %94, 255
%96 = load i64*, i64** %7
%97 = getelementptr inbounds i64, i64* %96, i64 3
%98 = load i64, i64* %97
%99 = xor i64 %98, %95
store i64 %99, i64* %97
%100 = load i64*, i64** %7
%101 = getelementptr inbounds i64, i64* %100, i64 1
%102 = load i64, i64* %101
%103 = load i64, i64* %18
%104 = xor i64 %102, %103
%105 = and i64 %104, 255
%106 = load i64*, i64** %7
%107 = getelementptr inbounds i64, i64* %106, i64 2
%108 = load i64, i64* %107
%109 = xor i64 %108, %105
store i64 %109, i64* %107
%110 = load i64*, i64** %7
%111 = getelementptr inbounds i64, i64* %110, i64 0
%112 = load i64, i64* %111
%113 = load i64, i64* %15
%114 = xor i64 %112, %113
%115 = and i64 %114, 255
%116 = load i64*, i64** %7
%117 = getelementptr inbounds i64, i64* %116, i64 1
%118 = load i64, i64* %117
%119 = xor i64 %118, %115
store i64 %119, i64* %117
%120 = load i64*, i64** %7
%121 = getelementptr inbounds i64, i64* %120, i64 0
%122 = load i64, i64* %121
store i64 %122, i64* %20
%123 = load i64*, i64** %7
%124 = getelementptr inbounds i64, i64* %123, i64 2
%125 = load i64, i64* %124
store i64 %125, i64* %21
%126 = load i64*, i64** %7
%127 = getelementptr inbounds i64, i64* %126, i64 5
%128 = load i64, i64* %127
store i64 %128, i64* %22
%129 = load i64*, i64** %7
%130 = getelementptr inbounds i64, i64* %129, i64 3
%131 = load i64, i64* %130
store i64 %131, i64* %24
%132 = load i64*, i64** %7
%133 = getelementptr inbounds i64, i64* %132, i64 1
%134 = load i64, i64* %133
store i64 %134, i64* %26
%135 = load i64*, i64** %7
%136 = getelementptr inbounds i64, i64* %135, i64 4
%137 = load i64, i64* %136
store i64 %137, i64* %27
%138 = load i64, i64* %23
%139 = load i64*, i64** %7
%140 = getelementptr inbounds i64, i64* %139, i64 3
%141 = load i64, i64* %140
%142 = xor i64 %138, %141
%143 = load i64, i64* %25
%144 = load i64*, i64** %7
%145 = getelementptr inbounds i64, i64* %144, i64 1
%146 = load i64, i64* %145
%147 = and i64 %143, %146
%148 = load i64, i64* %25
%149 = load i64*, i64** %7
%150 = getelementptr inbounds i64, i64* %149, i64 4
%151 = load i64, i64* %150
%152 = and i64 %148, %151
%153 = xor i64 %147, %152
%154 = load i64*, i64** %7
%155 = getelementptr inbounds i64, i64* %154, i64 1
%156 = load i64, i64* %155
%157 = load i64*, i64** %7
%158 = getelementptr inbounds i64, i64* %157, i64 4
%159 = load i64, i64* %158
%160 = and i64 %156, %159
%161 = xor i64 %153, %160
%162 = xor i64 %142, %161
%163 = trunc i64 %162 to i32
%164 = load i32*, i32** %10
store i32 %163, i32* %164
%165 = load i32*, i32** %10
%166 = load i32, i32* %165
%167 = and i32 %166, 255
store i32 %167, i32* %165
%168 = load i64*, i64** %7
%169 = getelementptr inbounds i64, i64* %168, i64 0
%170 = load i64, i64* %169
%171 = load i64*, i64** %7
%172 = getelementptr inbounds i64, i64* %171, i64 2
%173 = load i64, i64* %172
%174 = xor i64 %173, 4294967295
%175 = xor i64 %170, %174
%176 = load i64, i64* %14
%177 = load i64, i64* %15
%178 = and i64 %176, %177
%179 = load i64, i64* %14
%180 = load i64, i64* %16
%181 = and i64 %179, %180
%182 = xor i64 %178, %181
%183 = load i64, i64* %15
%184 = load i64, i64* %16
%185 = and i64 %183, %184
%186 = xor i64 %182, %185
%187 = xor i64 %175, %186
%188 = load i64*, i64** %7
%189 = getelementptr inbounds i64, i64* %188, i64 5
%190 = load i64, i64* %189
%191 = load i64, i64* %17
%192 = and i64 %190, %191
%193 = load i64*, i64** %7
%194 = getelementptr inbounds i64, i64* %193, i64 5
%195 = load i64, i64* %194
%196 = xor i64 %195, -1
%197 = load i64, i64* %18
%198 = and i64 %196, %197
%199 = xor i64 %192, %198
%200 = xor i64 %187, %199
%201 = load i64, i64* %19
%202 = load i32, i32* %11
%203 = zext i32 %202 to i64
%204 = and i64 %201, %203
%205 = xor i64 %200, %204
%206 = load i32, i32* %12
%207 = load i32*, i32** %10
%208 = load i32, i32* %207
%209 = and i32 %206, %208
%210 = zext i32 %209 to i64
%211 = xor i64 %205, %210
store i64 %211, i64* %13
%212 = load i32, i32* %9
%213 = load i32*, i32** %10
%214 = load i32, i32* %213
%215 = xor i32 %212, %214
%216 = load i32*, i32** %8
store i32 %215, i32* %216
%217 = load i64, i64* %13
%218 = load i32*, i32** %8
%219 = load i32, i32* %218
%220 = zext i32 %219 to i64
%221 = xor i64 %217, %220
%222 = and i64 %221, 255
store i64 %222, i64* %13
%223 = load i64*, i64** %7
%224 = getelementptr inbounds i64, i64* %223, i64 6
%225 = load i64, i64* %224
%226 = load i64, i64* %13
%227 = shl i64 %226, 4
%228 = xor i64 %225, %227
%229 = load i64*, i64** %7
%230 = getelementptr inbounds i64, i64* %229, i64 6
store i64 %228, i64* %230
%231 = load i64*, i64** %7
%232 = getelementptr inbounds i64, i64* %231, i64 0
%233 = load i64, i64* %232
%234 = lshr i64 %233, 8
%235 = load i64*, i64** %7
%236 = getelementptr inbounds i64, i64* %235, i64 1
%237 = load i64, i64* %236
%238 = and i64 %237, 255
%239 = shl i64 %238, 53
%240 = or i64 %234, %239
%241 = load i64*, i64** %7
%242 = getelementptr inbounds i64, i64* %241, i64 0
store i64 %240, i64* %242
%243 = load i64*, i64** %7
%244 = getelementptr inbounds i64, i64* %243, i64 1
%245 = load i64, i64* %244
%246 = lshr i64 %245, 8
%247 = load i64*, i64** %7
%248 = getelementptr inbounds i64, i64* %247, i64 2
%249 = load i64, i64* %248
%250 = and i64 %249, 255
%251 = shl i64 %250, 38
%252 = or i64 %246, %251
%253 = load i64*, i64** %7
%254 = getelementptr inbounds i64, i64* %253, i64 1
store i64 %252, i64* %254
%255 = load i64*, i64** %7
%256 = getelementptr inbounds i64, i64* %255, i64 2
%257 = load i64, i64* %256
%258 = lshr i64 %257, 8
%259 = load i64*, i64** %7
%260 = getelementptr inbounds i64, i64* %259, i64 3
%261 = load i64, i64* %260
%262 = and i64 %261, 255
%263 = shl i64 %262, 39
%264 = or i64 %258, %263
%265 = load i64*, i64** %7
%266 = getelementptr inbounds i64, i64* %265, i64 2
store i64 %264, i64* %266
%267 = load i64*, i64** %7
%268 = getelementptr inbounds i64, i64* %267, i64 3
%269 = load i64, i64* %268
%270 = lshr i64 %269, 8
%271 = load i64*, i64** %7
%272 = getelementptr inbounds i64, i64* %271, i64 4
%273 = load i64, i64* %272
%274 = and i64 %273, 255
%275 = shl i64 %274, 31
%276 = or i64 %270, %275
%277 = load i64*, i64** %7
%278 = getelementptr inbounds i64, i64* %277, i64 3
store i64 %276, i64* %278
%279 = load i64*, i64** %7
%280 = getelementptr inbounds i64, i64* %279, i64 4
%281 = load i64, i64* %280
%282 = lshr i64 %281, 8
%283 = load i64*, i64** %7
%284 = getelementptr inbounds i64, i64* %283, i64 5
%285 = load i64, i64* %284
%286 = and i64 %285, 255
%287 = shl i64 %286, 29
%288 = or i64 %282, %287
%289 = load i64*, i64** %7
%290 = getelementptr inbounds i64, i64* %289, i64 4
store i64 %288, i64* %290
%291 = load i64*, i64** %7
%292 = getelementptr inbounds i64, i64* %291, i64 5
%293 = load i64, i64* %292
%294 = lshr i64 %293, 8
%295 = load i64*, i64** %7
%296 = getelementptr inbounds i64, i64* %295, i64 6
%297 = load i64, i64* %296
%298 = and i64 %297, 255
%299 = shl i64 %298, 51
%300 = or i64 %294, %299
%301 = load i64*, i64** %7
%302 = getelementptr inbounds i64, i64* %301, i64 5
store i64 %300, i64* %302
%303 = load i64*, i64** %7
%304 = getelementptr inbounds i64, i64* %303, i64 6
%305 = load i64, i64* %304
%306 = lshr i64 %305, 8
%307 = load i64*, i64** %7
%308 = getelementptr inbounds i64, i64* %307, i64 6
store i64 %306, i64* %308
ret void
}

LLVM IR (-O2):
define void @decrypt_8bits(i64* nocapture %0, i32* nocapture writeonly %1, i32 %2, i32* nocapture writeonly %3, i32 %4, i32 %5) {
%7 = load i64, i64* %0
%8 = lshr i64 %7, 12
%9 = getelementptr inbounds i64, i64* %0, i64 5
%10 = load i64, i64* %9
%11 = lshr i64 %10, 5
%12 = lshr i64 %10, 14
%13 = lshr i64 %7, 23
%14 = getelementptr inbounds i64, i64* %0, i64 3
%15 = load i64, i64* %14
%16 = lshr i64 %15, 6
%17 = getelementptr inbounds i64, i64* %0, i64 2
%18 = load i64, i64* %17
%19 = lshr i64 %18, 4
%20 = getelementptr inbounds i64, i64* %0, i64 1
%21 = load i64, i64* %20
%22 = lshr i64 %21, 5
%23 = getelementptr inbounds i64, i64* %0, i64 4
%24 = load i64, i64* %23
%25 = lshr i64 %24, 3
%26 = xor i64 %11, %10
%27 = and i64 %26, 255
%28 = getelementptr inbounds i64, i64* %0, i64 6
%29 = load i64, i64* %28
%30 = xor i64 %29, %27
%31 = xor i64 %25, %24
%32 = and i64 %31, 255
%33 = xor i64 %32, %10
%34 = xor i64 %16, %15
%35 = and i64 %34, 255
%36 = xor i64 %24, %35
%37 = xor i64 %19, %18
%38 = and i64 %37, 255
%39 = xor i64 %38, %15
%40 = xor i64 %22, %21
%41 = and i64 %40, 255
%42 = xor i64 %41, %18
%43 = xor i64 %13, %7
%44 = and i64 %43, 255
%45 = xor i64 %21, %44
%46 = xor i64 %36, %45
%47 = and i64 %46, %11
%48 = and i64 %36, %45
%49 = xor i64 %39, %8
%50 = xor i64 %49, %48
%51 = xor i64 %50, %47
%52 = trunc i64 %51 to i32
%53 = and i32 %52, 255
store i32 %53, i32* %3
%54 = xor i64 %16, %13
%55 = and i64 %54, %12
%56 = and i64 %16, %13
%57 = and i64 %33, %19
%58 = xor i64 %33, -1
%59 = and i64 %22, %58
%60 = or i64 %57, %59
%61 = zext i32 %4 to i64
%62 = and i64 %25, %61
%63 = and i32 %52, %5
%64 = zext i32 %63 to i64
%65 = xor i32 %53, %2
store i32 %65, i32* %1
%66 = zext i32 %65 to i64
%67 = xor i64 %56, %7
%68 = xor i64 %67, %55
%69 = xor i64 %68, %62
%70 = xor i64 %69, %42
%71 = xor i64 %70, %60
%72 = xor i64 %71, %64
%73 = xor i64 %72, %66
%74 = shl i64 %73, 4
%75 = and i64 %74, 4080
%76 = xor i64 %30, %75
%77 = xor i64 %76, 4080
%78 = lshr i64 %7, 8
%79 = shl i64 %45, 53
%80 = and i64 %79, 2296835809958952960
%81 = or i64 %80, %78
store i64 %81, i64* %0
%82 = lshr i64 %21, 8
%83 = shl i64 %42, 38
%84 = and i64 %83, 70093866270720
%85 = or i64 %84, %82
store i64 %85, i64* %20
%86 = lshr i64 %18, 8
%87 = shl i64 %39, 39
%88 = and i64 %87, 140187732541440
%89 = or i64 %88, %86
store i64 %89, i64* %17
%90 = lshr i64 %15, 8
%91 = shl i64 %36, 31
%92 = and i64 %91, 547608330240
%93 = or i64 %92, %90
store i64 %93, i64* %14
%94 = lshr i64 %24, 8
%95 = shl i64 %33, 29
%96 = and i64 %95, 136902082560
%97 = or i64 %96, %94
store i64 %97, i64* %23
%98 = lshr i64 %10, 8
%99 = shl i64 %77, 51
%100 = and i64 %99, 574208952489738240
%101 = or i64 %100, %98
store i64 %101, i64* %9
%102 = lshr i64 %77, 8
store i64 %102, i64* %28
ret void
}