#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*/ cpu_set_t;

/* Variables and functions */
int __sched_cpucount(size_t size, const cpu_set_t *set) {
  size_t i, j, cnt = 0;
  const unsigned char *p = (const void *)set;
  for (i = 0; i < size; i++)
    for (j = 0; j < 8; j++)
      if (p[i] & (1 << j))
        cnt++;
  return cnt;
}


x86 assembly (clang, -O0):
<__sched_cpucount>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    11a1 <__sched_cpucount+0xa1>
movq   $0x0,-0x20(%rbp)
cmpq   $0x8,-0x20(%rbp)
jae    118b <__sched_cpucount+0x8b>
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1175 <__sched_cpucount+0x75>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    117a <__sched_cpucount+0x7a>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    113a <__sched_cpucount+0x3a>
jmp    1190 <__sched_cpucount+0x90>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1124 <__sched_cpucount+0x24>
mov    -0x28(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<__sched_cpucount>:
test   %rdi,%rdi
je     1115 <__sched_cpucount+0x15>
cmp    $0x4,%rdi
jae    1118 <__sched_cpucount+0x18>
xor    %r8d,%r8d
xor    %eax,%eax
jmp    12e5 <__sched_cpucount+0x1e5>
xor    %eax,%eax
ret
mov    %rdi,%r8
and    $0xfffffffffffffffc,%r8
pxor   %xmm9,%xmm9
xor    %eax,%eax
movdqa 0xed1(%rip),%xmm8
pxor   %xmm5,%xmm5
pxor   %xmm4,%xmm4
nopw   0x0(%rax,%rax,1)
movzwl (%rsi,%rax,1),%ecx
movd   %ecx,%xmm1
movzwl 0x2(%rsi,%rax,1),%ecx
movd   %ecx,%xmm0
punpcklbw %xmm9,%xmm1
punpcklwd %xmm9,%xmm1
punpcklbw %xmm9,%xmm0
punpcklwd %xmm9,%xmm0
movdqa %xmm1,%xmm3
pand   %xmm8,%xmm3
movdqa %xmm0,%xmm2
pand   %xmm8,%xmm2
punpckldq %xmm9,%xmm3
paddq  %xmm5,%xmm3
punpckldq %xmm9,%xmm2
paddq  %xmm4,%xmm2
movdqa %xmm1,%xmm7
psrld  $0x1,%xmm7
movdqa %xmm0,%xmm6
psrld  $0x1,%xmm6
pand   %xmm8,%xmm7
pand   %xmm8,%xmm6
punpckldq %xmm9,%xmm7
paddq  %xmm3,%xmm7
punpckldq %xmm9,%xmm6
paddq  %xmm2,%xmm6
movdqa %xmm1,%xmm2
psrld  $0x2,%xmm2
movdqa %xmm0,%xmm3
psrld  $0x2,%xmm3
pand   %xmm8,%xmm2
pand   %xmm8,%xmm3
punpckldq %xmm9,%xmm2
punpckldq %xmm9,%xmm3
movdqa %xmm1,%xmm5
psrld  $0x3,%xmm5
movdqa %xmm0,%xmm4
psrld  $0x3,%xmm4
pand   %xmm8,%xmm5
pand   %xmm8,%xmm4
punpckldq %xmm9,%xmm5
paddq  %xmm2,%xmm5
paddq  %xmm7,%xmm5
punpckldq %xmm9,%xmm4
paddq  %xmm3,%xmm4
paddq  %xmm6,%xmm4
movdqa %xmm1,%xmm2
psrld  $0x4,%xmm2
movdqa %xmm0,%xmm3
psrld  $0x4,%xmm3
pand   %xmm8,%xmm2
pand   %xmm8,%xmm3
punpckldq %xmm9,%xmm2
punpckldq %xmm9,%xmm3
movdqa %xmm1,%xmm6
psrld  $0x5,%xmm6
movdqa %xmm0,%xmm7
psrld  $0x5,%xmm7
pand   %xmm8,%xmm6
pand   %xmm8,%xmm7
punpckldq %xmm9,%xmm6
paddq  %xmm2,%xmm6
punpckldq %xmm9,%xmm7
paddq  %xmm3,%xmm7
movdqa %xmm1,%xmm2
psrld  $0x6,%xmm2
movdqa %xmm0,%xmm3
psrld  $0x6,%xmm3
pand   %xmm8,%xmm2
pand   %xmm8,%xmm3
punpckldq %xmm9,%xmm2
paddq  %xmm6,%xmm2
paddq  %xmm5,%xmm2
punpckldq %xmm9,%xmm3
paddq  %xmm7,%xmm3
paddq  %xmm4,%xmm3
psrld  $0x7,%xmm1
psrld  $0x7,%xmm0
punpckldq %xmm9,%xmm1
movdqa %xmm1,%xmm5
paddq  %xmm2,%xmm5
punpckldq %xmm9,%xmm0
movdqa %xmm0,%xmm4
paddq  %xmm3,%xmm4
add    $0x4,%rax
cmp    %rax,%r8
jne    1140 <__sched_cpucount+0x40>
paddq  %xmm5,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddq  %xmm4,%xmm0
movq   %xmm0,%rax
cmp    %rdi,%r8
je     135c <__sched_cpucount+0x25c>
mov    %rax,%r9
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%r8,1),%r11d
movzbl %r11b,%eax
mov    %r11d,%r10d
and    $0x1,%r10d
add    %r9,%r10
mov    %r11d,%edx
shr    %edx
and    $0x1,%edx
add    %r10,%rdx
mov    %r11d,%ecx
shr    $0x2,%ecx
and    $0x1,%ecx
add    %rdx,%rcx
mov    %r11d,%edx
shr    $0x3,%edx
and    $0x1,%edx
add    %rcx,%rdx
mov    %r11d,%ecx
shr    $0x4,%ecx
and    $0x1,%ecx
add    %rdx,%rcx
mov    %r11d,%edx
shr    $0x5,%edx
and    $0x1,%edx
add    %rcx,%rdx
shr    $0x6,%r11d
and    $0x1,%r11d
add    %rdx,%r11
shr    $0x7,%rax
add    %r11,%rax
add    $0x1,%r8
mov    %rax,%r9
cmp    %r8,%rdi
jne    12f0 <__sched_cpucount+0x1f0>
ret

