void encrypt_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;
  *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);
  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;
  *ciphertextword = plaintextword ^ *ks;
  return;
}


x86 assembly (clang, -O0):
<encrypt_8bits>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%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    -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    -0x30(%rbp),%rax
mov    -0xc(%rbp),%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)
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
xor    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
add    $0x20,%rsp
pop    %rbp
ret

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

LLVM IR (-O0):
define void @encrypt_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* %23
%121 = load i64*, i64** %7
%122 = getelementptr inbounds i64, i64* %121, i64 3
%123 = load i64, i64* %122
%124 = xor i64 %120, %123
%125 = load i64, i64* %25
%126 = load i64*, i64** %7
%127 = getelementptr inbounds i64, i64* %126, i64 1
%128 = load i64, i64* %127
%129 = and i64 %125, %128
%130 = load i64, i64* %25
%131 = load i64*, i64** %7
%132 = getelementptr inbounds i64, i64* %131, i64 4
%133 = load i64, i64* %132
%134 = and i64 %130, %133
%135 = xor i64 %129, %134
%136 = load i64*, i64** %7
%137 = getelementptr inbounds i64, i64* %136, i64 1
%138 = load i64, i64* %137
%139 = load i64*, i64** %7
%140 = getelementptr inbounds i64, i64* %139, i64 4
%141 = load i64, i64* %140
%142 = and i64 %138, %141
%143 = xor i64 %135, %142
%144 = xor i64 %124, %143
%145 = trunc i64 %144 to i32
%146 = load i32*, i32** %10
store i32 %145, i32* %146
%147 = load i32*, i32** %10
%148 = load i32, i32* %147
%149 = and i32 %148, 255
store i32 %149, i32* %147
%150 = load i64*, i64** %7
%151 = getelementptr inbounds i64, i64* %150, i64 0
%152 = load i64, i64* %151
%153 = load i64*, i64** %7
%154 = getelementptr inbounds i64, i64* %153, i64 2
%155 = load i64, i64* %154
%156 = xor i64 %155, 4294967295
%157 = xor i64 %152, %156
%158 = load i64, i64* %14
%159 = load i64, i64* %15
%160 = and i64 %158, %159
%161 = load i64, i64* %14
%162 = load i64, i64* %16
%163 = and i64 %161, %162
%164 = xor i64 %160, %163
%165 = load i64, i64* %15
%166 = load i64, i64* %16
%167 = and i64 %165, %166
%168 = xor i64 %164, %167
%169 = xor i64 %157, %168
%170 = load i64*, i64** %7
%171 = getelementptr inbounds i64, i64* %170, i64 5
%172 = load i64, i64* %171
%173 = load i64, i64* %17
%174 = and i64 %172, %173
%175 = load i64*, i64** %7
%176 = getelementptr inbounds i64, i64* %175, i64 5
%177 = load i64, i64* %176
%178 = xor i64 %177, -1
%179 = load i64, i64* %18
%180 = and i64 %178, %179
%181 = xor i64 %174, %180
%182 = xor i64 %169, %181
%183 = load i64, i64* %19
%184 = load i32, i32* %11
%185 = zext i32 %184 to i64
%186 = and i64 %183, %185
%187 = xor i64 %182, %186
%188 = load i32, i32* %12
%189 = load i32*, i32** %10
%190 = load i32, i32* %189
%191 = and i32 %188, %190
%192 = zext i32 %191 to i64
%193 = xor i64 %187, %192
store i64 %193, i64* %13
%194 = load i64, i64* %13
%195 = load i32, i32* %8
%196 = zext i32 %195 to i64
%197 = xor i64 %194, %196
%198 = and i64 %197, 255
store i64 %198, i64* %13
%199 = load i64*, i64** %7
%200 = getelementptr inbounds i64, i64* %199, i64 6
%201 = load i64, i64* %200
%202 = load i64, i64* %13
%203 = shl i64 %202, 4
%204 = xor i64 %201, %203
%205 = load i64*, i64** %7
%206 = getelementptr inbounds i64, i64* %205, i64 6
store i64 %204, i64* %206
%207 = load i64*, i64** %7
%208 = getelementptr inbounds i64, i64* %207, i64 0
%209 = load i64, i64* %208
%210 = lshr i64 %209, 8
%211 = load i64*, i64** %7
%212 = getelementptr inbounds i64, i64* %211, i64 1
%213 = load i64, i64* %212
%214 = and i64 %213, 255
%215 = shl i64 %214, 53
%216 = or i64 %210, %215
%217 = load i64*, i64** %7
%218 = getelementptr inbounds i64, i64* %217, i64 0
store i64 %216, i64* %218
%219 = load i64*, i64** %7
%220 = getelementptr inbounds i64, i64* %219, i64 1
%221 = load i64, i64* %220
%222 = lshr i64 %221, 8
%223 = load i64*, i64** %7
%224 = getelementptr inbounds i64, i64* %223, i64 2
%225 = load i64, i64* %224
%226 = and i64 %225, 255
%227 = shl i64 %226, 38
%228 = or i64 %222, %227
%229 = load i64*, i64** %7
%230 = getelementptr inbounds i64, i64* %229, i64 1
store i64 %228, i64* %230
%231 = load i64*, i64** %7
%232 = getelementptr inbounds i64, i64* %231, i64 2
%233 = load i64, i64* %232
%234 = lshr i64 %233, 8
%235 = load i64*, i64** %7
%236 = getelementptr inbounds i64, i64* %235, i64 3
%237 = load i64, i64* %236
%238 = and i64 %237, 255
%239 = shl i64 %238, 39
%240 = or i64 %234, %239
%241 = load i64*, i64** %7
%242 = getelementptr inbounds i64, i64* %241, i64 2
store i64 %240, i64* %242
%243 = load i64*, i64** %7
%244 = getelementptr inbounds i64, i64* %243, i64 3
%245 = load i64, i64* %244
%246 = lshr i64 %245, 8
%247 = load i64*, i64** %7
%248 = getelementptr inbounds i64, i64* %247, i64 4
%249 = load i64, i64* %248
%250 = and i64 %249, 255
%251 = shl i64 %250, 31
%252 = or i64 %246, %251
%253 = load i64*, i64** %7
%254 = getelementptr inbounds i64, i64* %253, i64 3
store i64 %252, i64* %254
%255 = load i64*, i64** %7
%256 = getelementptr inbounds i64, i64* %255, i64 4
%257 = load i64, i64* %256
%258 = lshr i64 %257, 8
%259 = load i64*, i64** %7
%260 = getelementptr inbounds i64, i64* %259, i64 5
%261 = load i64, i64* %260
%262 = and i64 %261, 255
%263 = shl i64 %262, 29
%264 = or i64 %258, %263
%265 = load i64*, i64** %7
%266 = getelementptr inbounds i64, i64* %265, i64 4
store i64 %264, i64* %266
%267 = load i64*, i64** %7
%268 = getelementptr inbounds i64, i64* %267, i64 5
%269 = load i64, i64* %268
%270 = lshr i64 %269, 8
%271 = load i64*, i64** %7
%272 = getelementptr inbounds i64, i64* %271, i64 6
%273 = load i64, i64* %272
%274 = and i64 %273, 255
%275 = shl i64 %274, 51
%276 = or i64 %270, %275
%277 = load i64*, i64** %7
%278 = getelementptr inbounds i64, i64* %277, i64 5
store i64 %276, i64* %278
%279 = load i64*, i64** %7
%280 = getelementptr inbounds i64, i64* %279, i64 6
%281 = load i64, i64* %280
%282 = lshr i64 %281, 8
%283 = load i64*, i64** %7
%284 = getelementptr inbounds i64, i64* %283, i64 6
store i64 %282, i64* %284
%285 = load i32, i32* %8
%286 = load i32*, i32** %10
%287 = load i32, i32* %286
%288 = xor i32 %285, %287
%289 = load i32*, i32** %9
store i32 %288, i32* %289
ret void
}

