void recast(double(**double_poly_ptr), int(**int_poly_ptr),
            unsigned int numberofbeads, double *recast_ptr) {
  for (int dim1 = 0; dim1 < numberofbeads; dim1++) {
    double_poly_ptr[dim1][0] = *recast_ptr * (double)int_poly_ptr[dim1][0];
    double_poly_ptr[dim1][1] = *recast_ptr * (double)int_poly_ptr[dim1][1];
    double_poly_ptr[dim1][2] = *recast_ptr * (double)int_poly_ptr[dim1][2];
  }
}


x86 assembly (clang, -O0):
<recast>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    11bc <recast+0xbc>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x4(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cvtsi2sdl 0x8(%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111a <recast+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<recast>:
test   %edx,%edx
je     1155 <recast+0x55>
mov    %edx,%r8d
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rsi,%rdx,8),%r9
xorps  %xmm0,%xmm0
cvtsi2sdl (%r9),%xmm0
mulsd  (%rcx),%xmm0
mov    (%rdi,%rdx,8),%rax
movsd  %xmm0,(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x4(%r9),%xmm0
mulsd  (%rcx),%xmm0
movsd  %xmm0,0x8(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl 0x8(%r9),%xmm0
mulsd  (%rcx),%xmm0
movsd  %xmm0,0x10(%rax)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1110 <recast+0x10>
ret

LLVM IR (-O0):
define void @recast(double** %0, i32** %1, i32 %2, double* %3) {
%5 = alloca double**
%6 = alloca i32**
%7 = alloca i32
%8 = alloca double*
%9 = alloca i32
store double** %0, double*** %5
store i32** %1, i32*** %6
store i32 %2, i32* %7
store double* %3, double** %8
store i32 0, i32* %9
br label %10
10: ; preds = %66, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %7
%13 = icmp ult i32 %11, %12
br i1 %13, label %14, label %69
14: ; preds = %10
%15 = load double*, double** %8
%16 = load double, double* %15
%17 = load i32**, i32*** %6
%18 = load i32, i32* %9
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds i32*, i32** %17, i64 %19
%21 = load i32*, i32** %20
%22 = getelementptr inbounds i32, i32* %21, i64 0
%23 = load i32, i32* %22
%24 = sitofp i32 %23 to double
%25 = fmul double %16, %24
%26 = load double**, double*** %5
%27 = load i32, i32* %9
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double*, double** %26, i64 %28
%30 = load double*, double** %29
%31 = getelementptr inbounds double, double* %30, i64 0
store double %25, double* %31
%32 = load double*, double** %8
%33 = load double, double* %32
%34 = load i32**, i32*** %6
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i32*, i32** %34, i64 %36
%38 = load i32*, i32** %37
%39 = getelementptr inbounds i32, i32* %38, i64 1
%40 = load i32, i32* %39
%41 = sitofp i32 %40 to double
%42 = fmul double %33, %41
%43 = load double**, double*** %5
%44 = load i32, i32* %9
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double*, double** %43, i64 %45
%47 = load double*, double** %46
%48 = getelementptr inbounds double, double* %47, i64 1
store double %42, double* %48
%49 = load double*, double** %8
%50 = load double, double* %49
%51 = load i32**, i32*** %6
%52 = load i32, i32* %9
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32*, i32** %51, i64 %53
%55 = load i32*, i32** %54
%56 = getelementptr inbounds i32, i32* %55, i64 2
%57 = load i32, i32* %56
%58 = sitofp i32 %57 to double
%59 = fmul double %50, %58
%60 = load double**, double*** %5
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double*, double** %60, i64 %62
%64 = load double*, double** %63
%65 = getelementptr inbounds double, double* %64, i64 2
store double %59, double* %65
br label %66
66: ; preds = %14
%67 = load i32, i32* %9
%68 = add nsw i32 %67, 1
store i32 %68, i32* %9
br label %10
69: ; preds = %10
ret void
}

LLVM IR (-O2):
define void @recast(double** nocapture %0, i32** nocapture %1, i32 %2, double* nocapture %3) {
%5 = icmp eq i32 %2, 0
br i1 %5, label %8, label %6
6: ; preds = %4
%7 = zext i32 %2 to i64
br label %9
8: ; preds = %9, %4
ret void
9: ; preds = %6, %9
%10 = phi i64 [ 0, %6 ], [ %31, %9 ]
%11 = load double, double* %3
%12 = getelementptr inbounds i32*, i32** %1, i64 %10
%13 = load i32*, i32** %12
%14 = load i32, i32* %13
%15 = sitofp i32 %14 to double
%16 = fmul double %11, %15
%17 = getelementptr inbounds double*, double** %0, i64 %10
%18 = load double*, double** %17
store double %16, double* %18
%19 = load double, double* %3
%20 = getelementptr inbounds i32, i32* %13, i64 1
%21 = load i32, i32* %20
%22 = sitofp i32 %21 to double
%23 = fmul double %19, %22
%24 = getelementptr inbounds double, double* %18, i64 1
store double %23, double* %24
%25 = load double, double* %3
%26 = getelementptr inbounds i32, i32* %13, i64 2
%27 = load i32, i32* %26
%28 = sitofp i32 %27 to double
%29 = fmul double %25, %28
%30 = getelementptr inbounds double, double* %18, i64 2
store double %29, double* %30
%31 = add nuw nsw i64 %10, 1
%32 = icmp eq i64 %31, %7
br i1 %32, label %8, label %9
}