#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 */
short abs(short);
void normalize_short(short *buffer, size_t size) {
  short min, max;
  size_t i;
  min = buffer[0];
  max = buffer[0];
  for (i = 0L; i < size; i++) {
    if (buffer[i] < min)
      min = buffer[i];
    if (buffer[i] > max)
      max = buffer[i];
  }
  min = abs(min);
  max = abs(max);
  if (max < min)
    max = min;
  for (i = 0L; i < size; i++) {
    buffer[i] = (short)(((double)buffer[i] / (double)max) * (double)32767);
  }
}


x86 assembly (clang, -O0):
<normalize_short>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x12(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11b2 <normalize_short+0xa2>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jge    1174 <normalize_short+0x64>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x12(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    119c <normalize_short+0x8c>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,2),%ax
mov    %ax,-0x14(%rbp)
jmp    11a1 <normalize_short+0x91>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    113e <normalize_short+0x2e>
movswl -0x12(%rbp),%edi
call   1030 <abs@plt>
mov    %ax,-0x12(%rbp)
movswl -0x14(%rbp),%edi
call   1030 <abs@plt>
mov    %ax,-0x14(%rbp)
movswl -0x14(%rbp),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jge    11e4 <normalize_short+0xd4>
mov    -0x12(%rbp),%ax
mov    %ax,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1246 <normalize_short+0x136>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cvtsi2sd %eax,%xmm0
movswl -0x14(%rbp),%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  0xde2(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    11ec <normalize_short+0xdc>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<normalize_short>:
test   %rsi,%rsi
je     14b4 <normalize_short+0x3b4>
movzwl (%rdi),%r10d
mov    %r10d,%edx
mov    %r10d,%eax
cmp    $0x1,%rsi
je     125a <normalize_short+0x15a>
lea    -0x1(%rsi),%r8
mov    $0x1,%r11d
mov    %r10d,%eax
mov    %r10d,%edx
cmp    $0x10,%r8
jb     1240 <normalize_short+0x140>
mov    %r8,%r11
and    $0xfffffffffffffff0,%r11
movd   %r10d,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x10(%r11),%rax
mov    %rax,%r9
shr    $0x4,%r9
add    $0x1,%r9
test   %rax,%rax
je     14b5 <normalize_short+0x3b5>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
mov    $0x1,%edx
movdqa %xmm0,%xmm2
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
nopl   (%rax)
movdqu (%rdi,%rdx,2),%xmm4
movdqu 0x10(%rdi,%rdx,2),%xmm5
movdqu 0x20(%rdi,%rdx,2),%xmm6
movdqu 0x30(%rdi,%rdx,2),%xmm7
pminsw %xmm4,%xmm1
pminsw %xmm5,%xmm3
pmaxsw %xmm4,%xmm0
pmaxsw %xmm5,%xmm2
pminsw %xmm6,%xmm1
pminsw %xmm7,%xmm3
pmaxsw %xmm6,%xmm0
pmaxsw %xmm7,%xmm2
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rax
jne    1180 <normalize_short+0x80>
test   $0x1,%r9b
je     11e2 <normalize_short+0xe2>
movdqu (%rdi,%rdx,2),%xmm4
movdqu 0x10(%rdi,%rdx,2),%xmm5
pminsw %xmm4,%xmm1
pminsw %xmm5,%xmm3
pmaxsw %xmm4,%xmm0
pmaxsw %xmm5,%xmm2
pmaxsw %xmm2,%xmm0
pminsw %xmm3,%xmm1
pshufd $0xee,%xmm1,%xmm2
pminsw %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
pminsw %xmm2,%xmm1
movdqa %xmm1,%xmm2
psrld  $0x10,%xmm2
pminsw %xmm1,%xmm2
movd   %xmm2,%edx
pshufd $0xee,%xmm0,%xmm1
pmaxsw %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxsw %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxsw %xmm0,%xmm1
movd   %xmm1,%eax
cmp    %r11,%r8
je     125a <normalize_short+0x15a>
or     $0x1,%r11
nopl   0x0(%rax)
movzwl (%rdi,%r11,2),%ecx
cmp    %dx,%cx
cmovl  %ecx,%edx
cmp    %ax,%cx
cmovg  %ecx,%eax
add    $0x1,%r11
cmp    %r11,%rsi
jne    1240 <normalize_short+0x140>
mov    %edx,%ecx
neg    %cx
cmovs  %dx,%cx
mov    %eax,%edx
neg    %dx
cmovs  %ax,%dx
test   %rsi,%rsi
je     14b4 <normalize_short+0x3b4>
cmp    %cx,%dx
cmovb  %ecx,%edx
movswl %dx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movswl %r10w,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
divsd  %xmm0,%xmm1
mulsd  0xd64(%rip),%xmm1
cvttsd2si %xmm1,%eax
mov    %ax,(%rdi)
cmp    $0x1,%rsi
je     14b4 <normalize_short+0x3b4>
lea    -0x1(%rsi),%r8
mov    $0x1,%eax
cmp    $0x8,%r8
jb     147d <normalize_short+0x37d>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     14d5 <normalize_short+0x3d5>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x1,%edx
movapd 0xd15(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rdx,2),%xmm4
punpcklwd %xmm4,%xmm3
psrad  $0x10,%xmm3
pshufd $0xee,%xmm3,%xmm5
cvtdq2pd %xmm5,%xmm5
cvtdq2pd %xmm3,%xmm6
movdqu 0x10(%rdi,%rdx,2),%xmm3
punpckhwd %xmm4,%xmm4
psrad  $0x10,%xmm4
pshufd $0xee,%xmm4,%xmm7
cvtdq2pd %xmm7,%xmm7
cvtdq2pd %xmm4,%xmm4
divpd  %xmm1,%xmm4
divpd  %xmm1,%xmm7
divpd  %xmm1,%xmm6
divpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm6
mulpd  %xmm2,%xmm7
mulpd  %xmm2,%xmm4
cvttpd2dq %xmm4,%xmm4
cvttpd2dq %xmm7,%xmm7
cvttpd2dq %xmm6,%xmm6
cvttpd2dq %xmm5,%xmm5
unpcklpd %xmm7,%xmm4
unpcklpd %xmm5,%xmm6
packssdw %xmm4,%xmm6
punpcklwd %xmm3,%xmm4
psrad  $0x10,%xmm4
pshufd $0xee,%xmm4,%xmm5
cvtdq2pd %xmm5,%xmm5
movdqu %xmm6,(%rdi,%rdx,2)
cvtdq2pd %xmm4,%xmm4
punpckhwd %xmm3,%xmm3
psrad  $0x10,%xmm3
pshufd $0xee,%xmm3,%xmm6
cvtdq2pd %xmm6,%xmm6
cvtdq2pd %xmm3,%xmm3
divpd  %xmm1,%xmm3
divpd  %xmm1,%xmm6
divpd  %xmm1,%xmm4
divpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm5
mulpd  %xmm2,%xmm4
mulpd  %xmm2,%xmm6
mulpd  %xmm2,%xmm3
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm6,%xmm6
cvttpd2dq %xmm4,%xmm4
unpcklpd %xmm6,%xmm3
cvttpd2dq %xmm5,%xmm5
unpcklpd %xmm5,%xmm4
packssdw %xmm3,%xmm4
movdqu %xmm4,0x10(%rdi,%rdx,2)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1300 <normalize_short+0x200>
test   $0x1,%r9b
je     1474 <normalize_short+0x374>
movdqu (%rdi,%rdx,2),%xmm2
punpcklwd %xmm2,%xmm3
psrad  $0x10,%xmm3
pshufd $0xee,%xmm3,%xmm4
cvtdq2pd %xmm4,%xmm4
cvtdq2pd %xmm3,%xmm3
punpckhwd %xmm2,%xmm2
psrad  $0x10,%xmm2
pshufd $0xee,%xmm2,%xmm5
cvtdq2pd %xmm5,%xmm5
cvtdq2pd %xmm2,%xmm2
divpd  %xmm1,%xmm2
divpd  %xmm1,%xmm5
divpd  %xmm1,%xmm3
divpd  %xmm1,%xmm4
movapd 0xbcd(%rip),%xmm1
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm2
cvttpd2dq %xmm2,%xmm1
cvttpd2dq %xmm5,%xmm2
cvttpd2dq %xmm3,%xmm3
cvttpd2dq %xmm4,%xmm4
unpcklpd %xmm2,%xmm1
unpcklpd %xmm4,%xmm3
packssdw %xmm1,%xmm3
movdqu %xmm3,(%rdi,%rdx,2)
cmp    %rax,%r8
je     14b4 <normalize_short+0x3b4>
or     $0x1,%rax
movsd  0xb7b(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movswl (%rdi,%rax,2),%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
cvttsd2si %xmm2,%ecx
mov    %cx,(%rdi,%rax,2)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1490 <normalize_short+0x390>
ret
mov    $0x1,%edx
movdqa %xmm0,%xmm2
movdqa %xmm0,%xmm1
movdqa %xmm0,%xmm3
test   $0x1,%r9b
jne    11c7 <normalize_short+0xc7>
jmp    11e2 <normalize_short+0xe2>
mov    $0x1,%edx
test   $0x1,%r9b
jne    13fa <normalize_short+0x2fa>
jmp    1474 <normalize_short+0x374>

LLVM IR (-O0):
define void @normalize_short(i16* %0, i64 %1) {
%3 = alloca i16*
%4 = alloca i64
%5 = alloca i16
%6 = alloca i16
%7 = alloca i64
store i16* %0, i16** %3
store i64 %1, i64* %4
%8 = load i16*, i16** %3
%9 = getelementptr inbounds i16, i16* %8, i64 0
%10 = load i16, i16* %9
store i16 %10, i16* %5
%11 = load i16*, i16** %3
%12 = getelementptr inbounds i16, i16* %11, i64 0
%13 = load i16, i16* %12
store i16 %13, i16* %6
store i64 0, i64* %7
br label %14
14: ; preds = %47, %2
%15 = load i64, i64* %7
%16 = load i64, i64* %4
%17 = icmp ult i64 %15, %16
br i1 %17, label %18, label %50
18: ; preds = %14
%19 = load i16*, i16** %3
%20 = load i64, i64* %7
%21 = getelementptr inbounds i16, i16* %19, i64 %20
%22 = load i16, i16* %21
%23 = sext i16 %22 to i32
%24 = load i16, i16* %5
%25 = sext i16 %24 to i32
%26 = icmp slt i32 %23, %25
br i1 %26, label %27, label %32
27: ; preds = %18
%28 = load i16*, i16** %3
%29 = load i64, i64* %7
%30 = getelementptr inbounds i16, i16* %28, i64 %29
%31 = load i16, i16* %30
store i16 %31, i16* %5
br label %32
32: ; preds = %27, %18
%33 = load i16*, i16** %3
%34 = load i64, i64* %7
%35 = getelementptr inbounds i16, i16* %33, i64 %34
%36 = load i16, i16* %35
%37 = sext i16 %36 to i32
%38 = load i16, i16* %6
%39 = sext i16 %38 to i32
%40 = icmp sgt i32 %37, %39
br i1 %40, label %41, label %46
41: ; preds = %32
%42 = load i16*, i16** %3
%43 = load i64, i64* %7
%44 = getelementptr inbounds i16, i16* %42, i64 %43
%45 = load i16, i16* %44
store i16 %45, i16* %6
br label %46
46: ; preds = %41, %32
br label %47
47: ; preds = %46
%48 = load i64, i64* %7
%49 = add i64 %48, 1
store i64 %49, i64* %7
br label %14
50: ; preds = %14
%51 = load i16, i16* %5
%52 = call signext i16 @abs(i16 signext %51)
store i16 %52, i16* %5
%53 = load i16, i16* %6
%54 = call signext i16 @abs(i16 signext %53)
store i16 %54, i16* %6
%55 = load i16, i16* %6
%56 = sext i16 %55 to i32
%57 = load i16, i16* %5
%58 = sext i16 %57 to i32
%59 = icmp slt i32 %56, %58
br i1 %59, label %60, label %62
60: ; preds = %50
%61 = load i16, i16* %5
store i16 %61, i16* %6
br label %62
62: ; preds = %60, %50
store i64 0, i64* %7
br label %63
63: ; preds = %81, %62
%64 = load i64, i64* %7
%65 = load i64, i64* %4
%66 = icmp ult i64 %64, %65
br i1 %66, label %67, label %84
67: ; preds = %63
%68 = load i16*, i16** %3
%69 = load i64, i64* %7
%70 = getelementptr inbounds i16, i16* %68, i64 %69
%71 = load i16, i16* %70
%72 = sitofp i16 %71 to double
%73 = load i16, i16* %6
%74 = sitofp i16 %73 to double
%75 = fdiv double %72, %74
%76 = fmul double %75, 3.276700e+04
%77 = fptosi double %76 to i16
%78 = load i16*, i16** %3
%79 = load i64, i64* %7
%80 = getelementptr inbounds i16, i16* %78, i64 %79
store i16 %77, i16* %80
br label %81
81: ; preds = %67
%82 = load i64, i64* %7
%83 = add i64 %82, 1
store i64 %83, i64* %7
br label %63
84: ; preds = %63
ret void
}

LLVM IR (-O2):
define void @normalize_short(i16* nocapture %0, i64 %1) {
%3 = load i16, i16* %0
%4 = icmp eq i64 %1, 0
br i1 %4, label %202, label %5
5: ; preds = %2
%6 = icmp eq i64 %1, 1
br i1 %6, label %120, label %7
7: ; preds = %5
%8 = add i64 %1, -1
%9 = icmp ult i64 %8, 16
br i1 %9, label %104, label %10
10: ; preds = %7
%11 = and i64 %8, -16
%12 = or i64 %11, 1
%13 = insertelement <8 x i16> poison, i16 %3, i64 0
%14 = shufflevector <8 x i16> %13, <8 x i16> poison, <8 x i32> zeroinitializer
%15 = insertelement <8 x i16> poison, i16 %3, i64 0
%16 = shufflevector <8 x i16> %15, <8 x i16> poison, <8 x i32> zeroinitializer
%17 = add i64 %11, -16
%18 = lshr exact i64 %17, 4
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 1
%21 = icmp eq i64 %17, 0
br i1 %21, label %66, label %22
22: ; preds = %10
%23 = and i64 %19, 2305843009213693950
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %61, %24 ]
%26 = phi <8 x i16> [ %14, %22 ], [ %59, %24 ]
%27 = phi <8 x i16> [ %14, %22 ], [ %60, %24 ]
%28 = phi <8 x i16> [ %16, %22 ], [ %55, %24 ]
%29 = phi <8 x i16> [ %16, %22 ], [ %56, %24 ]
%30 = phi i64 [ 0, %22 ], [ %62, %24 ]
%31 = or i64 %25, 1
%32 = getelementptr inbounds i16, i16* %0, i64 %31
%33 = bitcast i16* %32 to <8 x i16>*
%34 = load <8 x i16>, <8 x i16>* %33
%35 = getelementptr inbounds i16, i16* %32, i64 8
%36 = bitcast i16* %35 to <8 x i16>*
%37 = load <8 x i16>, <8 x i16>* %36
%38 = icmp slt <8 x i16> %34, %28
%39 = icmp slt <8 x i16> %37, %29
%40 = select <8 x i1> %38, <8 x i16> %34, <8 x i16> %28
%41 = select <8 x i1> %39, <8 x i16> %37, <8 x i16> %29
%42 = icmp sgt <8 x i16> %34, %26
%43 = icmp sgt <8 x i16> %37, %27
%44 = select <8 x i1> %42, <8 x i16> %34, <8 x i16> %26
%45 = select <8 x i1> %43, <8 x i16> %37, <8 x i16> %27
%46 = or i64 %25, 17
%47 = getelementptr inbounds i16, i16* %0, i64 %46
%48 = bitcast i16* %47 to <8 x i16>*
%49 = load <8 x i16>, <8 x i16>* %48
%50 = getelementptr inbounds i16, i16* %47, i64 8
%51 = bitcast i16* %50 to <8 x i16>*
%52 = load <8 x i16>, <8 x i16>* %51
%53 = icmp slt <8 x i16> %49, %40
%54 = icmp slt <8 x i16> %52, %41
%55 = select <8 x i1> %53, <8 x i16> %49, <8 x i16> %40
%56 = select <8 x i1> %54, <8 x i16> %52, <8 x i16> %41
%57 = icmp sgt <8 x i16> %49, %44
%58 = icmp sgt <8 x i16> %52, %45
%59 = select <8 x i1> %57, <8 x i16> %49, <8 x i16> %44
%60 = select <8 x i1> %58, <8 x i16> %52, <8 x i16> %45
%61 = add nuw i64 %25, 32
%62 = add i64 %30, 2
%63 = icmp eq i64 %62, %23
br i1 %63, label %64, label %24
64: ; preds = %24
%65 = or i64 %61, 1
br label %66
66: ; preds = %64, %10
%67 = phi <8 x i16> [ undef, %10 ], [ %55, %64 ]
%68 = phi <8 x i16> [ undef, %10 ], [ %56, %64 ]
%69 = phi <8 x i16> [ undef, %10 ], [ %59, %64 ]
%70 = phi <8 x i16> [ undef, %10 ], [ %60, %64 ]
%71 = phi i64 [ 1, %10 ], [ %65, %64 ]
%72 = phi <8 x i16> [ %14, %10 ], [ %59, %64 ]
%73 = phi <8 x i16> [ %14, %10 ], [ %60, %64 ]
%74 = phi <8 x i16> [ %16, %10 ], [ %55, %64 ]
%75 = phi <8 x i16> [ %16, %10 ], [ %56, %64 ]
%76 = icmp eq i64 %20, 0
br i1 %76, label %92, label %77
77: ; preds = %66
%78 = getelementptr inbounds i16, i16* %0, i64 %71
%79 = bitcast i16* %78 to <8 x i16>*
%80 = load <8 x i16>, <8 x i16>* %79
%81 = getelementptr inbounds i16, i16* %78, i64 8
%82 = bitcast i16* %81 to <8 x i16>*
%83 = load <8 x i16>, <8 x i16>* %82
%84 = icmp slt <8 x i16> %80, %74
%85 = icmp slt <8 x i16> %83, %75
%86 = select <8 x i1> %84, <8 x i16> %80, <8 x i16> %74
%87 = select <8 x i1> %85, <8 x i16> %83, <8 x i16> %75
%88 = icmp sgt <8 x i16> %80, %72
%89 = icmp sgt <8 x i16> %83, %73
%90 = select <8 x i1> %88, <8 x i16> %80, <8 x i16> %72
%91 = select <8 x i1> %89, <8 x i16> %83, <8 x i16> %73
br label %92
92: ; preds = %66, %77
%93 = phi <8 x i16> [ %67, %66 ], [ %86, %77 ]
%94 = phi <8 x i16> [ %68, %66 ], [ %87, %77 ]
%95 = phi <8 x i16> [ %69, %66 ], [ %90, %77 ]
%96 = phi <8 x i16> [ %70, %66 ], [ %91, %77 ]
%97 = icmp slt <8 x i16> %93, %94
%98 = select <8 x i1> %97, <8 x i16> %93, <8 x i16> %94
%99 = call i16 @llvm.vector.reduce.smin.v8i16(<8 x i16> %98)
%100 = icmp sgt <8 x i16> %95, %96
%101 = select <8 x i1> %100, <8 x i16> %95, <8 x i16> %96
%102 = call i16 @llvm.vector.reduce.smax.v8i16(<8 x i16> %101)
%103 = icmp eq i64 %8, %11
br i1 %103, label %120, label %104
104: ; preds = %7, %92
%105 = phi i64 [ 1, %7 ], [ %12, %92 ]
%106 = phi i16 [ %3, %7 ], [ %102, %92 ]
%107 = phi i16 [ %3, %7 ], [ %99, %92 ]
br label %108
108: ; preds = %104, %108
%109 = phi i64 [ %118, %108 ], [ %105, %104 ]
%110 = phi i16 [ %117, %108 ], [ %106, %104 ]
%111 = phi i16 [ %115, %108 ], [ %107, %104 ]
%112 = getelementptr inbounds i16, i16* %0, i64 %109
%113 = load i16, i16* %112
%114 = icmp slt i16 %113, %111
%115 = select i1 %114, i16 %113, i16 %111
%116 = icmp sgt i16 %113, %110
%117 = select i1 %116, i16 %113, i16 %110
%118 = add nuw i64 %109, 1
%119 = icmp eq i64 %118, %1
br i1 %119, label %120, label %108
120: ; preds = %108, %92, %5
%121 = phi i16 [ %3, %5 ], [ %99, %92 ], [ %115, %108 ]
%122 = phi i16 [ %3, %5 ], [ %102, %92 ], [ %117, %108 ]
%123 = tail call i16 @llvm.abs.i16(i16 %121, i1 true)
%124 = tail call i16 @llvm.abs.i16(i16 %122, i1 true)
br i1 %4, label %202, label %125
125: ; preds = %120
%126 = icmp ult i16 %124, %123
%127 = select i1 %126, i16 %123, i16 %124
%128 = sitofp i16 %127 to double
%129 = sitofp i16 %3 to double
%130 = fdiv double %129, %128
%131 = fmul double %130, 3.276700e+04
%132 = fptosi double %131 to i16
store i16 %132, i16* %0
%133 = icmp eq i64 %1, 1
br i1 %133, label %202, label %134
134: ; preds = %125
%135 = add i64 %1, -1
%136 = icmp ult i64 %135, 8
br i1 %136, label %189, label %137
137: ; preds = %134
%138 = and i64 %135, -8
%139 = or i64 %138, 1
%140 = insertelement <8 x double> poison, double %128, i64 0
%141 = shufflevector <8 x double> %140, <8 x double> poison, <8 x i32> zeroinitializer
%142 = add i64 %138, -8
%143 = lshr exact i64 %142, 3
%144 = add nuw nsw i64 %143, 1
%145 = and i64 %144, 1
%146 = icmp eq i64 %142, 0
br i1 %146, label %175, label %147
147: ; preds = %137
%148 = and i64 %144, 4611686018427387902
br label %149
149: ; preds = %149, %147
%150 = phi i64 [ 0, %147 ], [ %170, %149 ]
%151 = phi i64 [ 0, %147 ], [ %171, %149 ]
%152 = or i64 %150, 1
%153 = getelementptr inbounds i16, i16* %0, i64 %152
%154 = bitcast i16* %153 to <8 x i16>*
%155 = load <8 x i16>, <8 x i16>* %154
%156 = sitofp <8 x i16> %155 to <8 x double>
%157 = fdiv <8 x double> %156, %141
%158 = fmul <8 x double> %157, <double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04>
%159 = fptosi <8 x double> %158 to <8 x i16>
%160 = bitcast i16* %153 to <8 x i16>*
store <8 x i16> %159, <8 x i16>* %160
%161 = or i64 %150, 9
%162 = getelementptr inbounds i16, i16* %0, i64 %161
%163 = bitcast i16* %162 to <8 x i16>*
%164 = load <8 x i16>, <8 x i16>* %163
%165 = sitofp <8 x i16> %164 to <8 x double>
%166 = fdiv <8 x double> %165, %141
%167 = fmul <8 x double> %166, <double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04>
%168 = fptosi <8 x double> %167 to <8 x i16>
%169 = bitcast i16* %162 to <8 x i16>*
store <8 x i16> %168, <8 x i16>* %169
%170 = add nuw i64 %150, 16
%171 = add i64 %151, 2
%172 = icmp eq i64 %171, %148
br i1 %172, label %173, label %149
173: ; preds = %149
%174 = or i64 %170, 1
br label %175
175: ; preds = %173, %137
%176 = phi i64 [ 1, %137 ], [ %174, %173 ]
%177 = icmp eq i64 %145, 0
br i1 %177, label %187, label %178
178: ; preds = %175
%179 = getelementptr inbounds i16, i16* %0, i64 %176
%180 = bitcast i16* %179 to <8 x i16>*
%181 = load <8 x i16>, <8 x i16>* %180
%182 = sitofp <8 x i16> %181 to <8 x double>
%183 = fdiv <8 x double> %182, %141
%184 = fmul <8 x double> %183, <double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04, double 3.276700e+04>
%185 = fptosi <8 x double> %184 to <8 x i16>
%186 = bitcast i16* %179 to <8 x i16>*
store <8 x i16> %185, <8 x i16>* %186
br label %187
187: ; preds = %175, %178
%188 = icmp eq i64 %135, %138
br i1 %188, label %202, label %189
189: ; preds = %134, %187
%190 = phi i64 [ 1, %134 ], [ %139, %187 ]
br label %191
191: ; preds = %189, %191
%192 = phi i64 [ %200, %191 ], [ %190, %189 ]
%193 = getelementptr inbounds i16, i16* %0, i64 %192
%194 = load i16, i16* %193
%195 = getelementptr inbounds i16, i16* %0, i64 %192
%196 = sitofp i16 %194 to double
%197 = fdiv double %196, %128
%198 = fmul double %197, 3.276700e+04
%199 = fptosi double %198 to i16
store i16 %199, i16* %195
%200 = add nuw i64 %192, 1
%201 = icmp eq i64 %200, %1
br i1 %201, label %202, label %191
202: ; preds = %191, %125, %187, %2, %120
ret void
}