#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 */
scalar_t__ Scalloc(int, int);
int strlen(char *);
float *TranformRnaFoldMatTo53(float *rnafold_mat, char *seq,
                              float prob_cutoff) {
  int bp_prob_mat_dim;
  float *bp_prob_mat_incldiag;
  int mirror;
  int vienna_idx;
  int seqlen = strlen(seq);
  bp_prob_mat_dim = (seqlen + 1) * seqlen / 2;
  bp_prob_mat_incldiag = (float *)Scalloc(bp_prob_mat_dim, sizeof(float));
  mirror = 0;
  for (vienna_idx = (seqlen + 1) * seqlen / 2; vienna_idx >= 1; vienna_idx--) {
    if (rnafold_mat[vienna_idx] >= prob_cutoff)
      bp_prob_mat_incldiag[mirror] = rnafold_mat[vienna_idx];
    else
      bp_prob_mat_incldiag[mirror] = 0.0;
    mirror++;
  }
  return bp_prob_mat_incldiag;
}


x86 assembly (clang, -O0):
<TranformRnaFoldMatTo53>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
imul   -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%edi
mov    $0x4,%esi
call   1040 <Scalloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
imul   -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jl     11ea <TranformRnaFoldMatTo53+0xca>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x14(%rbp),%xmm0
jb     11c3 <TranformRnaFoldMatTo53+0xa3>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    11d3 <TranformRnaFoldMatTo53+0xb3>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1183 <TranformRnaFoldMatTo53+0x63>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<TranformRnaFoldMatTo53>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
movaps %xmm0,(%rsp)
mov    %rdi,%r14
mov    %rsi,%rdi
call   1030 <strlen@plt>
lea    0x1(%rax),%ebx
imul   %eax,%ebx
mov    %ebx,%ebp
shr    $0x1f,%ebp
add    %ebx,%ebp
sar    %ebp
mov    %ebp,%edi
mov    $0x4,%esi
call   1040 <Scalloc@plt>
movaps (%rsp),%xmm4
cmp    $0x2,%ebx
jl     12e8 <TranformRnaFoldMatTo53+0x1c8>
mov    %ebp,%ecx
cmp    $0x8,%ebp
jb     1184 <TranformRnaFoldMatTo53+0x64>
lea    (%r14,%rcx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    11fc <TranformRnaFoldMatTo53+0xdc>
lea    (%rax,%rcx,4),%rdx
lea    0x4(%r14),%rsi
cmp    %rdx,%rsi
jae    11fc <TranformRnaFoldMatTo53+0xdc>
xor    %edx,%edx
mov    %rcx,%rsi
mov    %rdx,%rdi
not    %rdi
test   $0x1,%cl
je     11b2 <TranformRnaFoldMatTo53+0x92>
movss  (%r14,%rsi,4),%xmm0
movaps %xmm4,%xmm1
cmpnless %xmm0,%xmm1
andnps %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
or     $0x1,%rdx
add    $0xffffffffffffffff,%rsi
add    %rcx,%rdi
je     12e8 <TranformRnaFoldMatTo53+0x1c8>
lea    (%r14,%rsi,4),%rsi
nop
movss  (%rsi),%xmm0
movaps %xmm4,%xmm1
cmpnless %xmm0,%xmm1
andnps %xmm0,%xmm1
movss  %xmm1,(%rax,%rdx,4)
movss  -0x4(%rsi),%xmm0
movaps %xmm4,%xmm1
cmpnless %xmm0,%xmm1
andnps %xmm0,%xmm1
movss  %xmm1,0x4(%rax,%rdx,4)
add    $0x2,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%rcx
jne    11c0 <TranformRnaFoldMatTo53+0xa0>
jmp    12e8 <TranformRnaFoldMatTo53+0x1c8>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movaps %xmm4,%xmm0
shufps $0x0,%xmm4,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     12fb <TranformRnaFoldMatTo53+0x1db>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r14,%rcx,4),%rbp
add    $0xfffffffffffffff4,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rbp),%xmm1
movups 0x0(%rbp),%xmm2
shufps $0x1b,%xmm2,%xmm2
shufps $0x1b,%xmm1,%xmm1
movaps %xmm0,%xmm3
cmpleps %xmm2,%xmm3
andps  %xmm2,%xmm3
movaps %xmm0,%xmm2
cmpleps %xmm1,%xmm2
andps  %xmm1,%xmm2
movups %xmm3,(%rax,%rsi,4)
movups %xmm2,0x10(%rax,%rsi,4)
movups -0x30(%rbp),%xmm1
movups -0x20(%rbp),%xmm2
shufps $0x1b,%xmm2,%xmm2
shufps $0x1b,%xmm1,%xmm1
movaps %xmm0,%xmm3
cmpleps %xmm2,%xmm3
andps  %xmm2,%xmm3
movaps %xmm0,%xmm2
cmpleps %xmm1,%xmm2
andps  %xmm1,%xmm2
movups %xmm3,0x20(%rax,%rsi,4)
movups %xmm2,0x30(%rax,%rsi,4)
add    $0x10,%rsi
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1240 <TranformRnaFoldMatTo53+0x120>
test   $0x1,%r8b
je     12e3 <TranformRnaFoldMatTo53+0x1c3>
mov    %rcx,%rdi
sub    %rsi,%rdi
movups -0x1c(%r14,%rdi,4),%xmm1
movups -0xc(%r14,%rdi,4),%xmm2
shufps $0x1b,%xmm2,%xmm2
shufps $0x1b,%xmm1,%xmm1
movaps %xmm0,%xmm3
cmpleps %xmm2,%xmm3
andps  %xmm2,%xmm3
cmpleps %xmm1,%xmm0
andps  %xmm1,%xmm0
movups %xmm3,(%rax,%rsi,4)
movups %xmm0,0x10(%rax,%rsi,4)
cmp    %rcx,%rdx
jne    12f1 <TranformRnaFoldMatTo53+0x1d1>
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
mov    %ecx,%esi
and    $0x7,%esi
jmp    1189 <TranformRnaFoldMatTo53+0x69>
xor    %esi,%esi
test   $0x1,%r8b
jne    12af <TranformRnaFoldMatTo53+0x18f>
jmp    12e3 <TranformRnaFoldMatTo53+0x1c3>

