Test Failure: Transforms/PhaseOrdering/X86/vec-load-combine.ll

Test source: git

Log:

Source: <stdin>
-- 1. Annotation2MetadataPass
-- 2. Annotation2MetadataPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 3. ForceFunctionAttrsPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 4. ForceFunctionAttrsPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 5. InferFunctionAttrsPass : Skipping unsupported
-- 6. InferFunctionAttrsPass : Skipping unsupported
-- 7. CoroEarlyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 8. CoroEarlyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 9. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 1. PassManager<Function> : Skipping NOP
-- 2. LowerExpectIntrinsicPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 3. LowerExpectIntrinsicPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 4. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 5. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 6. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 7. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = alloca i64 8, align 8
  %3 = alloca i64 16, align 16
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %4 = load ptr, ptr %2, align 8
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %4) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 0) noundef
  %7 = insertelement <4 x float> undef, float %6, i32 0
  %8 = load ptr, ptr %2, align 8
  %9 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %8) dereferenceable(16) nonnull noundef align(16)
  %10 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %9, noundef i32 1) noundef
  %11 = insertelement <4 x float> %7, float %10, i32 1
  %12 = load ptr, ptr %2, align 8
  %13 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %12) dereferenceable(16) nonnull noundef align(16)
  %14 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %13, noundef i32 2) noundef
  %15 = insertelement <4 x float> %11, float %14, i32 2
  %16 = load ptr, ptr %2, align 8
  %17 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr %16) dereferenceable(16) nonnull noundef align(16)
  %18 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %17, noundef i32 2) noundef
  %19 = insertelement <4 x float> %15, float %18, i32 3
  store <4 x float> %19, ptr %3, align 16
  %20 = load <4 x float>, ptr %3, align 16
  ret <4 x float> %20
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct!

-- 8. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 9. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 10. CallSiteSplittingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 11. CallSiteSplittingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 12. PassManager<Function> : Skipping NOP
-- 13. PassManager<Function> : Skipping NOP
-- 14. LowerExpectIntrinsicPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 15. LowerExpectIntrinsicPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 16. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 17. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 18. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
Transformation seems to be correct! (syntactically equal)

-- 19. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %V.addr = alloca i64 8, align 8
  %.compoundliteral = alloca i64 16, align 16
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  store ptr nonnull dereferenceable(16) noundef align(16) %V, ptr %V.addr, align 8
  start_lifetime ptr %ref.tmp
  %0 = load ptr, ptr %V.addr, align 8
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %0)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %1 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %2 = extractvalue {double, double} %call, 0
  store double %2, ptr %1, align 16
  %3 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %4 = extractvalue {double, double} %call, 1
  store double %4, ptr %3, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %5 = load ptr, ptr %V.addr, align 8
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %5)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %7 = extractvalue {double, double} %call3, 0
  store double %7, ptr %6, align 16
  %8 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %9 = extractvalue {double, double} %call3, 1
  store double %9, ptr %8, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %10 = load ptr, ptr %V.addr, align 8
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %10)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %11 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %12 = extractvalue {double, double} %call8, 0
  store double %12, ptr %11, align 16
  %13 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %14 = extractvalue {double, double} %call8, 1
  store double %14, ptr %13, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %15 = load ptr, ptr %V.addr, align 8
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr %15)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %16 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %17 = extractvalue {double, double} %call13, 0
  store double %17, ptr %16, align 16
  %18 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %19 = extractvalue {double, double} %call13, 1
  store double %19, ptr %18, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  store <4 x float> %vecinit16, ptr %.compoundliteral, align 16
  %20 = load <4 x float>, ptr %.compoundliteral, align 16
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %20
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %1 = extractvalue {double, double} %call, 0
  store double %1, ptr %0, align 16
  %2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %3 = extractvalue {double, double} %call, 1
  store double %3, ptr %2, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %5 = extractvalue {double, double} %call3, 0
  store double %5, ptr %4, align 16
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %7 = extractvalue {double, double} %call3, 1
  store double %7, ptr %6, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %9 = extractvalue {double, double} %call8, 0
  store double %9, ptr %8, align 16
  %10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call8, 1
  store double %11, ptr %10, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %13 = extractvalue {double, double} %call13, 0
  store double %13, ptr %12, align 16
  %14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %15 = extractvalue {double, double} %call13, 1
  store double %15, ptr %14, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct!

