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

/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int pack2bit1chan(float **in, int off, char *out, float mean, float stddev,
                  int len) {
  int i, j, ch[4];
  float maxposThresh, maxnegThresh, *f;
  if (len % 4 != 0) {
    printf("Can only pack multiple of 4 samples!\n");
    return (1);
  }
  maxposThresh = mean + stddev * 0.95;
  maxnegThresh = mean - stddev * 0.95;
  f = &in[0][off];
  j = 0;
  for (i = 0; i < len;) {
    {
      if (f[i] >= maxposThresh)
        ch[0] = 3;
      else if (f[i] <= maxnegThresh)
        ch[0] = 0;
      else if (f[i] > mean)
        ch[0] = 2;
      else
        ch[0] = 1;
    };
    i++;
    {
      if (f[i] >= maxposThresh)
        ch[1] = 3;
      else if (f[i] <= maxnegThresh)
        ch[1] = 0;
      else if (f[i] > mean)
        ch[1] = 2;
      else
        ch[1] = 1;
    };
    i++;
    {
      if (f[i] >= maxposThresh)
        ch[2] = 3;
      else if (f[i] <= maxnegThresh)
        ch[2] = 0;
      else if (f[i] > mean)
        ch[2] = 2;
      else
        ch[2] = 1;
    };
    i++;
    {
      if (f[i] >= maxposThresh)
        ch[3] = 3;
      else if (f[i] <= maxnegThresh)
        ch[3] = 0;
      else if (f[i] > mean)
        ch[3] = 2;
      else
        ch[3] = 1;
    };
    i++;
    out[j] = (ch[0]) | ((ch[1] << 2)) | ((ch[2] << 4)) | ((ch[3] << 6));
    j++;
  }
  return 0;
}