LLVM IR (-O0):
define float* @TranformRnaFoldMatTo53(float* %0, i8* %1, float %2) {
%4 = alloca float*
%5 = alloca i8*
%6 = alloca float
%7 = alloca i32
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store float* %0, float** %4
store i8* %1, i8** %5
store float %2, float* %6
%12 = load i8*, i8** %5
%13 = call i32 @strlen(i8* %12)
store i32 %13, i32* %11
%14 = load i32, i32* %11
%15 = add nsw i32 %14, 1
%16 = load i32, i32* %11
%17 = mul nsw i32 %15, %16
%18 = sdiv i32 %17, 2
store i32 %18, i32* %7
%19 = load i32, i32* %7
%20 = call i64 @Scalloc(i32 %19, i32 4)
%21 = inttoptr i64 %20 to float*
store float* %21, float** %8
store i32 0, i32* %9
%22 = load i32, i32* %11
%23 = add nsw i32 %22, 1
%24 = load i32, i32* %11
%25 = mul nsw i32 %23, %24
%26 = sdiv i32 %25, 2
store i32 %26, i32* %10
br label %27
27: ; preds = %56, %3
%28 = load i32, i32* %10
%29 = icmp sge i32 %28, 1
br i1 %29, label %30, label %59
30: ; preds = %27
%31 = load float*, float** %4
%32 = load i32, i32* %10
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float, float* %31, i64 %33
%35 = load float, float* %34
%36 = load float, float* %6
%37 = fcmp oge float %35, %36
br i1 %37, label %38, label %48
38: ; preds = %30
%39 = load float*, float** %4
%40 = load i32, i32* %10
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %39, i64 %41
%43 = load float, float* %42
%44 = load float*, float** %8
%45 = load i32, i32* %9
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
store float %43, float* %47
br label %53
48: ; preds = %30
%49 = load float*, float** %8
%50 = load i32, i32* %9
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds float, float* %49, i64 %51
store float 0.000000e+00, float* %52
br label %53
53: ; preds = %48, %38
%54 = load i32, i32* %9
%55 = add nsw i32 %54, 1
store i32 %55, i32* %9
br label %56
56: ; preds = %53
%57 = load i32, i32* %10
%58 = add nsw i32 %57, -1
store i32 %58, i32* %10
br label %27
59: ; preds = %27
%60 = load float*, float** %8
ret float* %60
}

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