LLVM IR (-O0):
define i32 @__sched_cpucount(i64 %0, i32* %1) {
%3 = alloca i64
%4 = alloca i32*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i8*
store i64 %0, i64* %3
store i32* %1, i32** %4
store i64 0, i64* %7
%9 = load i32*, i32** %4
%10 = bitcast i32* %9 to i8*
store i8* %10, i8** %8
store i64 0, i64* %5
br label %11
11: ; preds = %38, %2
%12 = load i64, i64* %5
%13 = load i64, i64* %3
%14 = icmp ult i64 %12, %13
br i1 %14, label %15, label %41
15: ; preds = %11
store i64 0, i64* %6
br label %16
16: ; preds = %34, %15
%17 = load i64, i64* %6
%18 = icmp ult i64 %17, 8
br i1 %18, label %19, label %37
19: ; preds = %16
%20 = load i8*, i8** %8
%21 = load i64, i64* %5
%22 = getelementptr inbounds i8, i8* %20, i64 %21
%23 = load i8, i8* %22
%24 = zext i8 %23 to i32
%25 = load i64, i64* %6
%26 = trunc i64 %25 to i32
%27 = shl i32 1, %26
%28 = and i32 %24, %27
%29 = icmp ne i32 %28, 0
br i1 %29, label %30, label %33
30: ; preds = %19
%31 = load i64, i64* %7
%32 = add i64 %31, 1
store i64 %32, i64* %7
br label %33
33: ; preds = %30, %19
br label %34
34: ; preds = %33
%35 = load i64, i64* %6
%36 = add i64 %35, 1
store i64 %36, i64* %6
br label %16
37: ; preds = %16
br label %38
38: ; preds = %37
%39 = load i64, i64* %5
%40 = add i64 %39, 1
store i64 %40, i64* %5
br label %11
41: ; preds = %11
%42 = load i64, i64* %7
%43 = trunc i64 %42 to i32
ret i32 %43
}