-- 20. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %1 = extractvalue {double, double} %call, 0
  store double %1, ptr %0, align 16
  %2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %3 = extractvalue {double, double} %call, 1
  store double %3, ptr %2, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %5 = extractvalue {double, double} %call3, 0
  store double %5, ptr %4, align 16
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %7 = extractvalue {double, double} %call3, 1
  store double %7, ptr %6, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %9 = extractvalue {double, double} %call8, 0
  store double %9, ptr %8, align 16
  %10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call8, 1
  store double %11, ptr %10, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %13 = extractvalue {double, double} %call13, 0
  store double %13, ptr %12, align 16
  %14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %15 = extractvalue {double, double} %call13, 1
  store double %15, ptr %14, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 21. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 0
  %0 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 0
  %1 = extractvalue {double, double} %call, 0
  store double %1, ptr %0, align 16
  %2 = gep inbounds ptr %coerce.dive, 16 x i32 0, 1 x i64 8
  %3 = extractvalue {double, double} %call, 1
  store double %3, ptr %2, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 0
  %4 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 0
  %5 = extractvalue {double, double} %call3, 0
  store double %5, ptr %4, align 16
  %6 = gep inbounds ptr %coerce.dive4, 16 x i32 0, 1 x i64 8
  %7 = extractvalue {double, double} %call3, 1
  store double %7, ptr %6, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive9 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 0
  %8 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 0
  %9 = extractvalue {double, double} %call8, 0
  store double %9, ptr %8, align 16
  %10 = gep inbounds ptr %coerce.dive9, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call8, 1
  store double %11, ptr %10, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %coerce.dive14 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 0
  %12 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 0
  %13 = extractvalue {double, double} %call13, 0
  store double %13, ptr %12, align 16
  %14 = gep inbounds ptr %coerce.dive14, 16 x i32 0, 1 x i64 8
  %15 = extractvalue {double, double} %call13, 1
  store double %15, ptr %14, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct!

-- 22. CallSiteSplittingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 23. CallSiteSplittingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 24. PassManager<Function> : Skipping NOP
-- 25. PassManager<Function> : Skipping NOP
-- 26. LowerExpectIntrinsicPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)

-- 27. LowerExpectIntrinsicPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)

-- 28. SimplifyCFGPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)

-- 29. SimplifyCFGPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)

-- 30. SROAPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
Transformation seems to be correct! (syntactically equal)

-- 31. SROAPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval = alloca i64 16, align 16
  %t.addr = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %t, ptr %t.addr, align 8
  %0 = load ptr, ptr %t.addr, align 8
  memcpy ptr %retval align 16, ptr %0 align 16, i64 16
  %coerce.dive = gep inbounds ptr %retval, 16 x i32 0, 1 x i64 0
  %1 = load {double, double}, ptr %coerce.dive, align 16
  ret {double, double} %1
}
=>
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct!

-- 32. EarlyCSEPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 33. EarlyCSEPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 34. CallSiteSplittingPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 35. CallSiteSplittingPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 36. PassManager<Function> : Skipping NOP
-- 37. PassManager<Function> : Skipping NOP
-- 38. LowerExpectIntrinsicPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)

-- 39. LowerExpectIntrinsicPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)

-- 40. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)

-- 41. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)

-- 42. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
Transformation seems to be correct! (syntactically equal)

-- 43. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  %2 = alloca i64 8, align 8
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %2, align 8
  %3 = load ptr, ptr %2, align 8
  ret ptr %3
}
=>
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct!

-- 44. EarlyCSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 45. EarlyCSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 46. CallSiteSplittingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 47. CallSiteSplittingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 48. PassManager<Function> : Skipping NOP
-- 49. PassManager<Function> : Skipping NOP
-- 50. LowerExpectIntrinsicPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)

-- 51. LowerExpectIntrinsicPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)

-- 52. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)

-- 53. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)

-- 54. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
Transformation seems to be correct! (syntactically equal)

-- 55. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = alloca i64 8, align 8
  %4 = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %0, ptr %3, align 8
  store i32 noundef %1, ptr %4, align 4
  %5 = load ptr, ptr %3, align 8
  %6 = load i32, ptr %4, align 4
  %7 = sext i32 %6 to i64
  %8 = gep inbounds ptr %5, 16 x i64 0, 4 x i64 %7
  %9 = load float, ptr %8, align 4
  ret float %9
}
=>
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct!

