#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ uint32_t;

/* Variables and functions */
void bitslice_syndrome(uint32_t *slices) {
  const int firstBit = 31 - 1;
  int i, n;
  uint32_t paritymask = slices[0];
  for (i = 1; i < 32; ++i) {
    paritymask ^= slices[i];
    slices[i - 1] = slices[i];
  }
  slices[31] = 0;
  for (n = 0; n < 21; ++n) {
    const int bit = firstBit - n;
    slices[20 - n] ^= slices[bit];
    slices[23 - n] ^= slices[bit];
    slices[25 - n] ^= slices[bit];
    slices[26 - n] ^= slices[bit];
    slices[28 - n] ^= slices[bit];
    slices[29 - n] ^= slices[bit];
    slices[30 - n] ^= slices[bit];
    slices[31 - n] ^= slices[bit];
  }
  slices[31 - 21] |= paritymask;
}


x86 assembly (clang, -O0):
<bitslice_syndrome>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x1e,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x18(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x20,-0x10(%rbp)
jge    1163 <bitslice_syndrome+0x63>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    111f <bitslice_syndrome+0x1f>
mov    -0x8(%rbp),%rax
movl   $0x0,0x7c(%rax)
movl   $0x0,-0x14(%rbp)
cmpl   $0x15,-0x14(%rbp)
jge    1298 <bitslice_syndrome+0x198>
mov    $0x1e,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x14,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x17,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x19,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x1a,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x1c,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x1d,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x1e,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    $0x1f,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1175 <bitslice_syndrome+0x75>
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
or     0x28(%rax),%ecx
mov    %ecx,0x28(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<bitslice_syndrome>:
mov    (%rdi),%r8d
movdqu 0x4(%rdi),%xmm1
movdqu %xmm1,(%rdi)
movdqu 0x14(%rdi),%xmm2
movdqu %xmm2,0x10(%rdi)
movdqu 0x24(%rdi),%xmm3
movdqu %xmm3,0x20(%rdi)
movdqu 0x34(%rdi),%xmm4
movdqu %xmm4,0x30(%rdi)
movdqu 0x44(%rdi),%xmm5
movdqu %xmm5,0x40(%rdi)
movdqu 0x54(%rdi),%xmm6
movdqu %xmm6,0x50(%rdi)
movdqu 0x64(%rdi),%xmm0
movdqu %xmm0,0x60(%rdi)
mov    0x74(%rdi),%r9d
mov    %r9d,0x70(%rdi)
mov    0x78(%rdi),%ecx
mov    %ecx,0x74(%rdi)
mov    0x7c(%rdi),%edx
mov    %edx,0x78(%rdi)
movl   $0x0,0x7c(%rdi)
mov    $0x1e,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rsi,4),%eax
xor    %eax,-0x28(%rdi,%rsi,4)
xor    %eax,-0x1c(%rdi,%rsi,4)
xor    %eax,-0x14(%rdi,%rsi,4)
xor    %eax,-0x10(%rdi,%rsi,4)
xor    %eax,-0x8(%rdi,%rsi,4)
xor    %eax,-0x4(%rdi,%rsi,4)
movl   $0x0,(%rdi,%rsi,4)
add    $0xffffffffffffffff,%rsi
cmp    $0x9,%rsi
jne    1170 <bitslice_syndrome+0x70>
movd   %r8d,%xmm7
pxor   %xmm7,%xmm1
pxor   %xmm1,%xmm2
pxor   %xmm2,%xmm3
pxor   %xmm3,%xmm4
pxor   %xmm4,%xmm5
pxor   %xmm5,%xmm6
pxor   %xmm6,%xmm0
pshufd $0xee,%xmm0,%xmm1
pxor   %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pxor   %xmm1,%xmm0
movd   %xmm0,%eax
xor    %eax,%r9d
xor    %r9d,%ecx
xor    %ecx,%edx
or     %edx,0x28(%rdi)
ret

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

LLVM IR (-O2):
define void @bitslice_syndrome(i32* nocapture %0) {
%2 = load i32, i32* %0
%3 = getelementptr inbounds i32, i32* %0, i64 1
%4 = bitcast i32* %3 to <4 x i32>*
%5 = load <4 x i32>, <4 x i32>* %4
%6 = bitcast i32* %0 to <4 x i32>*
store <4 x i32> %5, <4 x i32>* %6
%7 = getelementptr inbounds i32, i32* %0, i64 5
%8 = bitcast i32* %7 to <4 x i32>*
%9 = load <4 x i32>, <4 x i32>* %8
%10 = getelementptr inbounds i32, i32* %0, i64 4
%11 = bitcast i32* %10 to <4 x i32>*
store <4 x i32> %9, <4 x i32>* %11
%12 = getelementptr inbounds i32, i32* %0, i64 9
%13 = bitcast i32* %12 to <4 x i32>*
%14 = load <4 x i32>, <4 x i32>* %13
%15 = getelementptr inbounds i32, i32* %0, i64 8
%16 = bitcast i32* %15 to <4 x i32>*
store <4 x i32> %14, <4 x i32>* %16
%17 = getelementptr inbounds i32, i32* %0, i64 13
%18 = bitcast i32* %17 to <4 x i32>*
%19 = load <4 x i32>, <4 x i32>* %18
%20 = getelementptr inbounds i32, i32* %0, i64 12
%21 = bitcast i32* %20 to <4 x i32>*
store <4 x i32> %19, <4 x i32>* %21
%22 = getelementptr inbounds i32, i32* %0, i64 17
%23 = bitcast i32* %22 to <4 x i32>*
%24 = load <4 x i32>, <4 x i32>* %23
%25 = getelementptr inbounds i32, i32* %0, i64 16
%26 = bitcast i32* %25 to <4 x i32>*
store <4 x i32> %24, <4 x i32>* %26
%27 = getelementptr inbounds i32, i32* %0, i64 21
%28 = bitcast i32* %27 to <4 x i32>*
%29 = load <4 x i32>, <4 x i32>* %28
%30 = getelementptr inbounds i32, i32* %0, i64 20
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %31
%32 = getelementptr inbounds i32, i32* %0, i64 25
%33 = bitcast i32* %32 to <4 x i32>*
%34 = load <4 x i32>, <4 x i32>* %33
%35 = getelementptr inbounds i32, i32* %0, i64 24
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %34, <4 x i32>* %36
%37 = getelementptr inbounds i32, i32* %0, i64 29
%38 = load i32, i32* %37
%39 = getelementptr inbounds i32, i32* %0, i64 28
store i32 %38, i32* %39
%40 = getelementptr inbounds i32, i32* %0, i64 30
%41 = load i32, i32* %40
%42 = getelementptr inbounds i32, i32* %0, i64 29
store i32 %41, i32* %42
%43 = getelementptr inbounds i32, i32* %0, i64 31
%44 = load i32, i32* %43
%45 = getelementptr inbounds i32, i32* %0, i64 30
store i32 %44, i32* %45
%46 = getelementptr inbounds i32, i32* %0, i64 31
store i32 0, i32* %46
br label %47
47: ; preds = %1, %47
%48 = phi i64 [ 0, %1 ], [ %76, %47 ]
%49 = sub nuw nsw i64 30, %48
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = load i32, i32* %50
%52 = sub nuw nsw i64 20, %48
%53 = getelementptr inbounds i32, i32* %0, i64 %52
%54 = load i32, i32* %53
%55 = xor i32 %54, %51
store i32 %55, i32* %53
%56 = sub nuw nsw i64 23, %48
%57 = getelementptr inbounds i32, i32* %0, i64 %56
%58 = load i32, i32* %57
%59 = xor i32 %58, %51
store i32 %59, i32* %57
%60 = sub nuw nsw i64 25, %48
%61 = getelementptr inbounds i32, i32* %0, i64 %60
%62 = load i32, i32* %61
%63 = xor i32 %62, %51
store i32 %63, i32* %61
%64 = sub nuw nsw i64 26, %48
%65 = getelementptr inbounds i32, i32* %0, i64 %64
%66 = load i32, i32* %65
%67 = xor i32 %66, %51
store i32 %67, i32* %65
%68 = sub nuw nsw i64 28, %48
%69 = getelementptr inbounds i32, i32* %0, i64 %68
%70 = load i32, i32* %69
%71 = xor i32 %70, %51
store i32 %71, i32* %69
%72 = sub nuw nsw i64 29, %48
%73 = getelementptr inbounds i32, i32* %0, i64 %72
%74 = load i32, i32* %73
%75 = xor i32 %74, %51
store i32 %75, i32* %73
store i32 0, i32* %50
%76 = add nuw nsw i64 %48, 1
%77 = icmp eq i64 %76, 21
br i1 %77, label %78, label %47
78: ; preds = %47
%79 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %2, i64 0
%80 = xor <4 x i32> %5, %79
%81 = xor <4 x i32> %9, %80
%82 = xor <4 x i32> %14, %81
%83 = xor <4 x i32> %19, %82
%84 = xor <4 x i32> %24, %83
%85 = xor <4 x i32> %29, %84
%86 = xor <4 x i32> %34, %85
%87 = call i32 @llvm.vector.reduce.xor.v4i32(<4 x i32> %86)
%88 = xor i32 %38, %87
%89 = xor i32 %41, %88
%90 = xor i32 %44, %89
%91 = getelementptr inbounds i32, i32* %0, i64 10
%92 = load i32, i32* %91
%93 = or i32 %92, %90
store i32 %93, i32* %91
ret void
}