x86 assembly (clang, -O0):
<pack2bit1chan>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
movss  %xmm1,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     115c <pack2bit1chan+0x4c>
lea    0xebd(%rip),%rdi
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1452 <pack2bit1chan+0x342>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe8a(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x28(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xe48(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    144b <pack2bit1chan+0x33b>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     121c <pack2bit1chan+0x10c>
movl   $0x3,-0x50(%rbp)
jmp    1277 <pack2bit1chan+0x167>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1243 <pack2bit1chan+0x133>
movl   $0x0,-0x50(%rbp)
jmp    1272 <pack2bit1chan+0x162>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    1266 <pack2bit1chan+0x156>
movl   $0x2,-0x50(%rbp)
jmp    126d <pack2bit1chan+0x15d>
movl   $0x1,-0x50(%rbp)
jmp    1272 <pack2bit1chan+0x162>
jmp    1277 <pack2bit1chan+0x167>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     12a3 <pack2bit1chan+0x193>
movl   $0x3,-0x4c(%rbp)
jmp    12fe <pack2bit1chan+0x1ee>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     12ca <pack2bit1chan+0x1ba>
movl   $0x0,-0x4c(%rbp)
jmp    12f9 <pack2bit1chan+0x1e9>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    12ed <pack2bit1chan+0x1dd>
movl   $0x2,-0x4c(%rbp)
jmp    12f4 <pack2bit1chan+0x1e4>
movl   $0x1,-0x4c(%rbp)
jmp    12f9 <pack2bit1chan+0x1e9>
jmp    12fe <pack2bit1chan+0x1ee>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     132a <pack2bit1chan+0x21a>
movl   $0x3,-0x48(%rbp)
jmp    1385 <pack2bit1chan+0x275>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     1351 <pack2bit1chan+0x241>
movl   $0x0,-0x48(%rbp)
jmp    1380 <pack2bit1chan+0x270>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    1374 <pack2bit1chan+0x264>
movl   $0x2,-0x48(%rbp)
jmp    137b <pack2bit1chan+0x26b>
movl   $0x1,-0x48(%rbp)
jmp    1380 <pack2bit1chan+0x270>
jmp    1385 <pack2bit1chan+0x275>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x54(%rbp),%xmm0
jb     13b1 <pack2bit1chan+0x2a1>
movl   $0x3,-0x44(%rbp)
jmp    140c <pack2bit1chan+0x2fc>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     13d8 <pack2bit1chan+0x2c8>
movl   $0x0,-0x44(%rbp)
jmp    1407 <pack2bit1chan+0x2f7>
mov    -0x60(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    13fb <pack2bit1chan+0x2eb>
movl   $0x2,-0x44(%rbp)
jmp    1402 <pack2bit1chan+0x2f2>
movl   $0x1,-0x44(%rbp)
jmp    1407 <pack2bit1chan+0x2f7>
jmp    140c <pack2bit1chan+0x2fc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
or     %ecx,%eax
mov    -0x48(%rbp),%ecx
shl    $0x4,%ecx
or     %ecx,%eax
mov    -0x44(%rbp),%ecx
shl    $0x6,%ecx
or     %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    11ed <pack2bit1chan+0xdd>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pack2bit1chan>:
push   %rax
test   $0x3,%cl
je     1129 <pack2bit1chan+0x19>
lea    0xeeb(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%eax
pop    %rcx
ret
test   %ecx,%ecx
jle    1253 <pack2bit1chan+0x143>
cvtss2sd %xmm1,%xmm2
mulsd  0xec3(%rip),%xmm2
cvtss2sd %xmm0,%xmm3
movapd %xmm2,%xmm1
addsd  %xmm3,%xmm1
cvtsd2ss %xmm1,%xmm1
subsd  %xmm2,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
mov    (%rdi),%rax
movslq %esi,%rsi
add    $0xffffffff,%ecx
shr    $0x2,%ecx
add    $0x1,%ecx
lea    (%rax,%rsi,4),%rax
add    $0xc,%rax
xor    %r11d,%r11d
mov    $0x80,%r8d
jmp    11aa <pack2bit1chan+0x9a>
nopw   0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm3
mov    $0x40,%esi
cmova  %r8d,%esi
or     %r9b,%dil
or     %r10b,%dil
or     %sil,%dil
mov    %dil,(%rdx,%r11,1)
add    $0x1,%r11
add    $0x10,%rax
cmp    %r11,%rcx
je     1253 <pack2bit1chan+0x143>
movss  -0xc(%rax),%xmm3
mov    $0x3,%r9b
ucomiss %xmm1,%xmm3
jae    11d3 <pack2bit1chan+0xc3>
ucomiss %xmm3,%xmm2
jae    11d0 <pack2bit1chan+0xc0>
ucomiss %xmm0,%xmm3
seta   %r9b
add    $0x1,%r9b
jmp    11d3 <pack2bit1chan+0xc3>
nopl   0x0(%rax)
xor    %r9d,%r9d
movss  -0x8(%rax),%xmm3
mov    $0xc,%dil
ucomiss %xmm1,%xmm3
jae    1202 <pack2bit1chan+0xf2>
ucomiss %xmm3,%xmm2
jae    1200 <pack2bit1chan+0xf0>
ucomiss %xmm0,%xmm3
seta   %dil
shl    $0x2,%dil
add    $0x4,%dil
jmp    1202 <pack2bit1chan+0xf2>
cs nopw 0x0(%rax,%rax,1)
xor    %edi,%edi
movss  -0x4(%rax),%xmm3
mov    $0x30,%r10b
ucomiss %xmm1,%xmm3
jae    1233 <pack2bit1chan+0x123>
ucomiss %xmm3,%xmm2
jae    1230 <pack2bit1chan+0x120>
ucomiss %xmm0,%xmm3
seta   %r10b
shl    $0x4,%r10b
add    $0x10,%r10b
jmp    1233 <pack2bit1chan+0x123>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %r10d,%r10d
movss  (%rax),%xmm3
mov    $0xc0,%sil
ucomiss %xmm1,%xmm3
jae    118c <pack2bit1chan+0x7c>
ucomiss %xmm3,%xmm2
jb     1180 <pack2bit1chan+0x70>
xor    %esi,%esi
jmp    118c <pack2bit1chan+0x7c>
xor    %eax,%eax
pop    %rcx
ret

LLVM IR (-O0):
@.str = [38 x i8] c"Can only pack multiple of 4 samples!\0A\00"
define i32 @pack2bit1chan(float** %0, i32 %1, i8* %2, float %3, float %4, i32 %5) {
%7 = alloca i32
%8 = alloca float**
%9 = alloca i32
%10 = alloca i8*
%11 = alloca float
%12 = alloca float
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca [4 x i32]
%17 = alloca float
%18 = alloca float
%19 = alloca float*
store float** %0, float*** %8
store i32 %1, i32* %9
store i8* %2, i8** %10
store float %3, float* %11
store float %4, float* %12
store i32 %5, i32* %13
%20 = load i32, i32* %13
%21 = srem i32 %20, 4
%22 = icmp ne i32 %21, 0
br i1 %22, label %23, label %25
23: ; preds = %6
%24 = call i32 @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %7
br label %216
25: ; preds = %6
%26 = load float, float* %11
%27 = fpext float %26 to double
%28 = load float, float* %12
%29 = fpext float %28 to double
%30 = call double @llvm.fmuladd.f64(double %29, double 0x3FEE666666666666, double %27)
%31 = fptrunc double %30 to float
store float %31, float* %17
%32 = load float, float* %11
%33 = fpext float %32 to double
%34 = load float, float* %12
%35 = fpext float %34 to double
%36 = fneg double %35
%37 = call double @llvm.fmuladd.f64(double %36, double 0x3FEE666666666666, double %33)
%38 = fptrunc double %37 to float
store float %38, float* %18
%39 = load float**, float*** %8
%40 = getelementptr inbounds float*, float** %39, i64 0
%41 = load float*, float** %40
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds float, float* %41, i64 %43
store float* %44, float** %19
store i32 0, i32* %15
store i32 0, i32* %14
br label %45
45: ; preds = %191, %25
%46 = load i32, i32* %14
%47 = load i32, i32* %13
%48 = icmp slt i32 %46, %47
br i1 %48, label %49, label %215
49: ; preds = %45
%50 = load float*, float** %19
%51 = load i32, i32* %14
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = load float, float* %17
%56 = fcmp oge float %54, %55
br i1 %56, label %57, label %59
57: ; preds = %49
%58 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
store i32 3, i32* %58
br label %83
59: ; preds = %49
%60 = load float*, float** %19
%61 = load i32, i32* %14
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
%65 = load float, float* %18
%66 = fcmp ole float %64, %65
br i1 %66, label %67, label %69
67: ; preds = %59
%68 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
store i32 0, i32* %68
br label %82
69: ; preds = %59
%70 = load float*, float** %19
%71 = load i32, i32* %14
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %70, i64 %72
%74 = load float, float* %73
%75 = load float, float* %11
%76 = fcmp ogt float %74, %75
br i1 %76, label %77, label %79
77: ; preds = %69
%78 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
store i32 2, i32* %78
br label %81
79: ; preds = %69
%80 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
store i32 1, i32* %80
br label %81
81: ; preds = %79, %77
br label %82
82: ; preds = %81, %67
br label %83
83: ; preds = %82, %57
%84 = load i32, i32* %14
%85 = add nsw i32 %84, 1
store i32 %85, i32* %14
%86 = load float*, float** %19
%87 = load i32, i32* %14
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %86, i64 %88
%90 = load float, float* %89
%91 = load float, float* %17
%92 = fcmp oge float %90, %91
br i1 %92, label %93, label %95
93: ; preds = %83
%94 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
store i32 3, i32* %94
br label %119
95: ; preds = %83
%96 = load float*, float** %19
%97 = load i32, i32* %14
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %96, i64 %98
%100 = load float, float* %99
%101 = load float, float* %18
%102 = fcmp ole float %100, %101
br i1 %102, label %103, label %105
103: ; preds = %95
%104 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
store i32 0, i32* %104
br label %118
105: ; preds = %95
%106 = load float*, float** %19
%107 = load i32, i32* %14
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %106, i64 %108
%110 = load float, float* %109
%111 = load float, float* %11
%112 = fcmp ogt float %110, %111
br i1 %112, label %113, label %115
113: ; preds = %105
%114 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
store i32 2, i32* %114
br label %117
115: ; preds = %105
%116 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
store i32 1, i32* %116
br label %117
117: ; preds = %115, %113
br label %118
118: ; preds = %117, %103
br label %119
119: ; preds = %118, %93
%120 = load i32, i32* %14
%121 = add nsw i32 %120, 1
store i32 %121, i32* %14
%122 = load float*, float** %19
%123 = load i32, i32* %14
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %122, i64 %124
%126 = load float, float* %125
%127 = load float, float* %17
%128 = fcmp oge float %126, %127
br i1 %128, label %129, label %131
129: ; preds = %119
%130 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
store i32 3, i32* %130
br label %155
131: ; preds = %119
%132 = load float*, float** %19
%133 = load i32, i32* %14
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds float, float* %132, i64 %134
%136 = load float, float* %135
%137 = load float, float* %18
%138 = fcmp ole float %136, %137
br i1 %138, label %139, label %141
139: ; preds = %131
%140 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
store i32 0, i32* %140
br label %154
141: ; preds = %131
%142 = load float*, float** %19
%143 = load i32, i32* %14
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds float, float* %142, i64 %144
%146 = load float, float* %145
%147 = load float, float* %11
%148 = fcmp ogt float %146, %147
br i1 %148, label %149, label %151
149: ; preds = %141
%150 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
store i32 2, i32* %150
br label %153
151: ; preds = %141
%152 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
store i32 1, i32* %152
br label %153
153: ; preds = %151, %149
br label %154
154: ; preds = %153, %139
br label %155
155: ; preds = %154, %129
%156 = load i32, i32* %14
%157 = add nsw i32 %156, 1
store i32 %157, i32* %14
%158 = load float*, float** %19
%159 = load i32, i32* %14
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
%162 = load float, float* %161
%163 = load float, float* %17
%164 = fcmp oge float %162, %163
br i1 %164, label %165, label %167
165: ; preds = %155
%166 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
store i32 3, i32* %166
br label %191
167: ; preds = %155
%168 = load float*, float** %19
%169 = load i32, i32* %14
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %168, i64 %170
%172 = load float, float* %171
%173 = load float, float* %18
%174 = fcmp ole float %172, %173
br i1 %174, label %175, label %177
175: ; preds = %167
%176 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
store i32 0, i32* %176
br label %190
177: ; preds = %167
%178 = load float*, float** %19
%179 = load i32, i32* %14
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds float, float* %178, i64 %180
%182 = load float, float* %181
%183 = load float, float* %11
%184 = fcmp ogt float %182, %183
br i1 %184, label %185, label %187
185: ; preds = %177
%186 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
store i32 2, i32* %186
br label %189
187: ; preds = %177
%188 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
store i32 1, i32* %188
br label %189
189: ; preds = %187, %185
br label %190
190: ; preds = %189, %175
br label %191
191: ; preds = %190, %165
%192 = load i32, i32* %14
%193 = add nsw i32 %192, 1
store i32 %193, i32* %14
%194 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 0
%195 = load i32, i32* %194
%196 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 1
%197 = load i32, i32* %196
%198 = shl i32 %197, 2
%199 = or i32 %195, %198
%200 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 2
%201 = load i32, i32* %200
%202 = shl i32 %201, 4
%203 = or i32 %199, %202
%204 = getelementptr inbounds [4 x i32], [4 x i32]* %16, i64 0, i64 3
%205 = load i32, i32* %204
%206 = shl i32 %205, 6
%207 = or i32 %203, %206
%208 = trunc i32 %207 to i8
%209 = load i8*, i8** %10
%210 = load i32, i32* %15
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %209, i64 %211
store i8 %208, i8* %212
%213 = load i32, i32* %15
%214 = add nsw i32 %213, 1
store i32 %214, i32* %15
br label %45
215: ; preds = %45
store i32 0, i32* %7
br label %216
216: ; preds = %215, %23
%217 = load i32, i32* %7
ret i32 %217
}

LLVM IR (-O2):
@str = [37 x i8] c"Can only pack multiple of 4 samples!\00"
define i32 @pack2bit1chan(float** nocapture %0, i32 %1, i8* nocapture writeonly %2, float %3, float %4, i32 %5) {
%7 = and i32 %5, 3
%8 = icmp eq i32 %7, 0
br i1 %8, label %11, label %9
9: ; preds = %6
%10 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @str, i64 0, i64 0))
br label %81
11: ; preds = %6
%12 = fpext float %3 to double
%13 = fpext float %4 to double
%14 = tail call double @llvm.fmuladd.f64(double %13, double 0x3FEE666666666666, double %12)
%15 = fptrunc double %14 to float
%16 = fneg double %13
%17 = tail call double @llvm.fmuladd.f64(double %16, double 0x3FEE666666666666, double %12)
%18 = fptrunc double %17 to float
%19 = load float*, float** %0
%20 = sext i32 %1 to i64
%21 = getelementptr inbounds float, float* %19, i64 %20
%22 = icmp sgt i32 %5, 0
br i1 %22, label %23, label %81
23: ; preds = %11
%24 = add nsw i32 %5, -1
%25 = lshr i32 %24, 2
%26 = add nuw nsw i32 %25, 1
%27 = zext i32 %26 to i64
br label %28
28: ; preds = %23, %72
%29 = phi i64 [ 0, %23 ], [ %79, %72 ]
%30 = phi i64 [ 0, %23 ], [ %74, %72 ]
%31 = getelementptr inbounds float, float* %21, i64 %30
%32 = load float, float* %31
%33 = fcmp ult float %32, %15
br i1 %33, label %34, label %39
34: ; preds = %28
%35 = fcmp ugt float %32, %18
br i1 %35, label %36, label %39
36: ; preds = %34
%37 = fcmp ogt float %32, %3
%38 = select i1 %37, i8 2, i8 1
br label %39
39: ; preds = %36, %34, %28
%40 = phi i8 [ 3, %28 ], [ 0, %34 ], [ %38, %36 ]
%41 = or i64 %30, 1
%42 = getelementptr inbounds float, float* %21, i64 %41
%43 = load float, float* %42
%44 = fcmp ult float %43, %15
br i1 %44, label %45, label %50
45: ; preds = %39
%46 = fcmp ugt float %43, %18
br i1 %46, label %47, label %50
47: ; preds = %45
%48 = fcmp ogt float %43, %3
%49 = select i1 %48, i8 8, i8 4
br label %50
50: ; preds = %47, %45, %39
%51 = phi i8 [ 12, %39 ], [ 0, %45 ], [ %49, %47 ]
%52 = or i64 %30, 2
%53 = getelementptr inbounds float, float* %21, i64 %52
%54 = load float, float* %53
%55 = fcmp ult float %54, %15
br i1 %55, label %56, label %61
56: ; preds = %50
%57 = fcmp ugt float %54, %18
br i1 %57, label %58, label %61
58: ; preds = %56
%59 = fcmp ogt float %54, %3
%60 = select i1 %59, i8 32, i8 16
br label %61
61: ; preds = %58, %56, %50
%62 = phi i8 [ 48, %50 ], [ 0, %56 ], [ %60, %58 ]
%63 = or i64 %30, 3
%64 = getelementptr inbounds float, float* %21, i64 %63
%65 = load float, float* %64
%66 = fcmp ult float %65, %15
br i1 %66, label %67, label %72
67: ; preds = %61
%68 = fcmp ugt float %65, %18
br i1 %68, label %69, label %72
69: ; preds = %67
%70 = fcmp ogt float %65, %3
%71 = select i1 %70, i8 -128, i8 64
br label %72
72: ; preds = %69, %67, %61
%73 = phi i8 [ -64, %61 ], [ 0, %67 ], [ %71, %69 ]
%74 = add nuw nsw i64 %30, 4
%75 = or i8 %51, %40
%76 = or i8 %75, %62
%77 = or i8 %76, %73
%78 = getelementptr inbounds i8, i8* %2, i64 %29
store i8 %77, i8* %78
%79 = add nuw nsw i64 %29, 1
%80 = icmp eq i64 %79, %27
br i1 %80, label %81, label %28
81: ; preds = %72, %11, %9
%82 = phi i32 [ 1, %9 ], [ 0, %11 ], [ 0, %72 ]
ret i32 %82
}