void transformation_D1(unsigned char *x0, unsigned char *x1, unsigned char *x2,
                       unsigned char *x3) {
  const int LEN = 128;
  unsigned char temp[LEN / 8];
  int i;
  unsigned char extL = 0, extR = 0, L = 0;
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x1[i] ^ x3[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[0] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR =
        i == LEN / 8 - 1 ? temp[i] >> 3 : (temp[i] >> 3) | (temp[i + 1] << 5);
    L = extL ^ extR;
    x0[i] = x0[i] ^ x2[i] ^ x3[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x2[i] ^ x0[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[0] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR =
        i == LEN / 8 - 1 ? temp[i] >> 3 : (temp[i] >> 3) | (temp[i + 1] << 5);
    L = extL ^ extR;
    x1[i] = x1[i] ^ x3[i] ^ x0[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x3[i] ^ x1[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[0] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR =
        i == LEN / 8 - 1 ? temp[i] >> 3 : (temp[i] >> 3) | (temp[i + 1] << 5);
    L = extL ^ extR;
    x2[i] = x2[i] ^ x0[i] ^ x1[i] ^ L;
  }
  for (i = 0; i < LEN / 8; i++)
    temp[i] = x0[i] ^ x2[i];
  for (i = 0; i < LEN / 8; i++) {
    extL = i == 0 ? temp[0] << 1 : (temp[i] << 1) | (temp[i - 1] >> 7);
    extR =
        i == LEN / 8 - 1 ? temp[i] >> 3 : (temp[i] >> 3) | (temp[i + 1] << 5);
    L = extL ^ extR;
    x3[i] = x3[i] ^ x1[i] ^ x2[i] ^ L;
  }
}


x86 assembly (clang, -O0):
<transformation_D1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x80,-0x24(%rbp)
mov    %rsp,%rax
mov    %rax,-0x30(%rbp)
movb   $0x0,-0x35(%rbp)
movb   $0x0,-0x36(%rbp)
movb   $0x0,-0x37(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    1171 <transformation_D1+0x71>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1135 <transformation_D1+0x35>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    125f <transformation_D1+0x15f>
cmpl   $0x0,-0x34(%rbp)
jne    119b <transformation_D1+0x9b>
movzbl -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11bd <transformation_D1+0xbd>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
shl    $0x1,%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpl   $0xf,-0x34(%rbp)
jne    11e1 <transformation_D1+0xe1>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    %eax,-0x58(%rbp)
jmp    1203 <transformation_D1+0x103>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %al,-0x36(%rbp)
movzbl -0x35(%rbp),%eax
movzbl -0x36(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x37(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
movzbl -0x37(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1178 <transformation_D1+0x78>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    12a2 <transformation_D1+0x1a2>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1266 <transformation_D1+0x166>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    1390 <transformation_D1+0x290>
cmpl   $0x0,-0x34(%rbp)
jne    12cc <transformation_D1+0x1cc>
movzbl -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12ee <transformation_D1+0x1ee>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
shl    $0x1,%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpl   $0xf,-0x34(%rbp)
jne    1312 <transformation_D1+0x212>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    %eax,-0x60(%rbp)
jmp    1334 <transformation_D1+0x234>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %al,-0x36(%rbp)
movzbl -0x35(%rbp),%eax
movzbl -0x36(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x37(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
movzbl -0x37(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a9 <transformation_D1+0x1a9>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    13d3 <transformation_D1+0x2d3>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1397 <transformation_D1+0x297>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    14c1 <transformation_D1+0x3c1>
cmpl   $0x0,-0x34(%rbp)
jne    13fd <transformation_D1+0x2fd>
movzbl -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    141f <transformation_D1+0x31f>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
shl    $0x1,%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpl   $0xf,-0x34(%rbp)
jne    1443 <transformation_D1+0x343>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    %eax,-0x68(%rbp)
jmp    1465 <transformation_D1+0x365>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %al,-0x36(%rbp)
movzbl -0x35(%rbp),%eax
movzbl -0x36(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x37(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
movzbl -0x37(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13da <transformation_D1+0x2da>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    1504 <transformation_D1+0x404>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
movslq -0x34(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14c8 <transformation_D1+0x3c8>
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    15f2 <transformation_D1+0x4f2>
cmpl   $0x0,-0x34(%rbp)
jne    152e <transformation_D1+0x42e>
movzbl -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1550 <transformation_D1+0x450>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
shl    $0x1,%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
sar    $0x7,%ecx
or     %ecx,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    %al,-0x35(%rbp)
cmpl   $0xf,-0x34(%rbp)
jne    1574 <transformation_D1+0x474>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    %eax,-0x70(%rbp)
jmp    1596 <transformation_D1+0x496>
movslq -0x34(%rbp),%rax
movzbl -0x50(%rbp,%rax,1),%eax
sar    $0x3,%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x50(%rbp,%rcx,1),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %al,-0x36(%rbp)
movzbl -0x35(%rbp),%eax
movzbl -0x36(%rbp),%ecx
xor    %ecx,%eax
mov    %al,-0x37(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x18(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
movzbl -0x37(%rbp),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    150b <transformation_D1+0x40b>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<transformation_D1>:
push   %rbp
push   %r14
push   %rbx
movups (%rsi),%xmm0
movups (%rcx),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,-0x10(%rsp)
mov    -0x1(%rsp),%r8b
shr    $0x3,%r8b
mov    -0x10(%rsp),%r10b
mov    -0xf(%rsp),%r9b
lea    (%r10,%r10,1),%eax
mov    %r10d,%ebx
shr    $0x3,%bl
shl    $0x5,%r9b
or     %bl,%r9b
xor    %al,%r9b
xor    (%rdi),%r9b
xor    (%rdx),%r9b
xor    (%rcx),%r9b
mov    %r9b,(%rdi)
mov    $0x1,%eax
jmp    1168 <transformation_D1+0x68>
nopl   0x0(%rax)
xor    %bpl,%bl
xor    (%rdi,%rax,1),%bl
xor    (%rdx,%rax,1),%bl
xor    (%rcx,%rax,1),%bl
mov    %bl,(%rdi,%rax,1)
mov    %r11,%rax
cmp    $0x10,%r11
je     11a2 <transformation_D1+0xa2>
mov    %r10d,%ebx
movzbl -0x10(%rsp,%rax,1),%r10d
shr    $0x7,%bl
lea    (%r10,%r10,1),%ebp
or     %bl,%bpl
mov    $0x10,%r11d
mov    %r8d,%ebx
cmp    $0xf,%rax
je     1150 <transformation_D1+0x50>
lea    0x1(%rax),%r11
movzbl -0xf(%rsp,%rax,1),%ebx
mov    %r10d,%r14d
shr    $0x3,%r14b
shl    $0x5,%bl
or     %r14b,%bl
jmp    1150 <transformation_D1+0x50>
movzwl 0x2(%rdi),%eax
movd   %eax,%xmm0
movd   0x4(%rdi),%xmm1
movdqu (%rdx),%xmm2
movq   0x8(%rdi),%xmm3
movzbl %r9b,%eax
movzbl 0x1(%rdi),%ebp
shl    $0x8,%ebp
or     %eax,%ebp
movd   %ebp,%xmm4
punpcklwd %xmm0,%xmm4
punpckldq %xmm1,%xmm4
punpcklqdq %xmm3,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,-0x10(%rsp)
mov    -0x1(%rsp),%r10b
mov    -0x10(%rsp),%r11b
mov    -0xf(%rsp),%r8b
lea    (%r11,%r11,1),%eax
mov    %r11d,%ebx
shr    $0x3,%bl
shl    $0x5,%r8b
or     %bl,%r8b
xor    %al,%r8b
xor    (%rsi),%r8b
xor    (%rcx),%r8b
shr    $0x3,%r10b
xor    %r9b,%r8b
mov    %r8b,(%rsi)
mov    $0x1,%eax
jmp    1238 <transformation_D1+0x138>
nopl   0x0(%rax)
xor    %bpl,%bl
xor    (%rsi,%rax,1),%bl
xor    (%rcx,%rax,1),%bl
xor    (%rdi,%rax,1),%bl
mov    %bl,(%rsi,%rax,1)
mov    %r9,%rax
cmp    $0x10,%r9
je     1272 <transformation_D1+0x172>
mov    %r11d,%ebx
movzbl -0x10(%rsp,%rax,1),%r11d
shr    $0x7,%bl
lea    (%r11,%r11,1),%ebp
or     %bl,%bpl
mov    $0x10,%r9d
mov    %r10d,%ebx
cmp    $0xf,%rax
je     1220 <transformation_D1+0x120>
lea    0x1(%rax),%r9
movzbl -0xf(%rsp,%rax,1),%ebx
mov    %r11d,%r14d
shr    $0x3,%r14b
shl    $0x5,%bl
or     %r14b,%bl
jmp    1220 <transformation_D1+0x120>
movzwl 0x2(%rsi),%eax
movd   %eax,%xmm0
movd   0x4(%rsi),%xmm1
movdqu (%rcx),%xmm2
movq   0x8(%rsi),%xmm3
movzbl %r8b,%eax
movzbl 0x1(%rsi),%ebp
shl    $0x8,%ebp
or     %eax,%ebp
movd   %ebp,%xmm4
punpcklwd %xmm0,%xmm4
punpckldq %xmm1,%xmm4
punpcklqdq %xmm3,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,-0x10(%rsp)
mov    -0x1(%rsp),%r10b
mov    -0x10(%rsp),%r11b
mov    -0xf(%rsp),%r9b
lea    (%r11,%r11,1),%eax
mov    %r11d,%ebx
shr    $0x3,%bl
shl    $0x5,%r9b
or     %bl,%r9b
xor    %al,%r9b
xor    (%rdx),%r9b
xor    (%rdi),%r9b
shr    $0x3,%r10b
xor    %r8b,%r9b
mov    %r9b,(%rdx)
mov    $0x1,%eax
jmp    1308 <transformation_D1+0x208>
nopl   0x0(%rax)
xor    %bpl,%bl
xor    (%rdx,%rax,1),%bl
xor    (%rdi,%rax,1),%bl
xor    (%rsi,%rax,1),%bl
mov    %bl,(%rdx,%rax,1)
mov    %r8,%rax
cmp    $0x10,%r8
je     1342 <transformation_D1+0x242>
mov    %r11d,%ebx
movzbl -0x10(%rsp,%rax,1),%r11d
shr    $0x7,%bl
lea    (%r11,%r11,1),%ebp
or     %bl,%bpl
mov    $0x10,%r8d
mov    %r10d,%ebx
cmp    $0xf,%rax
je     12f0 <transformation_D1+0x1f0>
lea    0x1(%rax),%r8
movzbl -0xf(%rsp,%rax,1),%ebx
mov    %r11d,%r14d
shr    $0x3,%r14b
shl    $0x5,%bl
or     %r14b,%bl
jmp    12f0 <transformation_D1+0x1f0>
movzwl 0x2(%rdx),%eax
movd   %eax,%xmm0
movd   0x4(%rdx),%xmm1
movdqu (%rdi),%xmm2
movq   0x8(%rdx),%xmm3
movzbl %r9b,%eax
movzbl 0x1(%rdx),%edi
shl    $0x8,%edi
or     %eax,%edi
movd   %edi,%xmm4
punpcklwd %xmm0,%xmm4
punpckldq %xmm1,%xmm4
punpcklqdq %xmm3,%xmm4
pxor   %xmm2,%xmm4
movdqa %xmm4,-0x10(%rsp)
mov    -0x1(%rsp),%r8b
mov    -0x10(%rsp),%r10b
mov    -0xf(%rsp),%al
lea    (%r10,%r10,1),%edi
mov    %r10d,%ebx
shr    $0x3,%bl
shl    $0x5,%al
or     %bl,%al
xor    %dil,%al
xor    (%rcx),%al
xor    (%rsi),%al
shr    $0x3,%r8b
xor    %r9b,%al
mov    %al,(%rcx)
mov    $0x1,%eax
jmp    13d8 <transformation_D1+0x2d8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %bpl,%bl
xor    (%rcx,%rax,1),%bl
xor    (%rsi,%rax,1),%bl
xor    (%rdx,%rax,1),%bl
mov    %bl,(%rcx,%rax,1)
mov    %rdi,%rax
cmp    $0x10,%rdi
je     1411 <transformation_D1+0x311>
mov    %r10d,%ebx
movzbl -0x10(%rsp,%rax,1),%r10d
shr    $0x7,%bl
lea    (%r10,%r10,1),%ebp
or     %bl,%bpl
mov    $0x10,%edi
mov    %r8d,%ebx
cmp    $0xf,%rax
je     13c0 <transformation_D1+0x2c0>
lea    0x1(%rax),%rdi
movzbl -0xf(%rsp,%rax,1),%ebx
mov    %r10d,%r9d
shr    $0x3,%r9b
shl    $0x5,%bl
or     %r9b,%bl
jmp    13c0 <transformation_D1+0x2c0>
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define void @transformation_D1(i8* %0, i8* %1, i8* %2, i8* %3) {
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i8
%13 = alloca i8
%14 = alloca i8
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
store i8* %3, i8** %8
store i32 128, i32* %9
%15 = call i8* @llvm.stacksave()
store i8* %15, i8** %10
%16 = alloca i8, i64 16
store i8 0, i8* %12
store i8 0, i8* %13
store i8 0, i8* %14
store i32 0, i32* %11
br label %17
17: ; preds = %38, %4
%18 = load i32, i32* %11
%19 = icmp slt i32 %18, 16
br i1 %19, label %20, label %41
20: ; preds = %17
%21 = load i8*, i8** %6
%22 = load i32, i32* %11
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i8, i8* %24
%26 = zext i8 %25 to i32
%27 = load i8*, i8** %8
%28 = load i32, i32* %11
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
%31 = load i8, i8* %30
%32 = zext i8 %31 to i32
%33 = xor i32 %26, %32
%34 = trunc i32 %33 to i8
%35 = load i32, i32* %11
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %16, i64 %36
store i8 %34, i8* %37
br label %38
38: ; preds = %20
%39 = load i32, i32* %11
%40 = add nsw i32 %39, 1
store i32 %40, i32* %11
br label %17
41: ; preds = %17
store i32 0, i32* %11
br label %42
42: ; preds = %132, %41
%43 = load i32, i32* %11
%44 = icmp slt i32 %43, 16
br i1 %44, label %45, label %135
45: ; preds = %42
%46 = load i32, i32* %11
%47 = icmp eq i32 %46, 0
br i1 %47, label %48, label %53
48: ; preds = %45
%49 = getelementptr inbounds i8, i8* %16, i64 0
%50 = load i8, i8* %49
%51 = zext i8 %50 to i32
%52 = shl i32 %51, 1
br label %68
53: ; preds = %45
%54 = load i32, i32* %11
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %16, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
%59 = shl i32 %58, 1
%60 = load i32, i32* %11
%61 = sub nsw i32 %60, 1
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i8, i8* %16, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = ashr i32 %65, 7
%67 = or i32 %59, %66
br label %68
68: ; preds = %53, %48
%69 = phi i32 [ %52, %48 ], [ %67, %53 ]
%70 = trunc i32 %69 to i8
store i8 %70, i8* %12
%71 = load i32, i32* %11
%72 = icmp eq i32 %71, 15
br i1 %72, label %73, label %80
73: ; preds = %68
%74 = load i32, i32* %11
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %16, i64 %75
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = ashr i32 %78, 3
br label %95
80: ; preds = %68
%81 = load i32, i32* %11
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %16, i64 %82
%84 = load i8, i8* %83
%85 = zext i8 %84 to i32
%86 = ashr i32 %85, 3
%87 = load i32, i32* %11
%88 = add nsw i32 %87, 1
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i8, i8* %16, i64 %89
%91 = load i8, i8* %90
%92 = zext i8 %91 to i32
%93 = shl i32 %92, 5
%94 = or i32 %86, %93
br label %95
95: ; preds = %80, %73
%96 = phi i32 [ %79, %73 ], [ %94, %80 ]
%97 = trunc i32 %96 to i8
store i8 %97, i8* %13
%98 = load i8, i8* %12
%99 = zext i8 %98 to i32
%100 = load i8, i8* %13
%101 = zext i8 %100 to i32
%102 = xor i32 %99, %101
%103 = trunc i32 %102 to i8
store i8 %103, i8* %14
%104 = load i8*, i8** %5
%105 = load i32, i32* %11
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i8, i8* %104, i64 %106
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = load i8*, i8** %7
%111 = load i32, i32* %11
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i8, i8* %110, i64 %112
%114 = load i8, i8* %113
%115 = zext i8 %114 to i32
%116 = xor i32 %109, %115
%117 = load i8*, i8** %8
%118 = load i32, i32* %11
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %117, i64 %119
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = xor i32 %116, %122
%124 = load i8, i8* %14
%125 = zext i8 %124 to i32
%126 = xor i32 %123, %125
%127 = trunc i32 %126 to i8
%128 = load i8*, i8** %5
%129 = load i32, i32* %11
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i8, i8* %128, i64 %130
store i8 %127, i8* %131
br label %132
132: ; preds = %95
%133 = load i32, i32* %11
%134 = add nsw i32 %133, 1
store i32 %134, i32* %11
br label %42
135: ; preds = %42
store i32 0, i32* %11
br label %136
136: ; preds = %157, %135
%137 = load i32, i32* %11
%138 = icmp slt i32 %137, 16
br i1 %138, label %139, label %160
139: ; preds = %136
%140 = load i8*, i8** %7
%141 = load i32, i32* %11
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i8, i8* %140, i64 %142
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = load i8*, i8** %5
%147 = load i32, i32* %11
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i8, i8* %146, i64 %148
%150 = load i8, i8* %149
%151 = zext i8 %150 to i32
%152 = xor i32 %145, %151
%153 = trunc i32 %152 to i8
%154 = load i32, i32* %11
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %16, i64 %155
store i8 %153, i8* %156
br label %157
157: ; preds = %139
%158 = load i32, i32* %11
%159 = add nsw i32 %158, 1
store i32 %159, i32* %11
br label %136
160: ; preds = %136
store i32 0, i32* %11
br label %161
161: ; preds = %251, %160
%162 = load i32, i32* %11
%163 = icmp slt i32 %162, 16
br i1 %163, label %164, label %254
164: ; preds = %161
%165 = load i32, i32* %11
%166 = icmp eq i32 %165, 0
br i1 %166, label %167, label %172
167: ; preds = %164
%168 = getelementptr inbounds i8, i8* %16, i64 0
%169 = load i8, i8* %168
%170 = zext i8 %169 to i32
%171 = shl i32 %170, 1
br label %187
172: ; preds = %164
%173 = load i32, i32* %11
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i8, i8* %16, i64 %174
%176 = load i8, i8* %175
%177 = zext i8 %176 to i32
%178 = shl i32 %177, 1
%179 = load i32, i32* %11
%180 = sub nsw i32 %179, 1
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %16, i64 %181
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = ashr i32 %184, 7
%186 = or i32 %178, %185
br label %187
187: ; preds = %172, %167
%188 = phi i32 [ %171, %167 ], [ %186, %172 ]
%189 = trunc i32 %188 to i8
store i8 %189, i8* %12
%190 = load i32, i32* %11
%191 = icmp eq i32 %190, 15
br i1 %191, label %192, label %199
192: ; preds = %187
%193 = load i32, i32* %11
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds i8, i8* %16, i64 %194
%196 = load i8, i8* %195
%197 = zext i8 %196 to i32
%198 = ashr i32 %197, 3
br label %214
199: ; preds = %187
%200 = load i32, i32* %11
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %16, i64 %201
%203 = load i8, i8* %202
%204 = zext i8 %203 to i32
%205 = ashr i32 %204, 3
%206 = load i32, i32* %11
%207 = add nsw i32 %206, 1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i8, i8* %16, i64 %208
%210 = load i8, i8* %209
%211 = zext i8 %210 to i32
%212 = shl i32 %211, 5
%213 = or i32 %205, %212
br label %214
214: ; preds = %199, %192
%215 = phi i32 [ %198, %192 ], [ %213, %199 ]
%216 = trunc i32 %215 to i8
store i8 %216, i8* %13
%217 = load i8, i8* %12
%218 = zext i8 %217 to i32
%219 = load i8, i8* %13
%220 = zext i8 %219 to i32
%221 = xor i32 %218, %220
%222 = trunc i32 %221 to i8
store i8 %222, i8* %14
%223 = load i8*, i8** %6
%224 = load i32, i32* %11
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i8, i8* %223, i64 %225
%227 = load i8, i8* %226
%228 = zext i8 %227 to i32
%229 = load i8*, i8** %8
%230 = load i32, i32* %11
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds i8, i8* %229, i64 %231
%233 = load i8, i8* %232
%234 = zext i8 %233 to i32
%235 = xor i32 %228, %234
%236 = load i8*, i8** %5
%237 = load i32, i32* %11
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %236, i64 %238
%240 = load i8, i8* %239
%241 = zext i8 %240 to i32
%242 = xor i32 %235, %241
%243 = load i8, i8* %14
%244 = zext i8 %243 to i32
%245 = xor i32 %242, %244
%246 = trunc i32 %245 to i8
%247 = load i8*, i8** %6
%248 = load i32, i32* %11
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %247, i64 %249
store i8 %246, i8* %250
br label %251
251: ; preds = %214
%252 = load i32, i32* %11
%253 = add nsw i32 %252, 1
store i32 %253, i32* %11
br label %161
254: ; preds = %161
store i32 0, i32* %11
br label %255
255: ; preds = %276, %254
%256 = load i32, i32* %11
%257 = icmp slt i32 %256, 16
br i1 %257, label %258, label %279
258: ; preds = %255
%259 = load i8*, i8** %8
%260 = load i32, i32* %11
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %259, i64 %261
%263 = load i8, i8* %262
%264 = zext i8 %263 to i32
%265 = load i8*, i8** %6
%266 = load i32, i32* %11
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i8, i8* %265, i64 %267
%269 = load i8, i8* %268
%270 = zext i8 %269 to i32
%271 = xor i32 %264, %270
%272 = trunc i32 %271 to i8
%273 = load i32, i32* %11
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i8, i8* %16, i64 %274
store i8 %272, i8* %275
br label %276
276: ; preds = %258
%277 = load i32, i32* %11
%278 = add nsw i32 %277, 1
store i32 %278, i32* %11
br label %255
279: ; preds = %255
store i32 0, i32* %11
br label %280
280: ; preds = %370, %279
%281 = load i32, i32* %11
%282 = icmp slt i32 %281, 16
br i1 %282, label %283, label %373
283: ; preds = %280
%284 = load i32, i32* %11
%285 = icmp eq i32 %284, 0
br i1 %285, label %286, label %291
286: ; preds = %283
%287 = getelementptr inbounds i8, i8* %16, i64 0
%288 = load i8, i8* %287
%289 = zext i8 %288 to i32
%290 = shl i32 %289, 1
br label %306
291: ; preds = %283
%292 = load i32, i32* %11
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i8, i8* %16, i64 %293
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = shl i32 %296, 1
%298 = load i32, i32* %11
%299 = sub nsw i32 %298, 1
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i8, i8* %16, i64 %300
%302 = load i8, i8* %301
%303 = zext i8 %302 to i32
%304 = ashr i32 %303, 7
%305 = or i32 %297, %304
br label %306
306: ; preds = %291, %286
%307 = phi i32 [ %290, %286 ], [ %305, %291 ]
%308 = trunc i32 %307 to i8
store i8 %308, i8* %12
%309 = load i32, i32* %11
%310 = icmp eq i32 %309, 15
br i1 %310, label %311, label %318
311: ; preds = %306
%312 = load i32, i32* %11
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8, i8* %16, i64 %313
%315 = load i8, i8* %314
%316 = zext i8 %315 to i32
%317 = ashr i32 %316, 3
br label %333
318: ; preds = %306
%319 = load i32, i32* %11
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i8, i8* %16, i64 %320
%322 = load i8, i8* %321
%323 = zext i8 %322 to i32
%324 = ashr i32 %323, 3
%325 = load i32, i32* %11
%326 = add nsw i32 %325, 1
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i8, i8* %16, i64 %327
%329 = load i8, i8* %328
%330 = zext i8 %329 to i32
%331 = shl i32 %330, 5
%332 = or i32 %324, %331
br label %333
333: ; preds = %318, %311
%334 = phi i32 [ %317, %311 ], [ %332, %318 ]
%335 = trunc i32 %334 to i8
store i8 %335, i8* %13
%336 = load i8, i8* %12
%337 = zext i8 %336 to i32
%338 = load i8, i8* %13
%339 = zext i8 %338 to i32
%340 = xor i32 %337, %339
%341 = trunc i32 %340 to i8
store i8 %341, i8* %14
%342 = load i8*, i8** %7
%343 = load i32, i32* %11
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds i8, i8* %342, i64 %344
%346 = load i8, i8* %345
%347 = zext i8 %346 to i32
%348 = load i8*, i8** %5
%349 = load i32, i32* %11
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds i8, i8* %348, i64 %350
%352 = load i8, i8* %351
%353 = zext i8 %352 to i32
%354 = xor i32 %347, %353
%355 = load i8*, i8** %6
%356 = load i32, i32* %11
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds i8, i8* %355, i64 %357
%359 = load i8, i8* %358
%360 = zext i8 %359 to i32
%361 = xor i32 %354, %360
%362 = load i8, i8* %14
%363 = zext i8 %362 to i32
%364 = xor i32 %361, %363
%365 = trunc i32 %364 to i8
%366 = load i8*, i8** %7
%367 = load i32, i32* %11
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds i8, i8* %366, i64 %368
store i8 %365, i8* %369
br label %370
370: ; preds = %333
%371 = load i32, i32* %11
%372 = add nsw i32 %371, 1
store i32 %372, i32* %11
br label %280
373: ; preds = %280
store i32 0, i32* %11
br label %374
374: ; preds = %395, %373
%375 = load i32, i32* %11
%376 = icmp slt i32 %375, 16
br i1 %376, label %377, label %398
377: ; preds = %374
%378 = load i8*, i8** %5
%379 = load i32, i32* %11
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds i8, i8* %378, i64 %380
%382 = load i8, i8* %381
%383 = zext i8 %382 to i32
%384 = load i8*, i8** %7
%385 = load i32, i32* %11
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i8, i8* %384, i64 %386
%388 = load i8, i8* %387
%389 = zext i8 %388 to i32
%390 = xor i32 %383, %389
%391 = trunc i32 %390 to i8
%392 = load i32, i32* %11
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i8, i8* %16, i64 %393
store i8 %391, i8* %394
br label %395
395: ; preds = %377
%396 = load i32, i32* %11
%397 = add nsw i32 %396, 1
store i32 %397, i32* %11
br label %374
398: ; preds = %374
store i32 0, i32* %11
br label %399
399: ; preds = %489, %398
%400 = load i32, i32* %11
%401 = icmp slt i32 %400, 16
br i1 %401, label %402, label %492
402: ; preds = %399
%403 = load i32, i32* %11
%404 = icmp eq i32 %403, 0
br i1 %404, label %405, label %410
405: ; preds = %402
%406 = getelementptr inbounds i8, i8* %16, i64 0
%407 = load i8, i8* %406
%408 = zext i8 %407 to i32
%409 = shl i32 %408, 1
br label %425
410: ; preds = %402
%411 = load i32, i32* %11
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i8, i8* %16, i64 %412
%414 = load i8, i8* %413
%415 = zext i8 %414 to i32
%416 = shl i32 %415, 1
%417 = load i32, i32* %11
%418 = sub nsw i32 %417, 1
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i8, i8* %16, i64 %419
%421 = load i8, i8* %420
%422 = zext i8 %421 to i32
%423 = ashr i32 %422, 7
%424 = or i32 %416, %423
br label %425
425: ; preds = %410, %405
%426 = phi i32 [ %409, %405 ], [ %424, %410 ]
%427 = trunc i32 %426 to i8
store i8 %427, i8* %12
%428 = load i32, i32* %11
%429 = icmp eq i32 %428, 15
br i1 %429, label %430, label %437
430: ; preds = %425
%431 = load i32, i32* %11
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i8, i8* %16, i64 %432
%434 = load i8, i8* %433
%435 = zext i8 %434 to i32
%436 = ashr i32 %435, 3
br label %452
437: ; preds = %425
%438 = load i32, i32* %11
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i8, i8* %16, i64 %439
%441 = load i8, i8* %440
%442 = zext i8 %441 to i32
%443 = ashr i32 %442, 3
%444 = load i32, i32* %11
%445 = add nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i8, i8* %16, i64 %446
%448 = load i8, i8* %447
%449 = zext i8 %448 to i32
%450 = shl i32 %449, 5
%451 = or i32 %443, %450
br label %452
452: ; preds = %437, %430
%453 = phi i32 [ %436, %430 ], [ %451, %437 ]
%454 = trunc i32 %453 to i8
store i8 %454, i8* %13
%455 = load i8, i8* %12
%456 = zext i8 %455 to i32
%457 = load i8, i8* %13
%458 = zext i8 %457 to i32
%459 = xor i32 %456, %458
%460 = trunc i32 %459 to i8
store i8 %460, i8* %14
%461 = load i8*, i8** %8
%462 = load i32, i32* %11
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds i8, i8* %461, i64 %463
%465 = load i8, i8* %464
%466 = zext i8 %465 to i32
%467 = load i8*, i8** %6
%468 = load i32, i32* %11
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i8, i8* %467, i64 %469
%471 = load i8, i8* %470
%472 = zext i8 %471 to i32
%473 = xor i32 %466, %472
%474 = load i8*, i8** %7
%475 = load i32, i32* %11
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds i8, i8* %474, i64 %476
%478 = load i8, i8* %477
%479 = zext i8 %478 to i32
%480 = xor i32 %473, %479
%481 = load i8, i8* %14
%482 = zext i8 %481 to i32
%483 = xor i32 %480, %482
%484 = trunc i32 %483 to i8
%485 = load i8*, i8** %8
%486 = load i32, i32* %11
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds i8, i8* %485, i64 %487
store i8 %484, i8* %488
br label %489
489: ; preds = %452
%490 = load i32, i32* %11
%491 = add nsw i32 %490, 1
store i32 %491, i32* %11
br label %399
492: ; preds = %399
%493 = load i8*, i8** %10
ret void
}

LLVM IR (-O2):
define void @transformation_D1(i8* nocapture %0, i8* nocapture %1, i8* nocapture %2, i8* nocapture %3) {
%5 = alloca <16 x i8>
%6 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 0
%7 = getelementptr inbounds i8, i8* %1, i64 1
%8 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 1
%9 = getelementptr inbounds i8, i8* %1, i64 2
%10 = getelementptr inbounds i8, i8* %1, i64 4
%11 = getelementptr inbounds i8, i8* %1, i64 8
%12 = bitcast i8* %1 to <16 x i8>*
%13 = load <16 x i8>, <16 x i8>* %12
%14 = bitcast i8* %3 to <16 x i8>*
%15 = load <16 x i8>, <16 x i8>* %14
%16 = xor <16 x i8> %15, %13
store <16 x i8> %16, <16 x i8>* %5
%17 = extractelement <16 x i8> %16, i64 15
%18 = lshr i8 %17, 3
%19 = load i8, i8* %6
%20 = shl i8 %19, 1
%21 = load i8, i8* %8
%22 = tail call i8 @llvm.fshl.i8(i8 %21, i8 %19, i8 5)
%23 = load i8, i8* %0
%24 = load i8, i8* %2
%25 = load i8, i8* %3
%26 = xor i8 %22, %20
%27 = xor i8 %26, %23
%28 = xor i8 %27, %24
%29 = xor i8 %28, %25
store i8 %29, i8* %0
br label %30
30: ; preds = %42, %4
%31 = phi i8 [ %19, %4 ], [ %34, %42 ]
%32 = phi i64 [ 1, %4 ], [ %43, %42 ]
%33 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %32
%34 = load i8, i8* %33
%35 = tail call i8 @llvm.fshl.i8(i8 %34, i8 %31, i8 1)
%36 = icmp eq i64 %32, 15
br i1 %36, label %42, label %37
37: ; preds = %30
%38 = add nuw nsw i64 %32, 1
%39 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %38
%40 = load i8, i8* %39
%41 = tail call i8 @llvm.fshl.i8(i8 %40, i8 %34, i8 5)
br label %42
42: ; preds = %30, %37
%43 = phi i64 [ %38, %37 ], [ 16, %30 ]
%44 = phi i8 [ %41, %37 ], [ %18, %30 ]
%45 = getelementptr inbounds i8, i8* %0, i64 %32
%46 = load i8, i8* %45
%47 = getelementptr inbounds i8, i8* %2, i64 %32
%48 = load i8, i8* %47
%49 = getelementptr inbounds i8, i8* %3, i64 %32
%50 = load i8, i8* %49
%51 = xor i8 %44, %35
%52 = xor i8 %51, %46
%53 = xor i8 %52, %48
%54 = xor i8 %53, %50
store i8 %54, i8* %45
%55 = icmp eq i64 %43, 16
br i1 %55, label %56, label %30
56: ; preds = %42
%57 = getelementptr inbounds i8, i8* %2, i64 1
%58 = getelementptr inbounds i8, i8* %0, i64 1
%59 = load i8, i8* %58
%60 = getelementptr inbounds i8, i8* %2, i64 2
%61 = getelementptr inbounds i8, i8* %0, i64 2
%62 = bitcast i8* %61 to <2 x i8>*
%63 = load <2 x i8>, <2 x i8>* %62
%64 = getelementptr inbounds i8, i8* %2, i64 4
%65 = getelementptr inbounds i8, i8* %0, i64 4
%66 = bitcast i8* %65 to <4 x i8>*
%67 = load <4 x i8>, <4 x i8>* %66
%68 = getelementptr inbounds i8, i8* %2, i64 8
%69 = getelementptr inbounds i8, i8* %0, i64 8
%70 = bitcast i8* %2 to <16 x i8>*
%71 = load <16 x i8>, <16 x i8>* %70
%72 = bitcast i8* %69 to <8 x i8>*
%73 = load <8 x i8>, <8 x i8>* %72
%74 = insertelement <16 x i8> poison, i8 %29, i64 0
%75 = insertelement <16 x i8> %74, i8 %59, i64 1
%76 = shufflevector <2 x i8> %63, <2 x i8> poison, <16 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%77 = shufflevector <16 x i8> %75, <16 x i8> %76, <16 x i32> <i32 0, i32 1, i32 16, i32 17, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%78 = shufflevector <4 x i8> %67, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%79 = shufflevector <16 x i8> %77, <16 x i8> %78, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%80 = shufflevector <8 x i8> %73, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%81 = shufflevector <16 x i8> %79, <16 x i8> %80, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%82 = xor <16 x i8> %81, %71
store <16 x i8> %82, <16 x i8>* %5
%83 = extractelement <16 x i8> %82, i64 15
%84 = lshr i8 %83, 3
%85 = extractelement <16 x i8> %82, i64 0
%86 = shl i8 %85, 1
%87 = extractelement <16 x i8> %82, i64 1
%88 = tail call i8 @llvm.fshl.i8(i8 %87, i8 %85, i8 5)
%89 = load i8, i8* %1
%90 = load i8, i8* %3
%91 = xor i8 %88, %86
%92 = xor i8 %91, %89
%93 = xor i8 %92, %90
%94 = xor i8 %93, %29
store i8 %94, i8* %1
br label %95
95: ; preds = %107, %56
%96 = phi i8 [ %85, %56 ], [ %99, %107 ]
%97 = phi i64 [ 1, %56 ], [ %108, %107 ]
%98 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %97
%99 = load i8, i8* %98
%100 = tail call i8 @llvm.fshl.i8(i8 %99, i8 %96, i8 1)
%101 = icmp eq i64 %97, 15
br i1 %101, label %107, label %102
102: ; preds = %95
%103 = add nuw nsw i64 %97, 1
%104 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %103
%105 = load i8, i8* %104
%106 = tail call i8 @llvm.fshl.i8(i8 %105, i8 %99, i8 5)
br label %107
107: ; preds = %95, %102
%108 = phi i64 [ %103, %102 ], [ 16, %95 ]
%109 = phi i8 [ %106, %102 ], [ %84, %95 ]
%110 = getelementptr inbounds i8, i8* %1, i64 %97
%111 = load i8, i8* %110
%112 = getelementptr inbounds i8, i8* %3, i64 %97
%113 = load i8, i8* %112
%114 = getelementptr inbounds i8, i8* %0, i64 %97
%115 = load i8, i8* %114
%116 = xor i8 %109, %100
%117 = xor i8 %116, %111
%118 = xor i8 %117, %113
%119 = xor i8 %118, %115
store i8 %119, i8* %110
%120 = icmp eq i64 %108, 16
br i1 %120, label %121, label %95
121: ; preds = %107
%122 = load i8, i8* %7
%123 = bitcast i8* %9 to <2 x i8>*
%124 = load <2 x i8>, <2 x i8>* %123
%125 = bitcast i8* %10 to <4 x i8>*
%126 = load <4 x i8>, <4 x i8>* %125
%127 = bitcast i8* %3 to <16 x i8>*
%128 = load <16 x i8>, <16 x i8>* %127
%129 = bitcast i8* %11 to <8 x i8>*
%130 = load <8 x i8>, <8 x i8>* %129
%131 = insertelement <16 x i8> poison, i8 %94, i64 0
%132 = insertelement <16 x i8> %131, i8 %122, i64 1
%133 = shufflevector <2 x i8> %124, <2 x i8> poison, <16 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%134 = shufflevector <16 x i8> %132, <16 x i8> %133, <16 x i32> <i32 0, i32 1, i32 16, i32 17, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%135 = shufflevector <4 x i8> %126, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%136 = shufflevector <16 x i8> %134, <16 x i8> %135, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%137 = shufflevector <8 x i8> %130, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%138 = shufflevector <16 x i8> %136, <16 x i8> %137, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%139 = xor <16 x i8> %138, %128
store <16 x i8> %139, <16 x i8>* %5
%140 = extractelement <16 x i8> %139, i64 15
%141 = lshr i8 %140, 3
%142 = extractelement <16 x i8> %139, i64 0
%143 = shl i8 %142, 1
%144 = extractelement <16 x i8> %139, i64 1
%145 = tail call i8 @llvm.fshl.i8(i8 %144, i8 %142, i8 5)
%146 = load i8, i8* %2
%147 = load i8, i8* %0
%148 = xor i8 %145, %143
%149 = xor i8 %148, %146
%150 = xor i8 %149, %147
%151 = xor i8 %150, %94
store i8 %151, i8* %2
br label %152
152: ; preds = %164, %121
%153 = phi i8 [ %142, %121 ], [ %156, %164 ]
%154 = phi i64 [ 1, %121 ], [ %165, %164 ]
%155 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %154
%156 = load i8, i8* %155
%157 = tail call i8 @llvm.fshl.i8(i8 %156, i8 %153, i8 1)
%158 = icmp eq i64 %154, 15
br i1 %158, label %164, label %159
159: ; preds = %152
%160 = add nuw nsw i64 %154, 1
%161 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %160
%162 = load i8, i8* %161
%163 = tail call i8 @llvm.fshl.i8(i8 %162, i8 %156, i8 5)
br label %164
164: ; preds = %152, %159
%165 = phi i64 [ %160, %159 ], [ 16, %152 ]
%166 = phi i8 [ %163, %159 ], [ %141, %152 ]
%167 = getelementptr inbounds i8, i8* %2, i64 %154
%168 = load i8, i8* %167
%169 = getelementptr inbounds i8, i8* %0, i64 %154
%170 = load i8, i8* %169
%171 = getelementptr inbounds i8, i8* %1, i64 %154
%172 = load i8, i8* %171
%173 = xor i8 %166, %157
%174 = xor i8 %173, %168
%175 = xor i8 %174, %170
%176 = xor i8 %175, %172
store i8 %176, i8* %167
%177 = icmp eq i64 %165, 16
br i1 %177, label %178, label %152
178: ; preds = %164
%179 = load i8, i8* %57
%180 = bitcast i8* %60 to <2 x i8>*
%181 = load <2 x i8>, <2 x i8>* %180
%182 = bitcast i8* %64 to <4 x i8>*
%183 = load <4 x i8>, <4 x i8>* %182
%184 = bitcast i8* %0 to <16 x i8>*
%185 = load <16 x i8>, <16 x i8>* %184
%186 = bitcast i8* %68 to <8 x i8>*
%187 = load <8 x i8>, <8 x i8>* %186
%188 = insertelement <16 x i8> poison, i8 %151, i64 0
%189 = insertelement <16 x i8> %188, i8 %179, i64 1
%190 = shufflevector <2 x i8> %181, <2 x i8> poison, <16 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%191 = shufflevector <16 x i8> %189, <16 x i8> %190, <16 x i32> <i32 0, i32 1, i32 16, i32 17, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%192 = shufflevector <4 x i8> %183, <4 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%193 = shufflevector <16 x i8> %191, <16 x i8> %192, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 16, i32 17, i32 18, i32 19, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%194 = shufflevector <8 x i8> %187, <8 x i8> poison, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%195 = shufflevector <16 x i8> %193, <16 x i8> %194, <16 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23>
%196 = xor <16 x i8> %195, %185
store <16 x i8> %196, <16 x i8>* %5
%197 = extractelement <16 x i8> %196, i64 15
%198 = lshr i8 %197, 3
%199 = extractelement <16 x i8> %196, i64 0
%200 = shl i8 %199, 1
%201 = extractelement <16 x i8> %196, i64 1
%202 = tail call i8 @llvm.fshl.i8(i8 %201, i8 %199, i8 5)
%203 = load i8, i8* %3
%204 = load i8, i8* %1
%205 = xor i8 %202, %200
%206 = xor i8 %205, %203
%207 = xor i8 %206, %204
%208 = xor i8 %207, %151
store i8 %208, i8* %3
br label %209
209: ; preds = %221, %178
%210 = phi i8 [ %199, %178 ], [ %213, %221 ]
%211 = phi i64 [ 1, %178 ], [ %222, %221 ]
%212 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %211
%213 = load i8, i8* %212
%214 = tail call i8 @llvm.fshl.i8(i8 %213, i8 %210, i8 1)
%215 = icmp eq i64 %211, 15
br i1 %215, label %221, label %216
216: ; preds = %209
%217 = add nuw nsw i64 %211, 1
%218 = getelementptr inbounds <16 x i8>, <16 x i8>* %5, i64 0, i64 %217
%219 = load i8, i8* %218
%220 = tail call i8 @llvm.fshl.i8(i8 %219, i8 %213, i8 5)
br label %221
221: ; preds = %209, %216
%222 = phi i64 [ %217, %216 ], [ 16, %209 ]
%223 = phi i8 [ %220, %216 ], [ %198, %209 ]
%224 = getelementptr inbounds i8, i8* %3, i64 %211
%225 = load i8, i8* %224
%226 = getelementptr inbounds i8, i8* %1, i64 %211
%227 = load i8, i8* %226
%228 = getelementptr inbounds i8, i8* %2, i64 %211
%229 = load i8, i8* %228
%230 = xor i8 %223, %214
%231 = xor i8 %230, %225
%232 = xor i8 %231, %227
%233 = xor i8 %232, %229
store i8 %233, i8* %224
%234 = icmp eq i64 %222, 16
br i1 %234, label %235, label %209
235: ; preds = %221
ret void
}