LLVM IR (-O2):
define i32 @__sched_cpucount(i64 %0, i32* nocapture %1) {
%3 = bitcast i32* %1 to i8*
%4 = icmp eq i64 %0, 0
br i1 %4, label %131, label %5
5: ; preds = %2
%6 = icmp ult i64 %0, 4
br i1 %6, label %87, label %7
7: ; preds = %5
%8 = and i64 %0, -4
br label %9
9: ; preds = %9, %7
%10 = phi i64 [ 0, %7 ], [ %81, %9 ]
%11 = phi <2 x i64> [ zeroinitializer, %7 ], [ %79, %9 ]
%12 = phi <2 x i64> [ zeroinitializer, %7 ], [ %80, %9 ]
%13 = getelementptr inbounds i8, i8* %3, i64 %10
%14 = bitcast i8* %13 to <2 x i8>*
%15 = load <2 x i8>, <2 x i8>* %14
%16 = getelementptr inbounds i8, i8* %13, i64 2
%17 = bitcast i8* %16 to <2 x i8>*
%18 = load <2 x i8>, <2 x i8>* %17
%19 = zext <2 x i8> %15 to <2 x i32>
%20 = zext <2 x i8> %18 to <2 x i32>
%21 = and <2 x i32> %19, <i32 1, i32 1>
%22 = and <2 x i32> %20, <i32 1, i32 1>
%23 = zext <2 x i32> %21 to <2 x i64>
%24 = zext <2 x i32> %22 to <2 x i64>
%25 = add <2 x i64> %11, %23
%26 = add <2 x i64> %12, %24
%27 = lshr <2 x i32> %19, <i32 1, i32 1>
%28 = lshr <2 x i32> %20, <i32 1, i32 1>
%29 = and <2 x i32> %27, <i32 1, i32 1>
%30 = and <2 x i32> %28, <i32 1, i32 1>
%31 = zext <2 x i32> %29 to <2 x i64>
%32 = zext <2 x i32> %30 to <2 x i64>
%33 = add <2 x i64> %25, %31
%34 = add <2 x i64> %26, %32
%35 = lshr <2 x i32> %19, <i32 2, i32 2>
%36 = lshr <2 x i32> %20, <i32 2, i32 2>
%37 = and <2 x i32> %35, <i32 1, i32 1>
%38 = and <2 x i32> %36, <i32 1, i32 1>
%39 = zext <2 x i32> %37 to <2 x i64>
%40 = zext <2 x i32> %38 to <2 x i64>
%41 = add <2 x i64> %33, %39
%42 = add <2 x i64> %34, %40
%43 = lshr <2 x i32> %19, <i32 3, i32 3>
%44 = lshr <2 x i32> %20, <i32 3, i32 3>
%45 = and <2 x i32> %43, <i32 1, i32 1>
%46 = and <2 x i32> %44, <i32 1, i32 1>
%47 = zext <2 x i32> %45 to <2 x i64>
%48 = zext <2 x i32> %46 to <2 x i64>
%49 = add <2 x i64> %41, %47
%50 = add <2 x i64> %42, %48
%51 = lshr <2 x i32> %19, <i32 4, i32 4>
%52 = lshr <2 x i32> %20, <i32 4, i32 4>
%53 = and <2 x i32> %51, <i32 1, i32 1>
%54 = and <2 x i32> %52, <i32 1, i32 1>
%55 = zext <2 x i32> %53 to <2 x i64>
%56 = zext <2 x i32> %54 to <2 x i64>
%57 = add <2 x i64> %49, %55
%58 = add <2 x i64> %50, %56
%59 = lshr <2 x i32> %19, <i32 5, i32 5>
%60 = lshr <2 x i32> %20, <i32 5, i32 5>
%61 = and <2 x i32> %59, <i32 1, i32 1>
%62 = and <2 x i32> %60, <i32 1, i32 1>
%63 = zext <2 x i32> %61 to <2 x i64>
%64 = zext <2 x i32> %62 to <2 x i64>
%65 = add <2 x i64> %57, %63
%66 = add <2 x i64> %58, %64
%67 = lshr <2 x i32> %19, <i32 6, i32 6>
%68 = lshr <2 x i32> %20, <i32 6, i32 6>
%69 = and <2 x i32> %67, <i32 1, i32 1>
%70 = and <2 x i32> %68, <i32 1, i32 1>
%71 = zext <2 x i32> %69 to <2 x i64>
%72 = zext <2 x i32> %70 to <2 x i64>
%73 = add <2 x i64> %65, %71
%74 = add <2 x i64> %66, %72
%75 = lshr <2 x i32> %19, <i32 7, i32 7>
%76 = lshr <2 x i32> %20, <i32 7, i32 7>
%77 = zext <2 x i32> %75 to <2 x i64>
%78 = zext <2 x i32> %76 to <2 x i64>
%79 = add <2 x i64> %73, %77
%80 = add <2 x i64> %74, %78
%81 = add nuw i64 %10, 4
%82 = icmp eq i64 %81, %8
br i1 %82, label %83, label %9
83: ; preds = %9
%84 = add <2 x i64> %80, %79
%85 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %84)
%86 = icmp eq i64 %8, %0
br i1 %86, label %128, label %87
87: ; preds = %5, %83
%88 = phi i64 [ 0, %5 ], [ %8, %83 ]
%89 = phi i64 [ 0, %5 ], [ %85, %83 ]
br label %90
90: ; preds = %87, %90
%91 = phi i64 [ %126, %90 ], [ %88, %87 ]
%92 = phi i64 [ %125, %90 ], [ %89, %87 ]
%93 = getelementptr inbounds i8, i8* %3, i64 %91
%94 = load i8, i8* %93
%95 = zext i8 %94 to i32
%96 = and i32 %95, 1
%97 = zext i32 %96 to i64
%98 = add i64 %92, %97
%99 = lshr i32 %95, 1
%100 = and i32 %99, 1
%101 = zext i32 %100 to i64
%102 = add i64 %98, %101
%103 = lshr i32 %95, 2
%104 = and i32 %103, 1
%105 = zext i32 %104 to i64
%106 = add i64 %102, %105
%107 = lshr i32 %95, 3
%108 = and i32 %107, 1
%109 = zext i32 %108 to i64
%110 = add i64 %106, %109
%111 = lshr i32 %95, 4
%112 = and i32 %111, 1
%113 = zext i32 %112 to i64
%114 = add i64 %110, %113
%115 = lshr i32 %95, 5
%116 = and i32 %115, 1
%117 = zext i32 %116 to i64
%118 = add i64 %114, %117
%119 = lshr i32 %95, 6
%120 = and i32 %119, 1
%121 = zext i32 %120 to i64
%122 = add i64 %118, %121
%123 = lshr i32 %95, 7
%124 = zext i32 %123 to i64
%125 = add i64 %122, %124
%126 = add nuw i64 %91, 1
%127 = icmp eq i64 %126, %0
br i1 %127, label %128, label %90
128: ; preds = %90, %83
%129 = phi i64 [ %85, %83 ], [ %125, %90 ]
%130 = trunc i64 %129 to i32
br label %131
131: ; preds = %128, %2
%132 = phi i32 [ 0, %2 ], [ %130, %128 ]
ret i32 %132
}