-- 56. EarlyCSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 57. EarlyCSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 58. CallSiteSplittingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 59. CallSiteSplittingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 60. PassManager<Function> : Skipping NOP
-- 61. PassManager<Function> : Skipping NOP
-- 62. LowerExpectIntrinsicPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)

-- 63. LowerExpectIntrinsicPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)

-- 64. SimplifyCFGPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)

-- 65. SimplifyCFGPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)

-- 66. SROAPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
Transformation seems to be correct! (syntactically equal)

-- 67. SROAPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %this.addr = alloca i64 8, align 8
  %i.addr = alloca i64 4, align 4
  store ptr nonnull dereferenceable(16) noundef align(16) %this, ptr %this.addr, align 8
  store i32 noundef %i, ptr %i.addr, align 4
  %this1 = load ptr, ptr %this.addr, align 8
  %0 = load i32, ptr %i.addr, align 4
  %idxprom = sext i32 %0 to i64
  %arrayidx = gep inbounds ptr %this1, 16 x i64 0, 4 x i64 %idxprom
  %1 = load float, ptr %arrayidx, align 4
  ret float %1
}
=>
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct!

-- 68. EarlyCSEPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 69. EarlyCSEPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 70. CallSiteSplittingPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 71. CallSiteSplittingPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 72. PassManager<Function> : Skipping NOP
-- 73. PassManager<Function> : Skipping NOP
-- 74. LowerExpectIntrinsicPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 75. LowerExpectIntrinsicPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 76. SimplifyCFGPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 77. SimplifyCFGPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 78. SROAPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 79. SROAPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 80. EarlyCSEPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 81. EarlyCSEPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 82. CallSiteSplittingPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 83. CallSiteSplittingPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 84. PassManager<Function> : Skipping NOP
-- 10. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 11. OpenMPOptPass : Skipping unsupported
-- 12. OpenMPOptPass : Skipping unsupported
-- 13. IPSCCPPass : Skipping unsupported
-- 14. IPSCCPPass : Skipping unsupported
-- 15. CalledValuePropagationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 16. CalledValuePropagationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 17. GlobalOptPass : Skipping unsupported
-- 18. GlobalOptPass : Skipping unsupported
-- 19. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 85. PassManager<Function> : Skipping NOP
-- 86. PromotePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 87. PromotePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 88. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 89. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i32 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i32 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i32 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i32 3
  ret <4 x float> %13
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct!

-- 90. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 91. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)

-- 92. PassManager<Function> : Skipping NOP
-- 93. PassManager<Function> : Skipping NOP
-- 94. PromotePass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 95. PromotePass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 96. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 97. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i32 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i32 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i32 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i32 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i32 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i32 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i32 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i32 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
=>
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct!

-- 98. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 99. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)

-- 100. PassManager<Function> : Skipping NOP
-- 101. PassManager<Function> : Skipping NOP
-- 102. PromotePass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 103. PromotePass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 104. InstCombinePass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 105. InstCombinePass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 106. SimplifyCFGPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 107. SimplifyCFGPass

----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)

-- 108. PassManager<Function> : Skipping NOP
-- 109. PassManager<Function> : Skipping NOP
-- 110. PromotePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 111. PromotePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 112. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 113. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 114. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 115. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 116. PassManager<Function> : Skipping NOP
-- 117. PassManager<Function> : Skipping NOP
-- 118. PromotePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 119. PromotePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 120. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 121. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 122. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 123. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 124. PassManager<Function> : Skipping NOP
-- 125. PassManager<Function> : Skipping NOP
-- 126. PromotePass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 127. PromotePass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 128. InstCombinePass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 129. InstCombinePass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 130. SimplifyCFGPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 131. SimplifyCFGPass

----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)

-- 132. PassManager<Function> : Skipping NOP
-- 133. PassManager<Function> : Skipping NOP
-- 134. PromotePass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 135. PromotePass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 136. InstCombinePass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 137. InstCombinePass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i32 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i32 0
  %vecext1 = extractelement <8 x i32> %src, i32 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i32 1
  %vecext4 = extractelement <8 x i32> %src, i32 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i32 2
  %vecext7 = extractelement <8 x i32> %src, i32 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i32 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
=>
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation doesn't verify! (not unsound)
ERROR: Timeout
-- 138. SimplifyCFGPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 139. SimplifyCFGPass

