int decodebit(unsigned char *data, int threshold) {
  return ((data[0] + data[1] + data[2] + data[3] + data[4] + data[5] + data[6] +
           data[7] + data[8] + data[9] + data[10] + data[11] + data[12] +
           data[13] + data[14] + data[15] + data[16] + data[17] + data[18] +
           data[19] + data[20] + data[21] + data[22] + data[23] + data[24] +
           data[25] + data[26] + data[27] + data[28] + data[29] + data[30] +
           data[31]) >>
          5 > threshold);
}


x86 assembly (clang, -O0):
<decodebit>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xd(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x10(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x11(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x12(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x13(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x14(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x15(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x16(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x17(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x18(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x19(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1a(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1b(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1c(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1d(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1e(%rcx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0x1f(%rcx),%ecx
add    %ecx,%eax
sar    $0x5,%eax
cmp    -0xc(%rbp),%eax
setg   %al
and    $0x1,%al
movzbl %al,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<decodebit>:
movdqu (%rdi),%xmm0
movdqu 0x10(%rdi),%xmm1
pxor   %xmm2,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm2,%xmm3
movdqa %xmm3,%xmm4
punpckhwd %xmm2,%xmm4
movdqa %xmm0,%xmm5
punpcklbw %xmm2,%xmm5
movdqa %xmm5,%xmm6
punpckhwd %xmm2,%xmm6
paddd  %xmm4,%xmm6
punpckhbw %xmm2,%xmm1
movdqa %xmm1,%xmm4
punpckhwd %xmm2,%xmm4
punpckhbw %xmm2,%xmm0
movdqa %xmm0,%xmm7
punpckhwd %xmm2,%xmm7
paddd  %xmm4,%xmm7
paddd  %xmm6,%xmm7
punpcklwd %xmm2,%xmm3
punpcklwd %xmm2,%xmm5
paddd  %xmm3,%xmm5
punpcklwd %xmm2,%xmm1
punpcklwd %xmm2,%xmm0
paddd  %xmm1,%xmm0
paddd  %xmm5,%xmm0
paddd  %xmm7,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
shr    $0x5,%ecx
xor    %eax,%eax
cmp    %esi,%ecx
setg   %al
ret

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

LLVM IR (-O2):
define i32 @decodebit(i8* %0, i32 %1) {
%3 = bitcast i8* %0 to <32 x i8>*
%4 = load <32 x i8>, <32 x i8>* %3
%5 = zext <32 x i8> %4 to <32 x i32>
%6 = call i32 @llvm.vector.reduce.add.v32i32(<32 x i32> %5)
%7 = lshr i32 %6, 5
%8 = icmp sgt i32 %7, %1
%9 = zext i1 %8 to i32
ret i32 %9
}