void calc_beta_dev(float *beta_d, float *b_d, float scale_t, int nstates,
                   int obs_t, int t) {
  int i;
  for (i = 0; i < nstates; ++i) {
    beta_d[(t * nstates) + i] =
        beta_d[((t + 1) * nstates) + i] * b_d[(obs_t * nstates) + i] / scale_t;
  }
}


x86 assembly (clang, -O0):
<calc_beta_dev>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1186 <calc_beta_dev+0x86>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
divss  -0x14(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1122 <calc_beta_dev+0x22>
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_beta_dev>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
test   %edx,%edx
jle    12c1 <calc_beta_dev+0x1c1>
lea    0x1(%r8),%eax
imul   %edx,%eax
imul   %edx,%ecx
imul   %edx,%r8d
movslq %eax,%r9
movslq %ecx,%r10
movslq %r8d,%r8
mov    %edx,%r14d
cmp    $0x4,%edx
jae    11c7 <calc_beta_dev+0xc7>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
test   $0x1,%r14b
je     1164 <calc_beta_dev+0x64>
lea    (%rdx,%r9,1),%rcx
movss  (%rdi,%rcx,4),%xmm1
lea    (%rdx,%r10,1),%rcx
mulss  (%rsi,%rcx,4),%xmm1
divss  %xmm0,%xmm1
lea    (%rdx,%r8,1),%rcx
movss  %xmm1,(%rdi,%rcx,4)
or     $0x1,%rdx
add    %r14,%rax
je     12c1 <calc_beta_dev+0x1c1>
lea    (%rdi,%r8,4),%rax
add    $0x4,%rax
lea    (%rsi,%r10,4),%rcx
add    $0x4,%rcx
lea    (%rdi,%r9,4),%rsi
add    $0x4,%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movss  -0x4(%rsi,%rdx,4),%xmm1
mulss  -0x4(%rcx,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rax,%rdx,4)
movss  (%rsi,%rdx,4),%xmm1
mulss  (%rcx,%rdx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r14
jne    1190 <calc_beta_dev+0x90>
jmp    12c1 <calc_beta_dev+0x1c1>
lea    (%rdi,%r8,4),%rax
lea    (%r8,%r14,1),%rcx
lea    (%rdi,%rcx,4),%rcx
lea    (%rdi,%r9,4),%r15
lea    (%r9,%r14,1),%rbx
lea    (%rdi,%rbx,4),%rbx
lea    (%rsi,%r10,4),%r11
lea    (%r10,%r14,1),%rdx
lea    (%rsi,%rdx,4),%rdx
cmp    %rbx,%rax
setb   %bpl
cmp    %rcx,%r15
setb   %bl
cmp    %rdx,%rax
setb   %al
cmp    %rcx,%r11
setb   %cl
xor    %edx,%edx
test   %bl,%bpl
jne    1135 <calc_beta_dev+0x35>
and    %cl,%al
jne    1135 <calc_beta_dev+0x35>
mov    %r14d,%edx
and    $0xfffffffc,%edx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rdx),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     12ca <calc_beta_dev+0x1ca>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rdi,%r9,4),%r15
add    $0x10,%r15
lea    (%rsi,%r10,4),%r12
add    $0x10,%r12
lea    (%rdi,%r8,4),%rax
add    $0x10,%rax
xor    %ecx,%ecx
nopl   (%rax)
movups -0x10(%r15,%rcx,4),%xmm2
movups -0x10(%r12,%rcx,4),%xmm3
mulps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,-0x10(%rax,%rcx,4)
movups (%r15,%rcx,4),%xmm2
movups (%r12,%rcx,4),%xmm3
mulps  %xmm2,%xmm3
divps  %xmm1,%xmm3
movups %xmm3,(%rax,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rbx
jne    1260 <calc_beta_dev+0x160>
test   $0x1,%r11b
je     12b8 <calc_beta_dev+0x1b8>
lea    (%rcx,%r9,1),%rax
movups (%rdi,%rax,4),%xmm2
lea    (%rcx,%r10,1),%rax
movups (%rsi,%rax,4),%xmm3
mulps  %xmm2,%xmm3
divps  %xmm1,%xmm3
add    %r8,%rcx
movups %xmm3,(%rdi,%rcx,4)
cmp    %r14,%rdx
jne    1135 <calc_beta_dev+0x35>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%r11b
jne    129b <calc_beta_dev+0x19b>
jmp    12b8 <calc_beta_dev+0x1b8>

LLVM IR (-O0):
define void @calc_beta_dev(float* %0, float* %1, float %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca float*
%8 = alloca float*
%9 = alloca float
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store float* %0, float** %7
store float* %1, float** %8
store float %2, float* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
store i32 0, i32* %13
br label %14
14: ; preds = %49, %6
%15 = load i32, i32* %13
%16 = load i32, i32* %10
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %52
18: ; preds = %14
%19 = load float*, float** %7
%20 = load i32, i32* %12
%21 = add nsw i32 %20, 1
%22 = load i32, i32* %10
%23 = mul nsw i32 %21, %22
%24 = load i32, i32* %13
%25 = add nsw i32 %23, %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float, float* %19, i64 %26
%28 = load float, float* %27
%29 = load float*, float** %8
%30 = load i32, i32* %11
%31 = load i32, i32* %10
%32 = mul nsw i32 %30, %31
%33 = load i32, i32* %13
%34 = add nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds float, float* %29, i64 %35
%37 = load float, float* %36
%38 = fmul float %28, %37
%39 = load float, float* %9
%40 = fdiv float %38, %39
%41 = load float*, float** %7
%42 = load i32, i32* %12
%43 = load i32, i32* %10
%44 = mul nsw i32 %42, %43
%45 = load i32, i32* %13
%46 = add nsw i32 %44, %45
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %41, i64 %47
store float %40, float* %48
br label %49
49: ; preds = %18
%50 = load i32, i32* %13
%51 = add nsw i32 %50, 1
store i32 %51, i32* %13
br label %14
52: ; preds = %14
ret void
}

LLVM IR (-O2):
define void @calc_beta_dev(float* nocapture %0, float* nocapture %1, float %2, i32 %3, i32 %4, i32 %5) {
%7 = icmp sgt i32 %3, 0
br i1 %7, label %8, label %144
8: ; preds = %6
%9 = add nsw i32 %5, 1
%10 = mul nsw i32 %9, %3
%11 = mul nsw i32 %4, %3
%12 = mul nsw i32 %5, %3
%13 = sext i32 %10 to i64
%14 = sext i32 %11 to i64
%15 = sext i32 %12 to i64
%16 = zext i32 %3 to i64
%17 = icmp ult i32 %3, 4
br i1 %17, label %98, label %18
18: ; preds = %8
%19 = getelementptr float, float* %0, i64 %15
%20 = add nsw i64 %15, %16
%21 = getelementptr float, float* %0, i64 %20
%22 = getelementptr float, float* %0, i64 %13
%23 = add nsw i64 %13, %16
%24 = getelementptr float, float* %0, i64 %23
%25 = getelementptr float, float* %1, i64 %14
%26 = add nsw i64 %14, %16
%27 = getelementptr float, float* %1, i64 %26
%28 = icmp ult float* %19, %24
%29 = icmp ult float* %22, %21
%30 = and i1 %28, %29
%31 = icmp ult float* %19, %27
%32 = icmp ult float* %25, %21
%33 = and i1 %31, %32
%34 = or i1 %30, %33
br i1 %34, label %98, label %35
35: ; preds = %18
%36 = and i64 %16, 4294967292
%37 = insertelement <4 x float> poison, float %2, i64 0
%38 = shufflevector <4 x float> %37, <4 x float> poison, <4 x i32> zeroinitializer
%39 = add nsw i64 %36, -4
%40 = lshr exact i64 %39, 2
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 1
%43 = icmp eq i64 %39, 0
br i1 %43, label %79, label %44
44: ; preds = %35
%45 = and i64 %41, 9223372036854775806
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %76, %46 ]
%48 = phi i64 [ 0, %44 ], [ %77, %46 ]
%49 = add nsw i64 %47, %13
%50 = getelementptr inbounds float, float* %0, i64 %49
%51 = bitcast float* %50 to <4 x float>*
%52 = load <4 x float>, <4 x float>* %51
%53 = add nsw i64 %47, %14
%54 = getelementptr inbounds float, float* %1, i64 %53
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = fmul <4 x float> %52, %56
%58 = fdiv <4 x float> %57, %38
%59 = add nsw i64 %47, %15
%60 = getelementptr inbounds float, float* %0, i64 %59
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %58, <4 x float>* %61
%62 = or i64 %47, 4
%63 = add nsw i64 %62, %13
%64 = getelementptr inbounds float, float* %0, i64 %63
%65 = bitcast float* %64 to <4 x float>*
%66 = load <4 x float>, <4 x float>* %65
%67 = add nsw i64 %62, %14
%68 = getelementptr inbounds float, float* %1, i64 %67
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = fmul <4 x float> %66, %70
%72 = fdiv <4 x float> %71, %38
%73 = add nsw i64 %62, %15
%74 = getelementptr inbounds float, float* %0, i64 %73
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %72, <4 x float>* %75
%76 = add nuw i64 %47, 8
%77 = add i64 %48, 2
%78 = icmp eq i64 %77, %45
br i1 %78, label %79, label %46
79: ; preds = %46, %35
%80 = phi i64 [ 0, %35 ], [ %76, %46 ]
%81 = icmp eq i64 %42, 0
br i1 %81, label %96, label %82
82: ; preds = %79
%83 = add nsw i64 %80, %13
%84 = getelementptr inbounds float, float* %0, i64 %83
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = add nsw i64 %80, %14
%88 = getelementptr inbounds float, float* %1, i64 %87
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = fmul <4 x float> %86, %90
%92 = fdiv <4 x float> %91, %38
%93 = add nsw i64 %80, %15
%94 = getelementptr inbounds float, float* %0, i64 %93
%95 = bitcast float* %94 to <4 x float>*
store <4 x float> %92, <4 x float>* %95
br label %96
96: ; preds = %79, %82
%97 = icmp eq i64 %36, %16
br i1 %97, label %144, label %98
98: ; preds = %18, %8, %96
%99 = phi i64 [ 0, %18 ], [ 0, %8 ], [ %36, %96 ]
%100 = xor i64 %99, -1
%101 = and i64 %16, 1
%102 = icmp eq i64 %101, 0
br i1 %102, label %115, label %103
103: ; preds = %98
%104 = add nsw i64 %99, %13
%105 = getelementptr inbounds float, float* %0, i64 %104
%106 = load float, float* %105
%107 = add nsw i64 %99, %14
%108 = getelementptr inbounds float, float* %1, i64 %107
%109 = load float, float* %108
%110 = fmul float %106, %109
%111 = fdiv float %110, %2
%112 = add nsw i64 %99, %15
%113 = getelementptr inbounds float, float* %0, i64 %112
store float %111, float* %113
%114 = or i64 %99, 1
br label %115
115: ; preds = %103, %98
%116 = phi i64 [ %99, %98 ], [ %114, %103 ]
%117 = sub nsw i64 0, %16
%118 = icmp eq i64 %100, %117
br i1 %118, label %144, label %119
119: ; preds = %115, %119
%120 = phi i64 [ %142, %119 ], [ %116, %115 ]
%121 = add nsw i64 %120, %13
%122 = getelementptr inbounds float, float* %0, i64 %121
%123 = load float, float* %122
%124 = add nsw i64 %120, %14
%125 = getelementptr inbounds float, float* %1, i64 %124
%126 = load float, float* %125
%127 = fmul float %123, %126
%128 = fdiv float %127, %2
%129 = add nsw i64 %120, %15
%130 = getelementptr inbounds float, float* %0, i64 %129
store float %128, float* %130
%131 = add nuw nsw i64 %120, 1
%132 = add nsw i64 %131, %13
%133 = getelementptr inbounds float, float* %0, i64 %132
%134 = load float, float* %133
%135 = add nsw i64 %131, %14
%136 = getelementptr inbounds float, float* %1, i64 %135
%137 = load float, float* %136
%138 = fmul float %134, %137
%139 = fdiv float %138, %2
%140 = add nsw i64 %131, %15
%141 = getelementptr inbounds float, float* %0, i64 %140
store float %139, float* %141
%142 = add nuw nsw i64 %120, 2
%143 = icmp eq i64 %142, %16
br i1 %143, label %144, label %119
144: ; preds = %115, %119, %96, %6
ret void
}