----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 140. PassManager<Function> : Skipping NOP
-- 20. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 21. ModuleInlinerWrapperPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 22. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 23. RequireAnalysisPass<GlobalsAA, Module> : Skipping unsupported
-- 24. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 141. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 142. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 143. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 144. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 145. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 146. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 147. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 148. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 149. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 150. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 151. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 152. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 153. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 154. InvalidateAnalysisPass<AAManager> : Skipping NOP
-- 25. ModuleToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 26. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 27. RequireAnalysisPass<ProfileSummaryAnalysis, Module> : Skipping NOP
-- 28. ModuleToPostOrderCGSCCPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 29. DevirtSCCRepeatedPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 30. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 31. InlinerPass : Skipping unsupported
-- 32. InlinerPass : Skipping unsupported
-- 33. InlinerPass : Skipping unsupported
-- 34. InlinerPass : Skipping unsupported
-- 35. PostOrderFunctionAttrsPass : Skipping unsupported
-- 36. PostOrderFunctionAttrsPass : Skipping unsupported
-- 37. ArgumentPromotionPass : Skipping unsupported
-- 38. ArgumentPromotionPass : Skipping unsupported
-- 39. OpenMPOptCGSCCPass : Skipping unsupported
-- 40. OpenMPOptCGSCCPass : Skipping unsupported
-- 41. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 155. PassManager<Function> : Skipping NOP
-- 156. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 157. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 158. EarlyCSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 159. EarlyCSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 160. SpeculativeExecutionPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 161. SpeculativeExecutionPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 162. JumpThreadingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 163. JumpThreadingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 164. CorrelatedValuePropagationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 165. CorrelatedValuePropagationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 166. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 167. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 168. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 169. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 170. AggressiveInstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 171. AggressiveInstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 172. ConstraintEliminationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 173. ConstraintEliminationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 174. LibCallsShrinkWrapPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 175. LibCallsShrinkWrapPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 176. TailCallElimPass : Skipping unsupported
-- 177. TailCallElimPass : Skipping unsupported
-- 178. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 179. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 180. ReassociatePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 181. ReassociatePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 182. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 183. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 184. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 185. PassManager<Function> : Skipping NOP
-- 186. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 187. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 188. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 189. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 190. PassManager<Function> : Skipping NOP
-- 191. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 192. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 193. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 194. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 195. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 196. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 197. PassManager<Function> : Skipping NOP
-- 198. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 199. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 200. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 201. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 202. PassManager<Function> : Skipping NOP
-- 203. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 204. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 205. SROAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 206. VectorCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 207. VectorCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 208. MergedLoadStoreMotionPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 209. MergedLoadStoreMotionPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 210. GVNPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 211. GVNPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 212. SCCPPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 213. SCCPPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 214. BDCEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 215. BDCEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 216. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 217. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 218. JumpThreadingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 219. JumpThreadingPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 220. CorrelatedValuePropagationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 221. CorrelatedValuePropagationPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 222. ADCEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 223. ADCEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 224. MemCpyOptPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 225. MemCpyOptPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 226. DSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 227. DSEPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 228. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 229. PassManager<Function> : Skipping NOP
-- 230. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 231. LoopSimplifyPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 232. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 233. LCSSAPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 234. PassManager<Function> : Skipping NOP
-- 235. FunctionToLoopPassAdaptor

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 236. CoroElidePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 237. CoroElidePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 238. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 239. SimplifyCFGPass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 240. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 241. InstCombinePass

----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)