LLVM IR (-O2):
define void @encrypt_8bits(i64* nocapture %0, i32 %1, i32* nocapture writeonly %2, i32* nocapture %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 = zext i32 %1 to i64
%66 = xor i64 %7, %65
%67 = xor i64 %66, %56
%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 = shl i64 %72, 4
%74 = and i64 %73, 4080
%75 = xor i64 %30, %74
%76 = xor i64 %75, 4080
%77 = lshr i64 %7, 8
%78 = shl i64 %45, 53
%79 = and i64 %78, 2296835809958952960
%80 = or i64 %79, %77
store i64 %80, i64* %0
%81 = lshr i64 %21, 8
%82 = shl i64 %42, 38
%83 = and i64 %82, 70093866270720
%84 = or i64 %83, %81
store i64 %84, i64* %20
%85 = lshr i64 %18, 8
%86 = shl i64 %39, 39
%87 = and i64 %86, 140187732541440
%88 = or i64 %87, %85
store i64 %88, i64* %17
%89 = lshr i64 %15, 8
%90 = shl i64 %36, 31
%91 = and i64 %90, 547608330240
%92 = or i64 %91, %89
store i64 %92, i64* %14
%93 = lshr i64 %24, 8
%94 = shl i64 %33, 29
%95 = and i64 %94, 136902082560
%96 = or i64 %95, %93
store i64 %96, i64* %23
%97 = lshr i64 %10, 8
%98 = shl i64 %76, 51
%99 = and i64 %98, 574208952489738240
%100 = or i64 %99, %97
store i64 %100, i64* %9
%101 = lshr i64 %76, 8
store i64 %101, i64* %28
%102 = xor i32 %53, %1
store i32 %102, i32* %2
ret void
}