void mp_unsgn_imul(int n, double dradix, int in1[], double din2, int out[]) {
  int j, carry, shift;
  double x, d1_radix;
  d1_radix = ((double)1) / dradix;
  carry = 0;
  for (j = n; j >= 1; j--) {
    x = din2 * in1[j] + carry + ((double)0.5);
    carry = (int)(d1_radix * x);
    out[j] = (int)(x - dradix * carry);
  }
  shift = 0;
  x = carry + ((double)0.5);
  while (x > 1) {
    x *= d1_radix;
    shift++;
  }
  out[0] = in1[0] + shift;
  if (shift > 0) {
    while (shift > n) {
      carry = (int)(d1_radix * carry + ((double)0.5));
      shift--;
    }
    for (j = n; j >= shift + 1; j--) {
      out[j] = out[j - shift];
    }
    for (j = shift; j >= 1; j--) {
      x = carry + ((double)0.5);
      carry = (int)(d1_radix * x);
      out[j] = (int)(x - dradix * carry);
    }
  }
}


x86 assembly (clang, -O0):
<mp_unsgn_imul>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
movsd  0xedf(%rip),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     11ce <mp_unsgn_imul+0xce>
movsd  -0x20(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm2
cvtsi2sdl -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xe9f(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x40(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
cvtsi2sdl -0x30(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1138 <mp_unsgn_imul+0x38>
movl   $0x0,-0x34(%rbp)
cvtsi2sdl -0x30(%rbp),%xmm0
movsd  0xe26(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm0
movsd  0xe08(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    121f <mp_unsgn_imul+0x11f>
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11eb <mp_unsgn_imul+0xeb>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    -0x34(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
cmpl   $0x0,-0x34(%rbp)
jle    133f <mp_unsgn_imul+0x23f>
jmp    123d <mp_unsgn_imul+0x13d>
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1278 <mp_unsgn_imul+0x178>
movsd  -0x48(%rbp),%xmm0
cvtsi2sdl -0x30(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xda9(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    123d <mp_unsgn_imul+0x13d>
mov    -0x4(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     12b8 <mp_unsgn_imul+0x1b8>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    127e <mp_unsgn_imul+0x17e>
mov    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     133a <mp_unsgn_imul+0x23a>
cvtsi2sdl -0x30(%rbp),%xmm0
movsd  0xd33(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x40(%rbp),%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
movsd  -0x40(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm0
cvtsi2sdl -0x30(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    12be <mp_unsgn_imul+0x1be>
jmp    133f <mp_unsgn_imul+0x23f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mp_unsgn_imul>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r8
movsd  0xeeb(%rip),%xmm3
movapd %xmm3,%xmm2
divsd  %xmm0,%xmm2
test   %edi,%edi
jle    118f <mp_unsgn_imul+0x8f>
movapd 0xee7(%rip),%xmm4
xorpd  %xmm0,%xmm4
mov    %edi,%eax
add    $0x1,%rax
xor    %r9d,%r9d
movsd  0xeca(%rip),%xmm5
xchg   %ax,%ax
xorps  %xmm6,%xmm6
cvtsi2sdl -0x4(%rsi,%rax,4),%xmm6
xorps  %xmm7,%xmm7
cvtsi2sd %r9d,%xmm7
mulsd  %xmm1,%xmm6
addsd  %xmm7,%xmm6
addsd  %xmm5,%xmm6
movapd %xmm2,%xmm7
mulsd  %xmm6,%xmm7
cvttsd2si %xmm7,%r9d
cvttpd2dq %xmm7,%xmm7
cvtdq2pd %xmm7,%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm6,%xmm7
cvttsd2si %xmm7,%ecx
mov    %ecx,-0x4(%r8,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1140 <mp_unsgn_imul+0x40>
jmp    1192 <mp_unsgn_imul+0x92>
xor    %r9d,%r9d
xorps  %xmm1,%xmm1
cvtsi2sd %r9d,%xmm1
addsd  0xe66(%rip),%xmm1
ucomisd 0xe56(%rip),%xmm1
jbe    1239 <mp_unsgn_imul+0x139>
xor    %ebx,%ebx
xor    %ecx,%ecx
xor    %r14d,%r14d
nopw   0x0(%rax,%rax,1)
mulsd  %xmm2,%xmm1
add    $0xffffffffffffffff,%r14
add    $0x4,%rcx
add    $0x1,%rbx
ucomisd %xmm3,%xmm1
ja     11c0 <mp_unsgn_imul+0xc0>
mov    (%rsi),%eax
sub    %r14d,%eax
mov    %eax,(%r8)
mov    %r14d,%eax
not    %eax
mov    %r14,%rsi
neg    %rsi
cmp    %edi,%eax
jge    1243 <mp_unsgn_imul+0x143>
cmp    %edi,%esi
jge    1235 <mp_unsgn_imul+0x135>
movslq %edi,%rdi
lea    -0x1(%rdi),%r15
cmp    %rsi,%r15
mov    %rsi,%rax
cmovl  %r15,%rax
mov    %rdi,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jae    12d7 <mp_unsgn_imul+0x1d7>
add    %rdi,%r14
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r8,%r14,4),%eax
mov    %eax,(%r8,%rdi,4)
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%r14
cmp    %rsi,%rdi
jg     1220 <mp_unsgn_imul+0x120>
mov    %esi,%edi
jmp    1270 <mp_unsgn_imul+0x170>
mov    (%rsi),%eax
mov    %eax,(%r8)
jmp    12cc <mp_unsgn_imul+0x1cc>
movsd  0xdbd(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2sd %r9d,%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
cvttsd2si %xmm3,%r9d
add    $0xffffffff,%esi
cmp    %edi,%esi
jg     1250 <mp_unsgn_imul+0x150>
test   %edi,%edi
jle    12cc <mp_unsgn_imul+0x1cc>
xorpd  0xd98(%rip),%xmm0
mov    %edi,%eax
add    $0x1,%rax
movsd  0xd82(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm3,%xmm3
cvtsi2sd %r9d,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm3,%xmm4
cvttsd2si %xmm4,%r9d
cvttpd2dq %xmm4,%xmm4
cvtdq2pd %xmm4,%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
cvttsd2si %xmm4,%ecx
mov    %ecx,-0x4(%r8,%rax,4)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1290 <mp_unsgn_imul+0x190>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %rsi,%r15
mov    %rsi,%rax
cmovl  %r15,%rax
not    %rax
add    %rdi,%rax
lea    (%r8,%rdi,4),%r11
mov    $0x4,%edx
mul    %rdx
seto   %r12b
mov    %r11,%rbp
sub    %rax,%rbp
cmp    %r15,%rbx
mov    %r15,%rdx
cmovl  %rbx,%rdx
cmp    %r11,%rbp
ja     1212 <mp_unsgn_imul+0x112>
test   %r12b,%r12b
jne    1212 <mp_unsgn_imul+0x112>
mov    %r11,%rax
sub    %rcx,%rax
lea    (%r8,%rdx,4),%rdx
sub    %rcx,%rdx
add    $0x4,%rdx
cmp    %rax,%rdx
ja     1212 <mp_unsgn_imul+0x112>
test   %r12b,%r12b
jne    1212 <mp_unsgn_imul+0x112>
cmp    %rsi,%r15
mov    %rsi,%rcx
cmovl  %r15,%rcx
lea    (%r8,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %r15,%rbx
cmovge %r15,%rbx
add    $0x4,%rax
cmp    %rax,%rcx
jae    137a <mp_unsgn_imul+0x27a>
lea    (%r8,%rdi,4),%rax
add    $0x4,%rax
add    %r14,%rbx
lea    (%r8,%rbx,4),%rcx
add    $0x4,%rcx
cmp    %rax,%rcx
jb     1212 <mp_unsgn_imul+0x112>
mov    %r10,%r12
and    $0xfffffffffffffff8,%r12
lea    -0x8(%r12),%rax
mov    %rax,%r13
shr    $0x3,%r13
add    $0x1,%r13
test   %rax,%rax
je     140d <mp_unsgn_imul+0x30d>
cmp    %r15,%rsi
cmovl  %rsi,%r15
lea    (%r8,%rdi,4),%rbx
add    $0xfffffffffffffff4,%rbx
mov    %rdi,%rax
sub    %r15,%rax
and    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffff8,%rax
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %edx,%edx
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rbx,%rcx,4),%xmm1
movups (%rbx,%rcx,4),%xmm3
movups %xmm3,(%rbx,%rdx,4)
movups %xmm1,-0x10(%rbx,%rdx,4)
movupd -0x30(%rbx,%rcx,4),%xmm1
movupd -0x20(%rbx,%rcx,4),%xmm3
movupd %xmm3,-0x20(%rbx,%rdx,4)
movupd %xmm1,-0x30(%rbx,%rdx,4)
add    $0xfffffffffffffff0,%rdx
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rax
jne    13d0 <mp_unsgn_imul+0x2d0>
neg    %rdx
jmp    140f <mp_unsgn_imul+0x30f>
xor    %edx,%edx
test   $0x1,%r13b
je     143e <mp_unsgn_imul+0x33e>
mov    %rdi,%rax
sub    %rdx,%rax
shl    $0x2,%rdx
sub    %rdx,%r11
movupd -0x1c(%r11,%r14,4),%xmm1
movupd -0xc(%r11,%r14,4),%xmm3
movupd %xmm3,-0xc(%r8,%rax,4)
movupd %xmm1,-0x1c(%r8,%rax,4)
cmp    %r12,%r10
je     1235 <mp_unsgn_imul+0x135>
sub    %r12,%rdi
jmp    1212 <mp_unsgn_imul+0x112>

LLVM IR (-O0):
define void @mp_unsgn_imul(i32 %0, double %1, i32* %2, double %3, i32* %4) {
%6 = alloca i32
%7 = alloca double
%8 = alloca i32*
%9 = alloca double
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca double
%15 = alloca double
store i32 %0, i32* %6
store double %1, double* %7
store i32* %2, i32** %8
store double %3, double* %9
store i32* %4, i32** %10
%16 = load double, double* %7
%17 = fdiv double 1.000000e+00, %16
store double %17, double* %15
store i32 0, i32* %12
%18 = load i32, i32* %6
store i32 %18, i32* %11
br label %19
19: ; preds = %49, %5
%20 = load i32, i32* %11
%21 = icmp sge i32 %20, 1
br i1 %21, label %22, label %52
22: ; preds = %19
%23 = load double, double* %9
%24 = load i32*, i32** %8
%25 = load i32, i32* %11
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds i32, i32* %24, i64 %26
%28 = load i32, i32* %27
%29 = sitofp i32 %28 to double
%30 = load i32, i32* %12
%31 = sitofp i32 %30 to double
%32 = call double @llvm.fmuladd.f64(double %23, double %29, double %31)
%33 = fadd double %32, 5.000000e-01
store double %33, double* %14
%34 = load double, double* %15
%35 = load double, double* %14
%36 = fmul double %34, %35
%37 = fptosi double %36 to i32
store i32 %37, i32* %12
%38 = load double, double* %14
%39 = load double, double* %7
%40 = load i32, i32* %12
%41 = sitofp i32 %40 to double
%42 = fneg double %39
%43 = call double @llvm.fmuladd.f64(double %42, double %41, double %38)
%44 = fptosi double %43 to i32
%45 = load i32*, i32** %10
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
store i32 %44, i32* %48
br label %49
49: ; preds = %22
%50 = load i32, i32* %11
%51 = add nsw i32 %50, -1
store i32 %51, i32* %11
br label %19
52: ; preds = %19
store i32 0, i32* %13
%53 = load i32, i32* %12
%54 = sitofp i32 %53 to double
%55 = fadd double %54, 5.000000e-01
store double %55, double* %14
br label %56
56: ; preds = %59, %52
%57 = load double, double* %14
%58 = fcmp ogt double %57, 1.000000e+00
br i1 %58, label %59, label %65
59: ; preds = %56
%60 = load double, double* %15
%61 = load double, double* %14
%62 = fmul double %61, %60
store double %62, double* %14
%63 = load i32, i32* %13
%64 = add nsw i32 %63, 1
store i32 %64, i32* %13
br label %56
65: ; preds = %56
%66 = load i32*, i32** %8
%67 = getelementptr inbounds i32, i32* %66, i64 0
%68 = load i32, i32* %67
%69 = load i32, i32* %13
%70 = add nsw i32 %68, %69
%71 = load i32*, i32** %10
%72 = getelementptr inbounds i32, i32* %71, i64 0
store i32 %70, i32* %72
%73 = load i32, i32* %13
%74 = icmp sgt i32 %73, 0
br i1 %74, label %75, label %138
75: ; preds = %65
br label %76
76: ; preds = %80, %75
%77 = load i32, i32* %13
%78 = load i32, i32* %6
%79 = icmp sgt i32 %77, %78
br i1 %79, label %80, label %88
80: ; preds = %76
%81 = load double, double* %15
%82 = load i32, i32* %12
%83 = sitofp i32 %82 to double
%84 = call double @llvm.fmuladd.f64(double %81, double %83, double 5.000000e-01)
%85 = fptosi double %84 to i32
store i32 %85, i32* %12
%86 = load i32, i32* %13
%87 = add nsw i32 %86, -1
store i32 %87, i32* %13
br label %76
88: ; preds = %76
%89 = load i32, i32* %6
store i32 %89, i32* %11
br label %90
90: ; preds = %107, %88
%91 = load i32, i32* %11
%92 = load i32, i32* %13
%93 = add nsw i32 %92, 1
%94 = icmp sge i32 %91, %93
br i1 %94, label %95, label %110
95: ; preds = %90
%96 = load i32*, i32** %10
%97 = load i32, i32* %11
%98 = load i32, i32* %13
%99 = sub nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %96, i64 %100
%102 = load i32, i32* %101
%103 = load i32*, i32** %10
%104 = load i32, i32* %11
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %103, i64 %105
store i32 %102, i32* %106
br label %107
107: ; preds = %95
%108 = load i32, i32* %11
%109 = add nsw i32 %108, -1
store i32 %109, i32* %11
br label %90
110: ; preds = %90
%111 = load i32, i32* %13
store i32 %111, i32* %11
br label %112
112: ; preds = %134, %110
%113 = load i32, i32* %11
%114 = icmp sge i32 %113, 1
br i1 %114, label %115, label %137
115: ; preds = %112
%116 = load i32, i32* %12
%117 = sitofp i32 %116 to double
%118 = fadd double %117, 5.000000e-01
store double %118, double* %14
%119 = load double, double* %15
%120 = load double, double* %14
%121 = fmul double %119, %120
%122 = fptosi double %121 to i32
store i32 %122, i32* %12
%123 = load double, double* %14
%124 = load double, double* %7
%125 = load i32, i32* %12
%126 = sitofp i32 %125 to double
%127 = fneg double %124
%128 = call double @llvm.fmuladd.f64(double %127, double %126, double %123)
%129 = fptosi double %128 to i32
%130 = load i32*, i32** %10
%131 = load i32, i32* %11
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds i32, i32* %130, i64 %132
store i32 %129, i32* %133
br label %134
134: ; preds = %115
%135 = load i32, i32* %11
%136 = add nsw i32 %135, -1
store i32 %136, i32* %11
br label %112
137: ; preds = %112
br label %138
138: ; preds = %137, %65
ret void
}

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