-- 242. PassManager<Function> : Skipping NOP
-- 42. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  %5 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  %8 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  %11 = call ptr @castToElementWiseAccess_ByRef(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16)
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull noundef align(16) {
%1:
  ret ptr nonnull dereferenceable(16) noundef align(16) %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 43. PostOrderFunctionAttrsPass : Skipping unsupported
-- 44. PostOrderFunctionAttrsPass : Skipping unsupported
-- 45. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 243. RequireAnalysisPass<ShouldNotRunFunctionPassesAnalysis, Function> : Skipping NOP
-- 244. RequireAnalysisPass<ShouldNotRunFunctionPassesAnalysis, Function> : Skipping NOP
-- 46. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 47. CoroSplitPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 48. CoroSplitPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 49. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 50. DevirtSCCRepeatedPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 51. DevirtSCCRepeatedPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 52. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 53. InlinerPass : Skipping unsupported
-- 54. InlinerPass : Skipping unsupported
-- 55. InlinerPass : Skipping unsupported
-- 56. InlinerPass : Skipping unsupported
-- 57. PostOrderFunctionAttrsPass : Skipping unsupported
-- 58. PostOrderFunctionAttrsPass : Skipping unsupported
-- 59. ArgumentPromotionPass : Skipping unsupported
-- 60. ArgumentPromotionPass : Skipping unsupported
-- 61. OpenMPOptCGSCCPass : Skipping unsupported
-- 62. OpenMPOptCGSCCPass : Skipping unsupported
-- 63. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 245. PassManager<Function> : Skipping NOP
-- 246. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 247. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 248. EarlyCSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 249. EarlyCSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 250. SpeculativeExecutionPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 251. SpeculativeExecutionPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 252. JumpThreadingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 253. JumpThreadingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 254. CorrelatedValuePropagationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 255. CorrelatedValuePropagationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 256. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 257. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 258. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 259. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 260. AggressiveInstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 261. AggressiveInstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 262. ConstraintEliminationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 263. ConstraintEliminationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 264. LibCallsShrinkWrapPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 265. LibCallsShrinkWrapPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 266. TailCallElimPass : Skipping unsupported
-- 267. TailCallElimPass : Skipping unsupported
-- 268. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 269. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 270. ReassociatePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 271. ReassociatePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 272. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 273. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 274. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 275. PassManager<Function> : Skipping NOP
-- 276. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 277. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 278. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 279. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 280. PassManager<Function> : Skipping NOP
-- 281. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 282. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 283. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 284. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 285. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 286. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 287. PassManager<Function> : Skipping NOP
-- 288. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 289. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 290. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 291. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 292. PassManager<Function> : Skipping NOP
-- 293. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 294. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 295. SROAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 296. VectorCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 297. VectorCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 298. MergedLoadStoreMotionPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 299. MergedLoadStoreMotionPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 300. GVNPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 301. GVNPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 302. SCCPPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 303. SCCPPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 304. BDCEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 305. BDCEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 306. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 307. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 308. JumpThreadingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 309. JumpThreadingPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 310. CorrelatedValuePropagationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 311. CorrelatedValuePropagationPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 312. ADCEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 313. ADCEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 314. MemCpyOptPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 315. MemCpyOptPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 316. DSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 317. DSEPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 318. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 319. PassManager<Function> : Skipping NOP
-- 320. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 321. LoopSimplifyPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 322. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 323. LCSSAPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 324. PassManager<Function> : Skipping NOP
-- 325. FunctionToLoopPassAdaptor

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 326. CoroElidePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 327. CoroElidePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 328. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 329. SimplifyCFGPass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 330. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 331. InstCombinePass

----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)

