#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*/ HError(int, char *, long);
void ZeroMean(short *data, long nSamples) {
  long i, hiClip = 0, loClip = 0;
  short *x;
  double sum = 0.0, y, mean;
  x = data;
  for (i = 0; i < nSamples; i++, x++)
    sum += *x;
  mean = sum / (float)nSamples;
  x = data;
  for (i = 0; i < nSamples; i++, x++) {
    y = (double)(*x) - mean;
    if (y < -32767.0) {
      y = -32767.0;
      ++loClip;
    }
    if (y > 32767.0) {
      y = 32767.0;
      ++hiClip;
    }
    *x = (short)((y > 0.0) ? y + 0.5 : y - 0.5);
  }
  if (loClip > 0)
    HError(-5322, "ZeroMean: %d samples too -ve\n", loClip);
  if (hiClip > 0)
    HError(-5322, "ZeroMean: %d samples too +ve\n", hiClip);
}


x86 assembly (clang, -O0):
<ZeroMean>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1188 <ZeroMean+0x78>
mov    -0x30(%rbp),%rax
movswl (%rax),%eax
cvtsi2sd %eax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    1148 <ZeroMean+0x38>
movsd  -0x38(%rbp),%xmm0
cvtsi2ssq -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    129e <ZeroMean+0x18e>
mov    -0x30(%rbp),%rax
movswl (%rax),%eax
cvtsi2sd %eax,%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xe25(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    11ff <ZeroMean+0xef>
movsd  0xe12(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0xdfc(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    122f <ZeroMean+0x11f>
movsd  0xdea(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movsd  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1258 <ZeroMean+0x148>
movsd  0xdc7(%rip),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    126e <ZeroMean+0x15e>
movsd  -0x40(%rbp),%xmm0
movsd  0xdab(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%cx
mov    -0x30(%rbp),%rax
mov    %cx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x30(%rbp)
jmp    11b0 <ZeroMean+0xa0>
cmpq   $0x0,-0x28(%rbp)
jle    12be <ZeroMean+0x1ae>
mov    -0x28(%rbp),%rdx
mov    $0xffffeb36,%edi
lea    0xd5f(%rip),%rsi
call   1030 <HError@plt>
cmpq   $0x0,-0x20(%rbp)
jle    12de <ZeroMean+0x1ce>
mov    -0x20(%rbp),%rdx
mov    $0xffffeb36,%edi
lea    0xd5d(%rip),%rsi
call   1030 <HError@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ZeroMean>:
push   %rbx
test   %rsi,%rsi
jle    13fa <ZeroMean+0x2ea>
lea    -0x1(%rsi),%rcx
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1132 <ZeroMean+0x22>
xorpd  %xmm0,%xmm0
mov    %rdi,%rcx
jmp    1185 <ZeroMean+0x75>
mov    %rsi,%rdx
and    $0xfffffffffffffffc,%rdx
xorpd  %xmm0,%xmm0
mov    %rdi,%rcx
movswl (%rcx),%ebx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
movswl 0x2(%rcx),%ebx
xorps  %xmm2,%xmm2
cvtsi2sd %ebx,%xmm2
addsd  %xmm0,%xmm1
movswl 0x4(%rcx),%ebx
xorps  %xmm3,%xmm3
cvtsi2sd %ebx,%xmm3
addsd  %xmm1,%xmm2
movswl 0x6(%rcx),%ebx
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x8,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1140 <ZeroMean+0x30>
test   %rax,%rax
je     11a8 <ZeroMean+0x98>
xor    %edx,%edx
nopl   0x0(%rax)
movswl (%rcx,%rdx,2),%ebx
xorps  %xmm1,%xmm1
cvtsi2sd %ebx,%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1190 <ZeroMean+0x80>
test   %rsi,%rsi
jle    13fa <ZeroMean+0x2ea>
xorps  %xmm1,%xmm1
cvtsi2ss %rsi,%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cmp    $0x4,%rsi
jae    11d5 <ZeroMean+0xc5>
xor    %ecx,%ecx
mov    %rdi,%rax
xor    %edx,%edx
xor    %ebx,%ebx
jmp    134f <ZeroMean+0x23f>
mov    %rsi,%rcx
and    $0xfffffffffffffffc,%rcx
lea    (%rdi,%rcx,2),%rax
movapd %xmm0,%xmm10
unpcklpd %xmm0,%xmm10
pxor   %xmm13,%xmm13
xor    %edx,%edx
movapd 0xe06(%rip),%xmm11
movapd 0xe0d(%rip),%xmm12
movapd 0xe14(%rip),%xmm8
movapd 0xe1b(%rip),%xmm9
pxor   %xmm14,%xmm14
pxor   %xmm6,%xmm6
pxor   %xmm7,%xmm7
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   (%rdi,%rdx,2),%xmm3
movd   0x4(%rdi,%rdx,2),%xmm4
pshuflw $0x60,%xmm3,%xmm3
psrad  $0x10,%xmm3
cvtdq2pd %xmm3,%xmm3
pshuflw $0x60,%xmm4,%xmm4
psrad  $0x10,%xmm4
cvtdq2pd %xmm4,%xmm4
subpd  %xmm10,%xmm3
subpd  %xmm10,%xmm4
movapd %xmm11,%xmm5
maxpd  %xmm3,%xmm5
cmpltpd %xmm11,%xmm3
psubq  %xmm3,%xmm13
movapd %xmm11,%xmm3
maxpd  %xmm4,%xmm3
cmpltpd %xmm11,%xmm4
psubq  %xmm4,%xmm14
movapd %xmm12,%xmm4
cmpltpd %xmm5,%xmm4
psubq  %xmm4,%xmm6
movapd %xmm12,%xmm4
cmpltpd %xmm3,%xmm4
psubq  %xmm4,%xmm7
movapd %xmm12,%xmm4
minpd  %xmm5,%xmm4
movapd %xmm12,%xmm5
minpd  %xmm3,%xmm5
xorpd  %xmm3,%xmm3
cmpltpd %xmm4,%xmm3
xorpd  %xmm1,%xmm1
cmpltpd %xmm5,%xmm1
movapd %xmm9,%xmm2
andpd  %xmm3,%xmm2
andnpd %xmm8,%xmm3
orpd   %xmm2,%xmm3
movapd %xmm9,%xmm2
andpd  %xmm1,%xmm2
andnpd %xmm8,%xmm1
orpd   %xmm2,%xmm1
addpd  %xmm4,%xmm3
addpd  %xmm5,%xmm1
cvttpd2dq %xmm3,%xmm2
pshuflw $0xe8,%xmm2,%xmm2
cvttpd2dq %xmm1,%xmm1
pshuflw $0xe8,%xmm1,%xmm1
movd   %xmm2,(%rdi,%rdx,2)
movd   %xmm1,0x4(%rdi,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1230 <ZeroMean+0x120>
paddq  %xmm6,%xmm7
pshufd $0xee,%xmm7,%xmm1
paddq  %xmm7,%xmm1
movq   %xmm1,%rbx
paddq  %xmm13,%xmm14
pshufd $0xee,%xmm14,%xmm1
paddq  %xmm14,%xmm1
movq   %xmm1,%rdx
cmp    %rsi,%rcx
je     13ca <ZeroMean+0x2ba>
sub    %rcx,%rsi
xor    %ecx,%ecx
movsd  0xcf4(%rip),%xmm1
movsd  0xcf4(%rip),%xmm2
xorpd  %xmm3,%xmm3
lea    0xcd1(%rip),%r8
nop
movswl (%rax,%rcx,2),%edi
xorps  %xmm4,%xmm4
cvtsi2sd %edi,%xmm4
subsd  %xmm0,%xmm4
xor    %edi,%edi
ucomisd %xmm4,%xmm1
seta   %dil
add    %rdi,%rdx
movapd %xmm1,%xmm5
maxsd  %xmm4,%xmm5
xor    %edi,%edi
ucomisd %xmm2,%xmm5
seta   %dil
add    %rdi,%rbx
movapd %xmm2,%xmm4
minsd  %xmm5,%xmm4
xor    %edi,%edi
ucomisd %xmm3,%xmm4
seta   %dil
addsd  (%r8,%rdi,8),%xmm4
cvttsd2si %xmm4,%edi
mov    %di,(%rax,%rcx,2)
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1370 <ZeroMean+0x260>
test   %rdx,%rdx
je     13e0 <ZeroMean+0x2d0>
lea    0xc8a(%rip),%rsi
mov    $0xffffeb36,%edi
call   1030 <HError@plt>
test   %rbx,%rbx
je     13fa <ZeroMean+0x2ea>
lea    0xc92(%rip),%rsi
mov    $0xffffeb36,%edi
mov    %rbx,%rdx
pop    %rbx
jmp    1030 <HError@plt>
pop    %rbx
ret

LLVM IR (-O0):
@.str = [30 x i8] c"ZeroMean: %d samples too -ve\0A\00"
@.str.1 = [30 x i8] c"ZeroMean: %d samples too +ve\0A\00"
define void @ZeroMean(i16* %0, i64 %1) {
%3 = alloca i16*
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i16*
%9 = alloca double
%10 = alloca double
%11 = alloca double
store i16* %0, i16** %3
store i64 %1, i64* %4
store i64 0, i64* %6
store i64 0, i64* %7
store double 0.000000e+00, double* %9
%12 = load i16*, i16** %3
store i16* %12, i16** %8
store i64 0, i64* %5
br label %13
13: ; preds = %24, %2
%14 = load i64, i64* %5
%15 = load i64, i64* %4
%16 = icmp slt i64 %14, %15
br i1 %16, label %17, label %29
17: ; preds = %13
%18 = load i16*, i16** %8
%19 = load i16, i16* %18
%20 = sext i16 %19 to i32
%21 = sitofp i32 %20 to double
%22 = load double, double* %9
%23 = fadd double %22, %21
store double %23, double* %9
br label %24
24: ; preds = %17
%25 = load i64, i64* %5
%26 = add nsw i64 %25, 1
store i64 %26, i64* %5
%27 = load i16*, i16** %8
%28 = getelementptr inbounds i16, i16* %27, i32 1
store i16* %28, i16** %8
br label %13
29: ; preds = %13
%30 = load double, double* %9
%31 = load i64, i64* %4
%32 = sitofp i64 %31 to float
%33 = fpext float %32 to double
%34 = fdiv double %30, %33
store double %34, double* %11
%35 = load i16*, i16** %3
store i16* %35, i16** %8
store i64 0, i64* %5
br label %36
36: ; preds = %70, %29
%37 = load i64, i64* %5
%38 = load i64, i64* %4
%39 = icmp slt i64 %37, %38
br i1 %39, label %40, label %75
40: ; preds = %36
%41 = load i16*, i16** %8
%42 = load i16, i16* %41
%43 = sitofp i16 %42 to double
%44 = load double, double* %11
%45 = fsub double %43, %44
store double %45, double* %10
%46 = load double, double* %10
%47 = fcmp olt double %46, -3.276700e+04
br i1 %47, label %48, label %51
48: ; preds = %40
store double -3.276700e+04, double* %10
%49 = load i64, i64* %7
%50 = add nsw i64 %49, 1
store i64 %50, i64* %7
br label %51
51: ; preds = %48, %40
%52 = load double, double* %10
%53 = fcmp ogt double %52, 3.276700e+04
br i1 %53, label %54, label %57
54: ; preds = %51
store double 3.276700e+04, double* %10
%55 = load i64, i64* %6
%56 = add nsw i64 %55, 1
store i64 %56, i64* %6
br label %57
57: ; preds = %54, %51
%58 = load double, double* %10
%59 = fcmp ogt double %58, 0.000000e+00
br i1 %59, label %60, label %63
60: ; preds = %57
%61 = load double, double* %10
%62 = fadd double %61, 5.000000e-01
br label %66
63: ; preds = %57
%64 = load double, double* %10
%65 = fsub double %64, 5.000000e-01
br label %66
66: ; preds = %63, %60
%67 = phi double [ %62, %60 ], [ %65, %63 ]
%68 = fptosi double %67 to i16
%69 = load i16*, i16** %8
store i16 %68, i16* %69
br label %70
70: ; preds = %66
%71 = load i64, i64* %5
%72 = add nsw i64 %71, 1
store i64 %72, i64* %5
%73 = load i16*, i16** %8
%74 = getelementptr inbounds i16, i16* %73, i32 1
store i16* %74, i16** %8
br label %36
75: ; preds = %36
%76 = load i64, i64* %7
%77 = icmp sgt i64 %76, 0
br i1 %77, label %78, label %81
78: ; preds = %75
%79 = load i64, i64* %7
%80 = call i32 @HError(i32 -5322, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i64 %79)
br label %81
81: ; preds = %78, %75
%82 = load i64, i64* %6
%83 = icmp sgt i64 %82, 0
br i1 %83, label %84, label %87
84: ; preds = %81
%85 = load i64, i64* %6
%86 = call i32 @HError(i32 -5322, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i64 %85)
br label %87
87: ; preds = %84, %81
ret void
}

LLVM IR (-O2):
@.str = [30 x i8] c"ZeroMean: %d samples too -ve\0A\00"
@.str.1 = [30 x i8] c"ZeroMean: %d samples too +ve\0A\00"
define void @ZeroMean(i16* nocapture %0, i64 %1) {
%3 = icmp sgt i64 %1, 0
br i1 %3, label %4, label %149
4: ; preds = %2
%5 = add i64 %1, -1
%6 = and i64 %1, 3
%7 = icmp ult i64 %5, 3
br i1 %7, label %32, label %8
8: ; preds = %4
%9 = and i64 %1, -4
br label %10
10: ; preds = %10, %8
%11 = phi double [ 0.000000e+00, %8 ], [ %28, %10 ]
%12 = phi i16* [ %0, %8 ], [ %29, %10 ]
%13 = phi i64 [ 0, %8 ], [ %30, %10 ]
%14 = load i16, i16* %12
%15 = sitofp i16 %14 to double
%16 = fadd double %11, %15
%17 = getelementptr inbounds i16, i16* %12, i64 1
%18 = load i16, i16* %17
%19 = sitofp i16 %18 to double
%20 = fadd double %16, %19
%21 = getelementptr inbounds i16, i16* %12, i64 2
%22 = load i16, i16* %21
%23 = sitofp i16 %22 to double
%24 = fadd double %20, %23
%25 = getelementptr inbounds i16, i16* %12, i64 3
%26 = load i16, i16* %25
%27 = sitofp i16 %26 to double
%28 = fadd double %24, %27
%29 = getelementptr inbounds i16, i16* %12, i64 4
%30 = add i64 %13, 4
%31 = icmp eq i64 %30, %9
br i1 %31, label %32, label %10
32: ; preds = %10, %4
%33 = phi double [ undef, %4 ], [ %28, %10 ]
%34 = phi double [ 0.000000e+00, %4 ], [ %28, %10 ]
%35 = phi i16* [ %0, %4 ], [ %29, %10 ]
%36 = icmp eq i64 %6, 0
br i1 %36, label %47, label %37
37: ; preds = %32, %37
%38 = phi double [ %43, %37 ], [ %34, %32 ]
%39 = phi i16* [ %44, %37 ], [ %35, %32 ]
%40 = phi i64 [ %45, %37 ], [ 0, %32 ]
%41 = load i16, i16* %39
%42 = sitofp i16 %41 to double
%43 = fadd double %38, %42
%44 = getelementptr inbounds i16, i16* %39, i64 1
%45 = add i64 %40, 1
%46 = icmp eq i64 %45, %6
br i1 %46, label %47, label %37
47: ; preds = %37, %32
%48 = phi double [ %33, %32 ], [ %43, %37 ]
%49 = sitofp i64 %1 to float
%50 = fpext float %49 to double
%51 = fdiv double %48, %50
br i1 %3, label %52, label %149
52: ; preds = %47
%53 = icmp ult i64 %1, 4
br i1 %53, label %111, label %54
54: ; preds = %52
%55 = and i64 %1, -4
%56 = getelementptr i16, i16* %0, i64 %55
%57 = insertelement <2 x double> poison, double %51, i64 0
%58 = shufflevector <2 x double> %57, <2 x double> poison, <2 x i32> zeroinitializer
%59 = insertelement <2 x double> poison, double %51, i64 0
%60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
br label %61
61: ; preds = %61, %54
%62 = phi i64 [ 0, %54 ], [ %103, %61 ]
%63 = phi <2 x i64> [ zeroinitializer, %54 ], [ %81, %61 ]
%64 = phi <2 x i64> [ zeroinitializer, %54 ], [ %82, %61 ]
%65 = phi <2 x i64> [ zeroinitializer, %54 ], [ %89, %61 ]
%66 = phi <2 x i64> [ zeroinitializer, %54 ], [ %90, %61 ]
%67 = getelementptr i16, i16* %0, i64 %62
%68 = bitcast i16* %67 to <2 x i16>*
%69 = load <2 x i16>, <2 x i16>* %68
%70 = getelementptr i16, i16* %67, i64 2
%71 = bitcast i16* %70 to <2 x i16>*
%72 = load <2 x i16>, <2 x i16>* %71
%73 = sitofp <2 x i16> %69 to <2 x double>
%74 = sitofp <2 x i16> %72 to <2 x double>
%75 = fsub <2 x double> %73, %58
%76 = fsub <2 x double> %74, %60
%77 = fcmp olt <2 x double> %75, <double -3.276700e+04, double -3.276700e+04>
%78 = fcmp olt <2 x double> %76, <double -3.276700e+04, double -3.276700e+04>
%79 = zext <2 x i1> %77 to <2 x i64>
%80 = zext <2 x i1> %78 to <2 x i64>
%81 = add <2 x i64> %63, %79
%82 = add <2 x i64> %64, %80
%83 = select <2 x i1> %77, <2 x double> <double -3.276700e+04, double -3.276700e+04>, <2 x double> %75
%84 = select <2 x i1> %78, <2 x double> <double -3.276700e+04, double -3.276700e+04>, <2 x double> %76
%85 = fcmp ogt <2 x double> %83, <double 3.276700e+04, double 3.276700e+04>
%86 = fcmp ogt <2 x double> %84, <double 3.276700e+04, double 3.276700e+04>
%87 = zext <2 x i1> %85 to <2 x i64>
%88 = zext <2 x i1> %86 to <2 x i64>
%89 = add <2 x i64> %65, %87
%90 = add <2 x i64> %66, %88
%91 = select <2 x i1> %85, <2 x double> <double 3.276700e+04, double 3.276700e+04>, <2 x double> %83
%92 = select <2 x i1> %86, <2 x double> <double 3.276700e+04, double 3.276700e+04>, <2 x double> %84
%93 = fcmp ogt <2 x double> %91, zeroinitializer
%94 = fcmp ogt <2 x double> %92, zeroinitializer
%95 = select <2 x i1> %93, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> <double -5.000000e-01, double -5.000000e-01>
%96 = select <2 x i1> %94, <2 x double> <double 5.000000e-01, double 5.000000e-01>, <2 x double> <double -5.000000e-01, double -5.000000e-01>
%97 = fadd <2 x double> %91, %95
%98 = fadd <2 x double> %92, %96
%99 = fptosi <2 x double> %97 to <2 x i16>
%100 = fptosi <2 x double> %98 to <2 x i16>
%101 = bitcast i16* %67 to <2 x i16>*
store <2 x i16> %99, <2 x i16>* %101
%102 = bitcast i16* %70 to <2 x i16>*
store <2 x i16> %100, <2 x i16>* %102
%103 = add nuw i64 %62, 4
%104 = icmp eq i64 %103, %55
br i1 %104, label %105, label %61
105: ; preds = %61
%106 = add <2 x i64> %90, %89
%107 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %106)
%108 = add <2 x i64> %82, %81
%109 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %108)
%110 = icmp eq i64 %55, %1
br i1 %110, label %139, label %111
111: ; preds = %52, %105
%112 = phi i64 [ 0, %52 ], [ %55, %105 ]
%113 = phi i16* [ %0, %52 ], [ %56, %105 ]
%114 = phi i64 [ 0, %52 ], [ %109, %105 ]
%115 = phi i64 [ 0, %52 ], [ %107, %105 ]
br label %116
116: ; preds = %111, %116
%117 = phi i64 [ %136, %116 ], [ %112, %111 ]
%118 = phi i16* [ %137, %116 ], [ %113, %111 ]
%119 = phi i64 [ %126, %116 ], [ %114, %111 ]
%120 = phi i64 [ %130, %116 ], [ %115, %111 ]
%121 = load i16, i16* %118
%122 = sitofp i16 %121 to double
%123 = fsub double %122, %51
%124 = fcmp olt double %123, -3.276700e+04
%125 = zext i1 %124 to i64
%126 = add nuw nsw i64 %119, %125
%127 = select i1 %124, double -3.276700e+04, double %123
%128 = fcmp ogt double %127, 3.276700e+04
%129 = zext i1 %128 to i64
%130 = add nuw nsw i64 %120, %129
%131 = select i1 %128, double 3.276700e+04, double %127
%132 = fcmp ogt double %131, 0.000000e+00
%133 = select i1 %132, double 5.000000e-01, double -5.000000e-01
%134 = fadd double %131, %133
%135 = fptosi double %134 to i16
store i16 %135, i16* %118
%136 = add nuw nsw i64 %117, 1
%137 = getelementptr inbounds i16, i16* %118, i64 1
%138 = icmp eq i64 %136, %1
br i1 %138, label %139, label %116
139: ; preds = %116, %105
%140 = phi i64 [ %109, %105 ], [ %126, %116 ]
%141 = phi i64 [ %107, %105 ], [ %130, %116 ]
%142 = icmp eq i64 %140, 0
br i1 %142, label %145, label %143
143: ; preds = %139
%144 = tail call i32 @HError(i32 -5322, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i64 %140)
br label %145
145: ; preds = %143, %139
%146 = icmp eq i64 %141, 0
br i1 %146, label %149, label %147
147: ; preds = %145
%148 = tail call i32 @HError(i32 -5322, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.1, i64 0, i64 0), i64 %141)
br label %149
149: ; preds = %47, %2, %147, %145
ret void
}