-- 332. PassManager<Function> : Skipping NOP
-- 64. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 65. PostOrderFunctionAttrsPass : Skipping unsupported
-- 66. PostOrderFunctionAttrsPass : Skipping unsupported
-- 67. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 333. RequireAnalysisPass<ShouldNotRunFunctionPassesAnalysis, Function> : Skipping NOP
-- 334. RequireAnalysisPass<ShouldNotRunFunctionPassesAnalysis, Function> : Skipping NOP
-- 68. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 69. CoroSplitPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 70. CoroSplitPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 71. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 72. DevirtSCCRepeatedPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 73. DevirtSCCRepeatedPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %2 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %3 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %2, noundef i32 0) noundef
  %4 = insertelement <4 x float> undef, float %3, i64 0
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %5 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %6 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %5, noundef i32 1) noundef
  %7 = insertelement <4 x float> %4, float %6, i64 1
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %8 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %9 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %8, noundef i32 2) noundef
  %10 = insertelement <4 x float> %7, float %9, i64 2
  call void @castToElementWiseAccess_ByRef(nonnull noread nowrite dereferenceable(16) noundef align(16) returned ptr nonnull dereferenceable(16) noundef align(16) %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none)
  %11 = ptr nonnull dereferenceable(16) noundef align(16) %0
  %12 = call float @getAt(nonnull dereferenceable(16) noundef align(16) ptr %11, noundef i32 2) noundef
  %13 = insertelement <4 x float> %10, float %12, i64 3
  ret <4 x float> %13
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define ptr @castToElementWiseAccess_ByRef(ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0) dereferenceable(16) nonnull nofree noundef align(16) willreturn memory(none) {
%1:
  ret ptr nonnull noread nowrite dereferenceable(16) noundef align(16) returned %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @getAt(ptr nonnull dereferenceable(16) noundef align(16) %0, i32 noundef %1) noundef {
%2:
  %3 = sext i32 noundef %1 to i64
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 %3
  %5 = load float, ptr %4, align 4
  ret float %5
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 74. PassManager<LazyCallGraph::SCC, AnalysisManager<LazyCallGraph::SCC, LazyCallGraph&>, LazyCallGraph&, CGSCCUpdateResult&> : Skipping NOP
-- 75. InlinerPass : Skipping unsupported
-- 76. InlinerPass : Skipping unsupported
-- 77. InlinerPass : Skipping unsupported
-- 78. InlinerPass : Skipping unsupported
-- 79. PostOrderFunctionAttrsPass : Skipping unsupported
-- 80. PostOrderFunctionAttrsPass : Skipping unsupported
-- 81. ArgumentPromotionPass : Skipping unsupported
-- 82. ArgumentPromotionPass : Skipping unsupported
-- 83. OpenMPOptCGSCCPass : Skipping unsupported
-- 84. OpenMPOptCGSCCPass : Skipping unsupported
-- 85. CGSCCToFunctionPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %11 = load float, ptr %10, align 4
  %12 = insertelement <4 x float> %9, float %11, i64 3
  ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define <4 x float> @ConvertVectors_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %V) noundef {
%entry:
  %ref.tmp = alloca i64 16, align 16, dead
  %ref.tmp2 = alloca i64 16, align 16, dead
  %ref.tmp7 = alloca i64 16, align 16, dead
  %ref.tmp12 = alloca i64 16, align 16, dead
  start_lifetime ptr %ref.tmp
  %call = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %0 = extractvalue {double, double} %call, 0
  store double %0, ptr %ref.tmp, align 16
  %1 = gep inbounds ptr %ref.tmp, 16 x i64 0, 1 x i64 8
  %2 = extractvalue {double, double} %call, 1
  store double %2, ptr %1, align 8
  %call1 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp, noundef i32 0) noundef
  %vecinit = insertelement <4 x float> undef, float %call1, i64 0
  start_lifetime ptr %ref.tmp2
  %call3 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %3 = extractvalue {double, double} %call3, 0
  store double %3, ptr %ref.tmp2, align 16
  %4 = gep inbounds ptr %ref.tmp2, 16 x i64 0, 1 x i64 8
  %5 = extractvalue {double, double} %call3, 1
  store double %5, ptr %4, align 8
  %call5 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp2, noundef i32 1) noundef
  %vecinit6 = insertelement <4 x float> %vecinit, float %call5, i64 1
  start_lifetime ptr %ref.tmp7
  %call8 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %6 = extractvalue {double, double} %call8, 0
  store double %6, ptr %ref.tmp7, align 16
  %7 = gep inbounds ptr %ref.tmp7, 16 x i64 0, 1 x i64 8
  %8 = extractvalue {double, double} %call8, 1
  store double %8, ptr %7, align 8
  %call10 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp7, noundef i32 2) noundef
  %vecinit11 = insertelement <4 x float> %vecinit6, float %call10, i64 2
  start_lifetime ptr %ref.tmp12
  %call13 = call {double, double} @castToElementWiseAccess_ByVal(nonnull dereferenceable(16) noundef align(16) ptr nonnull dereferenceable(16) noundef align(16) %V)
  %9 = extractvalue {double, double} %call13, 0
  store double %9, ptr %ref.tmp12, align 16
  %10 = gep inbounds ptr %ref.tmp12, 16 x i64 0, 1 x i64 8
  %11 = extractvalue {double, double} %call13, 1
  store double %11, ptr %10, align 8
  %call15 = call float @ElementWiseAccess5getAt(nonnull dereferenceable(16) noundef align(16) ptr %ref.tmp12, noundef i32 2) noundef
  %vecinit16 = insertelement <4 x float> %vecinit11, float %call15, i64 3
  end_lifetime ptr %ref.tmp12
  end_lifetime ptr %ref.tmp7
  end_lifetime ptr %ref.tmp2
  end_lifetime ptr %ref.tmp
  ret <4 x float> %vecinit16
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define {double, double} @castToElementWiseAccess_ByVal(ptr nonnull dereferenceable(16) noundef align(16) %t) {
%entry:
  %retval.sroa.0.0.copyload = load double, ptr nonnull dereferenceable(16) noundef align(16) %t, align 16
  %retval.sroa.2.0.t.addr.0..sroa_idx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %t, 1 x i64 8
  %retval.sroa.2.0.copyload = load double, ptr %retval.sroa.2.0.t.addr.0..sroa_idx, align 8
  %.fca.0.insert = insertvalue {double, double} poison, double %retval.sroa.0.0.copyload, 0
  %.fca.1.insert = insertvalue {double, double} %.fca.0.insert, double %retval.sroa.2.0.copyload, 1
  ret {double, double} %.fca.1.insert
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define float @ElementWiseAccess5getAt(ptr nonnull dereferenceable(16) noundef align(16) %this, i32 noundef %i) noundef {
%entry:
  %idxprom = sext i32 noundef %i to i64
  %arrayidx = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %this, 16 x i64 0, 4 x i64 %idxprom
  %0 = load float, ptr %arrayidx, align 4
  ret float %0
}
Transformation seems to be correct! (syntactically equal)


----------------------------------------
define void @PR51397(ptr noundef %dst, ptr noundef %srcp) {
%0:
  %src = load <8 x i32>, ptr noundef %srcp, align 16
  %vecext = extractelement <8 x i32> %src, i64 0
  %conv = sitofp i32 %vecext to float
  %vecinit = insertelement <4 x float> undef, float %conv, i64 0
  %vecext1 = extractelement <8 x i32> %src, i64 1
  %conv2 = sitofp i32 %vecext1 to float
  %vecinit3 = insertelement <4 x float> %vecinit, float %conv2, i64 1
  %vecext4 = extractelement <8 x i32> %src, i64 2
  %conv5 = sitofp i32 %vecext4 to float
  %vecinit6 = insertelement <4 x float> %vecinit3, float %conv5, i64 2
  %vecext7 = extractelement <8 x i32> %src, i64 3
  %conv8 = sitofp i32 %vecext7 to float
  %vecinit9 = insertelement <4 x float> %vecinit6, float %conv8, i64 3
  store <4 x float> %vecinit9, ptr noundef %dst, align 16
  ret void
}
Transformation seems to be correct! (syntactically equal)

-- 335. PassManager<Function> : Skipping NOP
-- 336. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %11 = load float, ptr %10, align 4
  %12 = insertelement <4 x float> %9, float %11, i64 3
  ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)

-- 337. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %11 = load float, ptr %10, align 4
  %12 = insertelement <4 x float> %9, float %11, i64 3
  ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)

-- 338. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %11 = load float, ptr %10, align 4
  %12 = insertelement <4 x float> %9, float %11, i64 3
  ret <4 x float> %12
}
Transformation seems to be correct! (syntactically equal)

-- 339. EarlyCSEPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %11 = load float, ptr %10, align 4
  %12 = insertelement <4 x float> %9, float %11, i64 3
  ret <4 x float> %12
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct!

-- 340. SpeculativeExecutionPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 341. SpeculativeExecutionPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 342. JumpThreadingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 343. JumpThreadingPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 344. CorrelatedValuePropagationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 345. CorrelatedValuePropagationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 346. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 347. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 348. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 349. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 4
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 4
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct!

-- 350. AggressiveInstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 351. AggressiveInstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 352. ConstraintEliminationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 353. ConstraintEliminationPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 354. LibCallsShrinkWrapPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 355. LibCallsShrinkWrapPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 356. TailCallElimPass : Skipping unsupported
-- 357. TailCallElimPass : Skipping unsupported
-- 358. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 359. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 360. ReassociatePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 361. ReassociatePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 362. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 363. RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function> : Skipping NOP
-- 364. FunctionToLoopPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 365. PassManager<Function> : Skipping NOP
-- 366. LoopSimplifyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 367. LoopSimplifyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 368. LCSSAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 369. LCSSAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 370. PassManager<Function> : Skipping NOP
-- 371. FunctionToLoopPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 372. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 373. SimplifyCFGPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 374. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 375. InstCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 376. FunctionToLoopPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 377. PassManager<Function> : Skipping NOP
-- 378. LoopSimplifyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 379. LoopSimplifyPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 380. LCSSAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 381. LCSSAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 382. PassManager<Function> : Skipping NOP
-- 383. FunctionToLoopPassAdaptor

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 384. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 385. SROAPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 386. VectorCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 387. VectorCombinePass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load float, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = insertelement <4 x float> undef, float %2, i64 0
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct!

-- 388. MergedLoadStoreMotionPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 389. MergedLoadStoreMotionPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 390. GVNPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
Transformation seems to be correct! (syntactically equal)

-- 391. GVNPass

----------------------------------------
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %4 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 1
  %5 = load float, ptr %4, align 4
  %6 = insertelement <4 x float> %3, float %5, i64 1
  %7 = gep inbounds ptr nonnull dereferenceable(16) noundef align(16) %0, 16 x i64 0, 4 x i64 2
  %8 = load float, ptr %7, align 8
  %9 = insertelement <4 x float> %6, float %8, i64 2
  %10 = insertelement <4 x float> %9, float %8, i64 3
  ret <4 x float> %10
}
=>
define <4 x float> @ConvertVectors_ByRef(ptr nonnull dereferenceable(16) noundef align(16) %0) noundef {
%1:
  %2 = load <4 x float>, ptr nonnull dereferenceable(16) noundef align(16) %0, align 16
  %3 = shufflevector <4 x float> %2, <4 x float> poison, 0, 4294967295, 4294967295, 4294967295
  %5 = bitcast <4 x float> %2 to i128
  %6 = lshr i128 %5, 32
  %7 = trunc i128 %6 to i32
  %8 = bitcast i32 %7 to float
  %9 = insertelement <4 x float> %3, float %8, i64 1
  %11 = lshr i128 %5, 64
  %12 = trunc i128 %11 to i32
  %13 = bitcast i32 %12 to float
  %14 = insertelement <4 x float> %9, float %13, i64 2
  %15 = insertelement <4 x float> %14, float %13, i64 3
  ret <4 x float> %15
}
Transformation doesn't verify! (unsound)
ERROR: Source is more defined than target

Example:
ptr nonnull dereferenceable(16) noundef align(16) %0 = pointer(non-local, block_id=0, offset=104)

Source:
<4 x float> %2 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %3 = < #x00000000 (+0.0), poison, poison, poison >
ptr %4 = pointer(non-local, block_id=0, offset=108)
float %5 = #x00000000 (+0.0)
<4 x float> %6 = < #x00000000 (+0.0), #x00000000 (+0.0), poison, poison >
ptr %7 = pointer(non-local, block_id=0, offset=112)
float %8 = #x00000000 (+0.0)
<4 x float> %9 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %10 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0) >

SOURCE MEMORY STATE
===================
NON-LOCAL BLOCKS:
Block 0 >	size: 161	align: 2	alloc type: 0	address: 8

Target:
<4 x float> %2 = < #x00000000 (+0.0), #x00000000 (+0.0), #x00000000 (+0.0), poison >
<4 x float> %3 = < #x00000000 (+0.0), poison, poison, poison >
i128 %5 = poison
i128 %6 = poison
i32 %7 = poison
float %8 = poison
<4 x float> %9 = < #x00000000 (+0.0), poison, poison, poison >
i128 %11 = poison
i32 %12 = poison
float %13 = poison
<4 x float> %14 = < #x00000000 (+0.0), poison, poison, poison >
<4 x float> %15 = < #x00000000 (+0.0), poison, poison, poison >


Pass: GVNPass
Command line: '/home/nlopes/llvm/build/bin/opt' '-load=/home/nlopes/alive2/build/tv/tv.so' '-load-pass-plugin=/home/nlopes/alive2/build/tv/tv.so' '-tv-exit-on-error' '-passes=default<O3>' '-S' '-tv-smt-to=20000' '-tv-report-dir=/home/nlopes/alive2/build/logs' '-tv-smt-stats'
Wrote bitcode to: "/home/nlopes/alive2/build/logs/in_akM71rJ2_vJzU.bc"


------------------- SMT STATS -------------------
Num queries: 67
Num invalid: 0
Num skips:   0
Num trivial: 79 (54.1%)
Num timeout: 1 (1.5%)
Num errors:  0 (0.0%)
Num SAT:     43 (64.2%)
Num UNSAT:   23 (34.3%)
Alive2: Transform doesn't verify; aborting!

stderr:

+ : 'RUN: at line 2'
+ /home/nlopes/alive2/build/opt-alive.sh '-passes=default<O3>' -S
+ /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/vec-load-combine.ll --check-prefix=SSE

FileCheck error: '<stdin>' is empty.
FileCheck command line:  /bitbucket/nlopes/llvm/build/bin/FileCheck /bitbucket/nlopes/llvm/llvm/test/Transforms/PhaseOrdering/X86/vec-load-combine.ll --check-prefix=SSE

<-- Back