// #target: macos-x64
// #safe: yes
module test;
import libc;

fn void testf()
{
    float[<4>] y = { 1, 2, 3, 4 };
    float[<4>] z = { 2, 2, 2, -100 };
    float[<4>] w = y + z;
    libc::printf("%f %f %f %f\n", w[0], w[1], w[2], w[3]);
    w = y * z;
    libc::printf("%f %f %f %f\n", w[0], w[1], w[2], w[3]);
    w = y / z;
    libc::printf("%f %f %f %f\n", w[0], w[1], w[2], w[3]);
    w = y - z;
    libc::printf("%f %f %f %f\n", w[0], w[1], w[2], w[3]);
    int[<4>] ww = y < z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y <= z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y > z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y >= z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y == z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y != z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
}

fn void testb()
{
    bool[<4>] y = { true, false, true, true };
    bool[<4>] z = { false, false, true, true };
    ichar[<4>] ww = y < z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y <= z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y > z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y >= z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y == z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
    ww = y != z;
    libc::printf("%d %d %d %d\n", ww[0], ww[1], ww[2], ww[3]);
}

fn void testi()
{
    int[<4>] y = { 1, 2, 3, 4 };
    int[<4>] z = { 2, 2, 2, -100 };
    int[<4>] w = y + z;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = y * z;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = y / z;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = y - z;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z >> y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z << y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z > y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z >= y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z < y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z <= y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z == y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = z != y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    uint[<4>] uz = { 2, 6, 2, 1 };
    w = uz > y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = uz >= y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = uz < y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = uz <= y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = uz == y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
    w = uz != y;
    libc::printf("%d %d %d %d\n", w[0], w[1], w[2], w[3]);
}

fn void main()
{
    testf();
    testi();
    testb();
}

/* #expect: test.ll

define void @test.testf() #0 {
entry:
  %y = alloca <4 x float>, align 16
  %z = alloca <4 x float>, align 16
  %w = alloca <4 x float>, align 16
  %ww = alloca <4 x i32>, align 16
  store <4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>, <4 x float>* %y, align 16
  store <4 x float> <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00, float -1.000000e+02>, <4 x float>* %z, align 16
  %0 = load <4 x float>, <4 x float>* %y, align 16
  %1 = load <4 x float>, <4 x float>* %z, align 16
  %fadd = fadd <4 x float> %0, %1
  store <4 x float> %fadd, <4 x float>* %w, align 16
  %2 = load <4 x float>, <4 x float>* %w, align 16
  %3 = extractelement <4 x float> %2, i64 0
  %fpfpext = fpext float %3 to double
  %4 = load <4 x float>, <4 x float>* %w, align 16
  %5 = extractelement <4 x float> %4, i64 1
  %fpfpext1 = fpext float %5 to double
  %6 = load <4 x float>, <4 x float>* %w, align 16
  %7 = extractelement <4 x float> %6, i64 2
  %fpfpext2 = fpext float %7 to double
  %8 = load <4 x float>, <4 x float>* %w, align 16
  %9 = extractelement <4 x float> %8, i64 3
  %fpfpext3 = fpext float %9 to double
  %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i32 0, i32 0), double %fpfpext, double %fpfpext1, double %fpfpext2, double %fpfpext3)
  %11 = load <4 x float>, <4 x float>* %y, align 16
  %12 = load <4 x float>, <4 x float>* %z, align 16
  %fmul = fmul <4 x float> %11, %12
  store <4 x float> %fmul, <4 x float>* %w, align 16
  %13 = load <4 x float>, <4 x float>* %w, align 16
  %14 = extractelement <4 x float> %13, i64 0
  %fpfpext4 = fpext float %14 to double
  %15 = load <4 x float>, <4 x float>* %w, align 16
  %16 = extractelement <4 x float> %15, i64 1
  %fpfpext5 = fpext float %16 to double
  %17 = load <4 x float>, <4 x float>* %w, align 16
  %18 = extractelement <4 x float> %17, i64 2
  %fpfpext6 = fpext float %18 to double
  %19 = load <4 x float>, <4 x float>* %w, align 16
  %20 = extractelement <4 x float> %19, i64 3
  %fpfpext7 = fpext float %20 to double
  %21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i32 0, i32 0), double %fpfpext4, double %fpfpext5, double %fpfpext6, double %fpfpext7)
  %22 = load <4 x float>, <4 x float>* %y, align 16
  %23 = load <4 x float>, <4 x float>* %z, align 16
  %24 = call <4 x float> @llvm.fabs.v4f32(<4 x float> %23)
  %25 = call float @llvm.vector.reduce.fmin.v4f32(<4 x float> %24)
  %zero = fcmp ueq float %25, 0.000000e+00
  br i1 %zero, label %panic, label %checkok

panic:                                            ; preds = %entry
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.zstr, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.2, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.3, i64 0, i64 0), i32 12)
  br label %checkok

checkok:                                          ; preds = %panic, %entry
  %fdiv = fdiv <4 x float> %22, %23
  store <4 x float> %fdiv, <4 x float>* %w, align 16
  %26 = load <4 x float>, <4 x float>* %w, align 16
  %27 = extractelement <4 x float> %26, i64 0
  %fpfpext8 = fpext float %27 to double
  %28 = load <4 x float>, <4 x float>* %w, align 16
  %29 = extractelement <4 x float> %28, i64 1
  %fpfpext9 = fpext float %29 to double
  %30 = load <4 x float>, <4 x float>* %w, align 16
  %31 = extractelement <4 x float> %30, i64 2
  %fpfpext10 = fpext float %31 to double
  %32 = load <4 x float>, <4 x float>* %w, align 16
  %33 = extractelement <4 x float> %32, i64 3
  %fpfpext11 = fpext float %33 to double
  %34 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i32 0, i32 0), double %fpfpext8, double %fpfpext9, double %fpfpext10, double %fpfpext11)
  %35 = load <4 x float>, <4 x float>* %y, align 16
  %36 = load <4 x float>, <4 x float>* %z, align 16
  %fsub = fsub <4 x float> %35, %36
  store <4 x float> %fsub, <4 x float>* %w, align 16
  %37 = load <4 x float>, <4 x float>* %w, align 16
  %38 = extractelement <4 x float> %37, i64 0
  %fpfpext12 = fpext float %38 to double
  %39 = load <4 x float>, <4 x float>* %w, align 16
  %40 = extractelement <4 x float> %39, i64 1
  %fpfpext13 = fpext float %40 to double
  %41 = load <4 x float>, <4 x float>* %w, align 16
  %42 = extractelement <4 x float> %41, i64 2
  %fpfpext14 = fpext float %42 to double
  %43 = load <4 x float>, <4 x float>* %w, align 16
  %44 = extractelement <4 x float> %43, i64 3
  %fpfpext15 = fpext float %44 to double
  %45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i32 0, i32 0), double %fpfpext12, double %fpfpext13, double %fpfpext14, double %fpfpext15)
  %46 = load <4 x float>, <4 x float>* %y, align 16
  %47 = load <4 x float>, <4 x float>* %z, align 16
  %lt = fcmp olt <4 x float> %46, %47
  %48 = sext <4 x i1> %lt to <4 x i32>
  store <4 x i32> %48, <4 x i32>* %ww, align 16
  %49 = load <4 x i32>, <4 x i32>* %ww, align 16
  %50 = extractelement <4 x i32> %49, i64 0
  %51 = load <4 x i32>, <4 x i32>* %ww, align 16
  %52 = extractelement <4 x i32> %51, i64 1
  %53 = load <4 x i32>, <4 x i32>* %ww, align 16
  %54 = extractelement <4 x i32> %53, i64 2
  %55 = load <4 x i32>, <4 x i32>* %ww, align 16
  %56 = extractelement <4 x i32> %55, i64 3
  %57 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.6, i32 0, i32 0), i32 %50, i32 %52, i32 %54, i32 %56)
  %58 = load <4 x float>, <4 x float>* %y, align 16
  %59 = load <4 x float>, <4 x float>* %z, align 16
  %le = fcmp ole <4 x float> %58, %59
  %60 = sext <4 x i1> %le to <4 x i32>
  store <4 x i32> %60, <4 x i32>* %ww, align 16
  %61 = load <4 x i32>, <4 x i32>* %ww, align 16
  %62 = extractelement <4 x i32> %61, i64 0
  %63 = load <4 x i32>, <4 x i32>* %ww, align 16
  %64 = extractelement <4 x i32> %63, i64 1
  %65 = load <4 x i32>, <4 x i32>* %ww, align 16
  %66 = extractelement <4 x i32> %65, i64 2
  %67 = load <4 x i32>, <4 x i32>* %ww, align 16
  %68 = extractelement <4 x i32> %67, i64 3
  %69 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.7, i32 0, i32 0), i32 %62, i32 %64, i32 %66, i32 %68)
  %70 = load <4 x float>, <4 x float>* %y, align 16
  %71 = load <4 x float>, <4 x float>* %z, align 16
  %gt = fcmp ogt <4 x float> %70, %71
  %72 = sext <4 x i1> %gt to <4 x i32>
  store <4 x i32> %72, <4 x i32>* %ww, align 16
  %73 = load <4 x i32>, <4 x i32>* %ww, align 16
  %74 = extractelement <4 x i32> %73, i64 0
  %75 = load <4 x i32>, <4 x i32>* %ww, align 16
  %76 = extractelement <4 x i32> %75, i64 1
  %77 = load <4 x i32>, <4 x i32>* %ww, align 16
  %78 = extractelement <4 x i32> %77, i64 2
  %79 = load <4 x i32>, <4 x i32>* %ww, align 16
  %80 = extractelement <4 x i32> %79, i64 3
  %81 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.8, i32 0, i32 0), i32 %74, i32 %76, i32 %78, i32 %80)
  %82 = load <4 x float>, <4 x float>* %y, align 16
  %83 = load <4 x float>, <4 x float>* %z, align 16
  %ge = fcmp oge <4 x float> %82, %83
  %84 = sext <4 x i1> %ge to <4 x i32>
  store <4 x i32> %84, <4 x i32>* %ww, align 16
  %85 = load <4 x i32>, <4 x i32>* %ww, align 16
  %86 = extractelement <4 x i32> %85, i64 0
  %87 = load <4 x i32>, <4 x i32>* %ww, align 16
  %88 = extractelement <4 x i32> %87, i64 1
  %89 = load <4 x i32>, <4 x i32>* %ww, align 16
  %90 = extractelement <4 x i32> %89, i64 2
  %91 = load <4 x i32>, <4 x i32>* %ww, align 16
  %92 = extractelement <4 x i32> %91, i64 3
  %93 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i32 0, i32 0), i32 %86, i32 %88, i32 %90, i32 %92)
  %94 = load <4 x float>, <4 x float>* %y, align 16
  %95 = load <4 x float>, <4 x float>* %z, align 16
  %eq = fcmp oeq <4 x float> %94, %95
  %96 = sext <4 x i1> %eq to <4 x i32>
  store <4 x i32> %96, <4 x i32>* %ww, align 16
  %97 = load <4 x i32>, <4 x i32>* %ww, align 16
  %98 = extractelement <4 x i32> %97, i64 0
  %99 = load <4 x i32>, <4 x i32>* %ww, align 16
  %100 = extractelement <4 x i32> %99, i64 1
  %101 = load <4 x i32>, <4 x i32>* %ww, align 16
  %102 = extractelement <4 x i32> %101, i64 2
  %103 = load <4 x i32>, <4 x i32>* %ww, align 16
  %104 = extractelement <4 x i32> %103, i64 3
  %105 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.10, i32 0, i32 0), i32 %98, i32 %100, i32 %102, i32 %104)
  %106 = load <4 x float>, <4 x float>* %y, align 16
  %107 = load <4 x float>, <4 x float>* %z, align 16
  %neq = fcmp one <4 x float> %106, %107
  %108 = sext <4 x i1> %neq to <4 x i32>
  store <4 x i32> %108, <4 x i32>* %ww, align 16
  %109 = load <4 x i32>, <4 x i32>* %ww, align 16
  %110 = extractelement <4 x i32> %109, i64 0
  %111 = load <4 x i32>, <4 x i32>* %ww, align 16
  %112 = extractelement <4 x i32> %111, i64 1
  %113 = load <4 x i32>, <4 x i32>* %ww, align 16
  %114 = extractelement <4 x i32> %113, i64 2
  %115 = load <4 x i32>, <4 x i32>* %ww, align 16
  %116 = extractelement <4 x i32> %115, i64 3
  %117 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.11, i32 0, i32 0), i32 %110, i32 %112, i32 %114, i32 %116)
  ret void
}

; Function Attrs: nounwind
define void @test.testb() #0 {
entry:
  %y = alloca <4 x i8>, align 4
  %z = alloca <4 x i8>, align 4
  %ww = alloca <4 x i8>, align 4
  store <4 x i8> <i8 1, i8 0, i8 1, i8 1>, <4 x i8>* %y, align 4
  store <4 x i8> <i8 0, i8 0, i8 1, i8 1>, <4 x i8>* %z, align 4
  %0 = load <4 x i8>, <4 x i8>* %y, align 4
  %1 = load <4 x i8>, <4 x i8>* %z, align 4
  %lt = icmp ult <4 x i8> %0, %1
  %2 = sext <4 x i1> %lt to <4 x i8>
  store <4 x i8> %2, <4 x i8>* %ww, align 4
  %3 = load <4 x i8>, <4 x i8>* %ww, align 4
  %4 = extractelement <4 x i8> %3, i64 0
  %sisiext = sext i8 %4 to i32
  %5 = load <4 x i8>, <4 x i8>* %ww, align 4
  %6 = extractelement <4 x i8> %5, i64 1
  %sisiext1 = sext i8 %6 to i32
  %7 = load <4 x i8>, <4 x i8>* %ww, align 4
  %8 = extractelement <4 x i8> %7, i64 2
  %sisiext2 = sext i8 %8 to i32
  %9 = load <4 x i8>, <4 x i8>* %ww, align 4
  %10 = extractelement <4 x i8> %9, i64 3
  %sisiext3 = sext i8 %10 to i32
  %11 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.12, i32 0, i32 0), i32 %sisiext, i32 %sisiext1, i32 %sisiext2, i32 %sisiext3)
  %12 = load <4 x i8>, <4 x i8>* %y, align 4
  %13 = load <4 x i8>, <4 x i8>* %z, align 4
  %le = icmp ule <4 x i8> %12, %13
  %14 = sext <4 x i1> %le to <4 x i8>
  store <4 x i8> %14, <4 x i8>* %ww, align 4
  %15 = load <4 x i8>, <4 x i8>* %ww, align 4
  %16 = extractelement <4 x i8> %15, i64 0
  %sisiext4 = sext i8 %16 to i32
  %17 = load <4 x i8>, <4 x i8>* %ww, align 4
  %18 = extractelement <4 x i8> %17, i64 1
  %sisiext5 = sext i8 %18 to i32
  %19 = load <4 x i8>, <4 x i8>* %ww, align 4
  %20 = extractelement <4 x i8> %19, i64 2
  %sisiext6 = sext i8 %20 to i32
  %21 = load <4 x i8>, <4 x i8>* %ww, align 4
  %22 = extractelement <4 x i8> %21, i64 3
  %sisiext7 = sext i8 %22 to i32
  %23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.13, i32 0, i32 0), i32 %sisiext4, i32 %sisiext5, i32 %sisiext6, i32 %sisiext7)
  %24 = load <4 x i8>, <4 x i8>* %y, align 4
  %25 = load <4 x i8>, <4 x i8>* %z, align 4
  %gt = icmp ugt <4 x i8> %24, %25
  %26 = sext <4 x i1> %gt to <4 x i8>
  store <4 x i8> %26, <4 x i8>* %ww, align 4
  %27 = load <4 x i8>, <4 x i8>* %ww, align 4
  %28 = extractelement <4 x i8> %27, i64 0
  %sisiext8 = sext i8 %28 to i32
  %29 = load <4 x i8>, <4 x i8>* %ww, align 4
  %30 = extractelement <4 x i8> %29, i64 1
  %sisiext9 = sext i8 %30 to i32
  %31 = load <4 x i8>, <4 x i8>* %ww, align 4
  %32 = extractelement <4 x i8> %31, i64 2
  %sisiext10 = sext i8 %32 to i32
  %33 = load <4 x i8>, <4 x i8>* %ww, align 4
  %34 = extractelement <4 x i8> %33, i64 3
  %sisiext11 = sext i8 %34 to i32
  %35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.14, i32 0, i32 0), i32 %sisiext8, i32 %sisiext9, i32 %sisiext10, i32 %sisiext11)
  %36 = load <4 x i8>, <4 x i8>* %y, align 4
  %37 = load <4 x i8>, <4 x i8>* %z, align 4
  %ge = icmp uge <4 x i8> %36, %37
  %38 = sext <4 x i1> %ge to <4 x i8>
  store <4 x i8> %38, <4 x i8>* %ww, align 4
  %39 = load <4 x i8>, <4 x i8>* %ww, align 4
  %40 = extractelement <4 x i8> %39, i64 0
  %sisiext12 = sext i8 %40 to i32
  %41 = load <4 x i8>, <4 x i8>* %ww, align 4
  %42 = extractelement <4 x i8> %41, i64 1
  %sisiext13 = sext i8 %42 to i32
  %43 = load <4 x i8>, <4 x i8>* %ww, align 4
  %44 = extractelement <4 x i8> %43, i64 2
  %sisiext14 = sext i8 %44 to i32
  %45 = load <4 x i8>, <4 x i8>* %ww, align 4
  %46 = extractelement <4 x i8> %45, i64 3
  %sisiext15 = sext i8 %46 to i32
  %47 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i32 0, i32 0), i32 %sisiext12, i32 %sisiext13, i32 %sisiext14, i32 %sisiext15)
  %48 = load <4 x i8>, <4 x i8>* %y, align 4
  %49 = load <4 x i8>, <4 x i8>* %z, align 4
  %eq = icmp eq <4 x i8> %48, %49
  %50 = sext <4 x i1> %eq to <4 x i8>
  store <4 x i8> %50, <4 x i8>* %ww, align 4
  %51 = load <4 x i8>, <4 x i8>* %ww, align 4
  %52 = extractelement <4 x i8> %51, i64 0
  %sisiext16 = sext i8 %52 to i32
  %53 = load <4 x i8>, <4 x i8>* %ww, align 4
  %54 = extractelement <4 x i8> %53, i64 1
  %sisiext17 = sext i8 %54 to i32
  %55 = load <4 x i8>, <4 x i8>* %ww, align 4
  %56 = extractelement <4 x i8> %55, i64 2
  %sisiext18 = sext i8 %56 to i32
  %57 = load <4 x i8>, <4 x i8>* %ww, align 4
  %58 = extractelement <4 x i8> %57, i64 3
  %sisiext19 = sext i8 %58 to i32
  %59 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.16, i32 0, i32 0), i32 %sisiext16, i32 %sisiext17, i32 %sisiext18, i32 %sisiext19)
  %60 = load <4 x i8>, <4 x i8>* %y, align 4
  %61 = load <4 x i8>, <4 x i8>* %z, align 4
  %neq = icmp ne <4 x i8> %60, %61
  %62 = sext <4 x i1> %neq to <4 x i8>
  store <4 x i8> %62, <4 x i8>* %ww, align 4
  %63 = load <4 x i8>, <4 x i8>* %ww, align 4
  %64 = extractelement <4 x i8> %63, i64 0
  %sisiext20 = sext i8 %64 to i32
  %65 = load <4 x i8>, <4 x i8>* %ww, align 4
  %66 = extractelement <4 x i8> %65, i64 1
  %sisiext21 = sext i8 %66 to i32
  %67 = load <4 x i8>, <4 x i8>* %ww, align 4
  %68 = extractelement <4 x i8> %67, i64 2
  %sisiext22 = sext i8 %68 to i32
  %69 = load <4 x i8>, <4 x i8>* %ww, align 4
  %70 = extractelement <4 x i8> %69, i64 3
  %sisiext23 = sext i8 %70 to i32
  %71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.17, i32 0, i32 0), i32 %sisiext20, i32 %sisiext21, i32 %sisiext22, i32 %sisiext23)
  ret void
}

; Function Attrs: nounwind
define void @test.testi() #0 {
entry:
  %y = alloca <4 x i32>, align 16
  %z = alloca <4 x i32>, align 16
  %w = alloca <4 x i32>, align 16
  %uz = alloca <4 x i32>, align 16
  store <4 x i32> <i32 1, i32 2, i32 3, i32 4>, <4 x i32>* %y, align 16
  store <4 x i32> <i32 2, i32 2, i32 2, i32 -100>, <4 x i32>* %z, align 16
  %0 = load <4 x i32>, <4 x i32>* %y, align 16
  %1 = load <4 x i32>, <4 x i32>* %z, align 16
  %add = add <4 x i32> %0, %1
  store <4 x i32> %add, <4 x i32>* %w, align 16
  %2 = load <4 x i32>, <4 x i32>* %w, align 16
  %3 = extractelement <4 x i32> %2, i64 0
  %4 = load <4 x i32>, <4 x i32>* %w, align 16
  %5 = extractelement <4 x i32> %4, i64 1
  %6 = load <4 x i32>, <4 x i32>* %w, align 16
  %7 = extractelement <4 x i32> %6, i64 2
  %8 = load <4 x i32>, <4 x i32>* %w, align 16
  %9 = extractelement <4 x i32> %8, i64 3
  %10 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.18, i32 0, i32 0), i32 %3, i32 %5, i32 %7, i32 %9)
  %11 = load <4 x i32>, <4 x i32>* %y, align 16
  %12 = load <4 x i32>, <4 x i32>* %z, align 16
  %mul = mul <4 x i32> %11, %12
  store <4 x i32> %mul, <4 x i32>* %w, align 16
  %13 = load <4 x i32>, <4 x i32>* %w, align 16
  %14 = extractelement <4 x i32> %13, i64 0
  %15 = load <4 x i32>, <4 x i32>* %w, align 16
  %16 = extractelement <4 x i32> %15, i64 1
  %17 = load <4 x i32>, <4 x i32>* %w, align 16
  %18 = extractelement <4 x i32> %17, i64 2
  %19 = load <4 x i32>, <4 x i32>* %w, align 16
  %20 = extractelement <4 x i32> %19, i64 3
  %21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.19, i32 0, i32 0), i32 %14, i32 %16, i32 %18, i32 %20)
  %22 = load <4 x i32>, <4 x i32>* %y, align 16
  %23 = load <4 x i32>, <4 x i32>* %z, align 16
  %24 = call i32 @llvm.vector.reduce.umin.v4i32(<4 x i32> %23)
  %zero = icmp eq i32 %24, 0
  br i1 %zero, label %panic, label %checkok

panic:                                            ; preds = %entry
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.zstr.20, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.21, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.22, i64 0, i64 0), i32 56)
  br label %checkok

checkok:                                          ; preds = %panic, %entry
  %sdiv = sdiv <4 x i32> %22, %23
  store <4 x i32> %sdiv, <4 x i32>* %w, align 16
  %25 = load <4 x i32>, <4 x i32>* %w, align 16
  %26 = extractelement <4 x i32> %25, i64 0
  %27 = load <4 x i32>, <4 x i32>* %w, align 16
  %28 = extractelement <4 x i32> %27, i64 1
  %29 = load <4 x i32>, <4 x i32>* %w, align 16
  %30 = extractelement <4 x i32> %29, i64 2
  %31 = load <4 x i32>, <4 x i32>* %w, align 16
  %32 = extractelement <4 x i32> %31, i64 3
  %33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.23, i32 0, i32 0), i32 %26, i32 %28, i32 %30, i32 %32)
  %34 = load <4 x i32>, <4 x i32>* %y, align 16
  %35 = load <4 x i32>, <4 x i32>* %z, align 16
  %sub = sub <4 x i32> %34, %35
  store <4 x i32> %sub, <4 x i32>* %w, align 16
  %36 = load <4 x i32>, <4 x i32>* %w, align 16
  %37 = extractelement <4 x i32> %36, i64 0
  %38 = load <4 x i32>, <4 x i32>* %w, align 16
  %39 = extractelement <4 x i32> %38, i64 1
  %40 = load <4 x i32>, <4 x i32>* %w, align 16
  %41 = extractelement <4 x i32> %40, i64 2
  %42 = load <4 x i32>, <4 x i32>* %w, align 16
  %43 = extractelement <4 x i32> %42, i64 3
  %44 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.24, i32 0, i32 0), i32 %37, i32 %39, i32 %41, i32 %43)
  %45 = load <4 x i32>, <4 x i32>* %z, align 16
  %46 = load <4 x i32>, <4 x i32>* %y, align 16
  %47 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %46)
  %shift_underflow = icmp slt i32 %47, 0
  br i1 %shift_underflow, label %panic1, label %checkok2

panic1:                                           ; preds = %checkok
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.25, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.26, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.27, i64 0, i64 0), i32 60)
  br label %checkok2

checkok2:                                         ; preds = %panic1, %checkok
  %48 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %46)
  %shift_exceeds = icmp sge i32 %48, 32
  br i1 %shift_exceeds, label %panic3, label %checkok4

panic3:                                           ; preds = %checkok2
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.28, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.29, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.30, i64 0, i64 0), i32 60)
  br label %checkok4

checkok4:                                         ; preds = %panic3, %checkok2
  %ashr = ashr <4 x i32> %45, %46
  %49 = freeze <4 x i32> %ashr
  store <4 x i32> %49, <4 x i32>* %w, align 16
  %50 = load <4 x i32>, <4 x i32>* %w, align 16
  %51 = extractelement <4 x i32> %50, i64 0
  %52 = load <4 x i32>, <4 x i32>* %w, align 16
  %53 = extractelement <4 x i32> %52, i64 1
  %54 = load <4 x i32>, <4 x i32>* %w, align 16
  %55 = extractelement <4 x i32> %54, i64 2
  %56 = load <4 x i32>, <4 x i32>* %w, align 16
  %57 = extractelement <4 x i32> %56, i64 3
  %58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.31, i32 0, i32 0), i32 %51, i32 %53, i32 %55, i32 %57)
  %59 = load <4 x i32>, <4 x i32>* %z, align 16
  %60 = load <4 x i32>, <4 x i32>* %y, align 16
  %61 = call i32 @llvm.vector.reduce.smin.v4i32(<4 x i32> %60)
  %shift_underflow5 = icmp slt i32 %61, 0
  br i1 %shift_underflow5, label %panic6, label %checkok7

panic6:                                           ; preds = %checkok4
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.32, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.33, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.34, i64 0, i64 0), i32 62)
  br label %checkok7

checkok7:                                         ; preds = %panic6, %checkok4
  %62 = call i32 @llvm.vector.reduce.smax.v4i32(<4 x i32> %60)
  %shift_exceeds8 = icmp sge i32 %62, 32
  br i1 %shift_exceeds8, label %panic9, label %checkok10

panic9:                                           ; preds = %checkok7
  call void @"std::core::builtin.panic"(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.zstr.35, i64 0, i64 0), i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.zstr.36, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.zstr.37, i64 0, i64 0), i32 62)
  br label %checkok10

checkok10:                                        ; preds = %panic9, %checkok7
  %shl = shl <4 x i32> %59, %60
  %63 = freeze <4 x i32> %shl
  store <4 x i32> %63, <4 x i32>* %w, align 16
  %64 = load <4 x i32>, <4 x i32>* %w, align 16
  %65 = extractelement <4 x i32> %64, i64 0
  %66 = load <4 x i32>, <4 x i32>* %w, align 16
  %67 = extractelement <4 x i32> %66, i64 1
  %68 = load <4 x i32>, <4 x i32>* %w, align 16
  %69 = extractelement <4 x i32> %68, i64 2
  %70 = load <4 x i32>, <4 x i32>* %w, align 16
  %71 = extractelement <4 x i32> %70, i64 3
  %72 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.38, i32 0, i32 0), i32 %65, i32 %67, i32 %69, i32 %71)
  %73 = load <4 x i32>, <4 x i32>* %z, align 16
  %74 = load <4 x i32>, <4 x i32>* %y, align 16
  %gt = icmp sgt <4 x i32> %73, %74
  %75 = sext <4 x i1> %gt to <4 x i32>
  store <4 x i32> %75, <4 x i32>* %w, align 16
  %76 = load <4 x i32>, <4 x i32>* %w, align 16
  %77 = extractelement <4 x i32> %76, i64 0
  %78 = load <4 x i32>, <4 x i32>* %w, align 16
  %79 = extractelement <4 x i32> %78, i64 1
  %80 = load <4 x i32>, <4 x i32>* %w, align 16
  %81 = extractelement <4 x i32> %80, i64 2
  %82 = load <4 x i32>, <4 x i32>* %w, align 16
  %83 = extractelement <4 x i32> %82, i64 3
  %84 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.39, i32 0, i32 0), i32 %77, i32 %79, i32 %81, i32 %83)
  %85 = load <4 x i32>, <4 x i32>* %z, align 16
  %86 = load <4 x i32>, <4 x i32>* %y, align 16
  %ge = icmp sge <4 x i32> %85, %86
  %87 = sext <4 x i1> %ge to <4 x i32>
  store <4 x i32> %87, <4 x i32>* %w, align 16
  %88 = load <4 x i32>, <4 x i32>* %w, align 16
  %89 = extractelement <4 x i32> %88, i64 0
  %90 = load <4 x i32>, <4 x i32>* %w, align 16
  %91 = extractelement <4 x i32> %90, i64 1
  %92 = load <4 x i32>, <4 x i32>* %w, align 16
  %93 = extractelement <4 x i32> %92, i64 2
  %94 = load <4 x i32>, <4 x i32>* %w, align 16
  %95 = extractelement <4 x i32> %94, i64 3
  %96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.40, i32 0, i32 0), i32 %89, i32 %91, i32 %93, i32 %95)
  %97 = load <4 x i32>, <4 x i32>* %z, align 16
  %98 = load <4 x i32>, <4 x i32>* %y, align 16
  %lt = icmp slt <4 x i32> %97, %98
  %99 = sext <4 x i1> %lt to <4 x i32>
  store <4 x i32> %99, <4 x i32>* %w, align 16
  %100 = load <4 x i32>, <4 x i32>* %w, align 16
  %101 = extractelement <4 x i32> %100, i64 0
  %102 = load <4 x i32>, <4 x i32>* %w, align 16
  %103 = extractelement <4 x i32> %102, i64 1
  %104 = load <4 x i32>, <4 x i32>* %w, align 16
  %105 = extractelement <4 x i32> %104, i64 2
  %106 = load <4 x i32>, <4 x i32>* %w, align 16
  %107 = extractelement <4 x i32> %106, i64 3
  %108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.41, i32 0, i32 0), i32 %101, i32 %103, i32 %105, i32 %107)
  %109 = load <4 x i32>, <4 x i32>* %z, align 16
  %110 = load <4 x i32>, <4 x i32>* %y, align 16
  %le = icmp sle <4 x i32> %109, %110
  %111 = sext <4 x i1> %le to <4 x i32>
  store <4 x i32> %111, <4 x i32>* %w, align 16
  %112 = load <4 x i32>, <4 x i32>* %w, align 16
  %113 = extractelement <4 x i32> %112, i64 0
  %114 = load <4 x i32>, <4 x i32>* %w, align 16
  %115 = extractelement <4 x i32> %114, i64 1
  %116 = load <4 x i32>, <4 x i32>* %w, align 16
  %117 = extractelement <4 x i32> %116, i64 2
  %118 = load <4 x i32>, <4 x i32>* %w, align 16
  %119 = extractelement <4 x i32> %118, i64 3
  %120 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.42, i32 0, i32 0), i32 %113, i32 %115, i32 %117, i32 %119)
  %121 = load <4 x i32>, <4 x i32>* %z, align 16
  %122 = load <4 x i32>, <4 x i32>* %y, align 16
  %eq = icmp eq <4 x i32> %121, %122
  %123 = sext <4 x i1> %eq to <4 x i32>
  store <4 x i32> %123, <4 x i32>* %w, align 16
  %124 = load <4 x i32>, <4 x i32>* %w, align 16
  %125 = extractelement <4 x i32> %124, i64 0
  %126 = load <4 x i32>, <4 x i32>* %w, align 16
  %127 = extractelement <4 x i32> %126, i64 1
  %128 = load <4 x i32>, <4 x i32>* %w, align 16
  %129 = extractelement <4 x i32> %128, i64 2
  %130 = load <4 x i32>, <4 x i32>* %w, align 16
  %131 = extractelement <4 x i32> %130, i64 3
  %132 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.43, i32 0, i32 0), i32 %125, i32 %127, i32 %129, i32 %131)
  %133 = load <4 x i32>, <4 x i32>* %z, align 16
  %134 = load <4 x i32>, <4 x i32>* %y, align 16
  %neq = icmp ne <4 x i32> %133, %134
  %135 = sext <4 x i1> %neq to <4 x i32>
  store <4 x i32> %135, <4 x i32>* %w, align 16
  %136 = load <4 x i32>, <4 x i32>* %w, align 16
  %137 = extractelement <4 x i32> %136, i64 0
  %138 = load <4 x i32>, <4 x i32>* %w, align 16
  %139 = extractelement <4 x i32> %138, i64 1
  %140 = load <4 x i32>, <4 x i32>* %w, align 16
  %141 = extractelement <4 x i32> %140, i64 2
  %142 = load <4 x i32>, <4 x i32>* %w, align 16
  %143 = extractelement <4 x i32> %142, i64 3
  %144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.44, i32 0, i32 0), i32 %137, i32 %139, i32 %141, i32 %143)
  store <4 x i32> <i32 2, i32 6, i32 2, i32 1>, <4 x i32>* %uz, align 16
  %145 = load <4 x i32>, <4 x i32>* %uz, align 16
  %146 = load <4 x i32>, <4 x i32>* %y, align 16
  %lt11 = icmp slt <4 x i32> %146, %145
  %check = icmp slt <4 x i32> %145, zeroinitializer
  %siui-lt = or <4 x i1> %check, %lt11
  %147 = sext <4 x i1> %siui-lt to <4 x i32>
  store <4 x i32> %147, <4 x i32>* %w, align 16
  %148 = load <4 x i32>, <4 x i32>* %w, align 16
  %149 = extractelement <4 x i32> %148, i64 0
  %150 = load <4 x i32>, <4 x i32>* %w, align 16
  %151 = extractelement <4 x i32> %150, i64 1
  %152 = load <4 x i32>, <4 x i32>* %w, align 16
  %153 = extractelement <4 x i32> %152, i64 2
  %154 = load <4 x i32>, <4 x i32>* %w, align 16
  %155 = extractelement <4 x i32> %154, i64 3
  %156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.45, i32 0, i32 0), i32 %149, i32 %151, i32 %153, i32 %155)
  %157 = load <4 x i32>, <4 x i32>* %uz, align 16
  %158 = load <4 x i32>, <4 x i32>* %y, align 16
  %le12 = icmp sle <4 x i32> %158, %157
  %check13 = icmp slt <4 x i32> %157, zeroinitializer
  %siui-le = or <4 x i1> %check13, %le12
  %159 = sext <4 x i1> %siui-le to <4 x i32>
  store <4 x i32> %159, <4 x i32>* %w, align 16
  %160 = load <4 x i32>, <4 x i32>* %w, align 16
  %161 = extractelement <4 x i32> %160, i64 0
  %162 = load <4 x i32>, <4 x i32>* %w, align 16
  %163 = extractelement <4 x i32> %162, i64 1
  %164 = load <4 x i32>, <4 x i32>* %w, align 16
  %165 = extractelement <4 x i32> %164, i64 2
  %166 = load <4 x i32>, <4 x i32>* %w, align 16
  %167 = extractelement <4 x i32> %166, i64 3
  %168 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.46, i32 0, i32 0), i32 %161, i32 %163, i32 %165, i32 %167)
  %169 = load <4 x i32>, <4 x i32>* %uz, align 16
  %170 = load <4 x i32>, <4 x i32>* %y, align 16
  %gt14 = icmp sgt <4 x i32> %170, %169
  %check15 = icmp sge <4 x i32> %169, zeroinitializer
  %siui-gt = and <4 x i1> %check15, %gt14
  %171 = sext <4 x i1> %siui-gt to <4 x i32>
  store <4 x i32> %171, <4 x i32>* %w, align 16
  %172 = load <4 x i32>, <4 x i32>* %w, align 16
  %173 = extractelement <4 x i32> %172, i64 0
  %174 = load <4 x i32>, <4 x i32>* %w, align 16
  %175 = extractelement <4 x i32> %174, i64 1
  %176 = load <4 x i32>, <4 x i32>* %w, align 16
  %177 = extractelement <4 x i32> %176, i64 2
  %178 = load <4 x i32>, <4 x i32>* %w, align 16
  %179 = extractelement <4 x i32> %178, i64 3
  %180 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.47, i32 0, i32 0), i32 %173, i32 %175, i32 %177, i32 %179)
  %181 = load <4 x i32>, <4 x i32>* %uz, align 16
  %182 = load <4 x i32>, <4 x i32>* %y, align 16
  %ge16 = icmp sge <4 x i32> %182, %181
  %check17 = icmp sge <4 x i32> %181, zeroinitializer
  %siui-ge = and <4 x i1> %check17, %ge16
  %183 = sext <4 x i1> %siui-ge to <4 x i32>
  store <4 x i32> %183, <4 x i32>* %w, align 16
  %184 = load <4 x i32>, <4 x i32>* %w, align 16
  %185 = extractelement <4 x i32> %184, i64 0
  %186 = load <4 x i32>, <4 x i32>* %w, align 16
  %187 = extractelement <4 x i32> %186, i64 1
  %188 = load <4 x i32>, <4 x i32>* %w, align 16
  %189 = extractelement <4 x i32> %188, i64 2
  %190 = load <4 x i32>, <4 x i32>* %w, align 16
  %191 = extractelement <4 x i32> %190, i64 3
  %192 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.48, i32 0, i32 0), i32 %185, i32 %187, i32 %189, i32 %191)
  %193 = load <4 x i32>, <4 x i32>* %uz, align 16
  %194 = load <4 x i32>, <4 x i32>* %y, align 16
  %eq18 = icmp eq <4 x i32> %194, %193
  %check19 = icmp sge <4 x i32> %194, zeroinitializer
  %siui-eq = and <4 x i1> %check19, %eq18
  %195 = sext <4 x i1> %siui-eq to <4 x i32>
  store <4 x i32> %195, <4 x i32>* %w, align 16
  %196 = load <4 x i32>, <4 x i32>* %w, align 16
  %197 = extractelement <4 x i32> %196, i64 0
  %198 = load <4 x i32>, <4 x i32>* %w, align 16
  %199 = extractelement <4 x i32> %198, i64 1
  %200 = load <4 x i32>, <4 x i32>* %w, align 16
  %201 = extractelement <4 x i32> %200, i64 2
  %202 = load <4 x i32>, <4 x i32>* %w, align 16
  %203 = extractelement <4 x i32> %202, i64 3
  %204 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.49, i32 0, i32 0), i32 %197, i32 %199, i32 %201, i32 %203)
  %205 = load <4 x i32>, <4 x i32>* %uz, align 16
  %206 = load <4 x i32>, <4 x i32>* %y, align 16
  %neq20 = icmp ne <4 x i32> %206, %205
  %check21 = icmp slt <4 x i32> %206, zeroinitializer
  %siui-ne = or <4 x i1> %check21, %neq20
  %207 = sext <4 x i1> %siui-ne to <4 x i32>
  store <4 x i32> %207, <4 x i32>* %w, align 16
  %208 = load <4 x i32>, <4 x i32>* %w, align 16
  %209 = extractelement <4 x i32> %208, i64 0
  %210 = load <4 x i32>, <4 x i32>* %w, align 16
  %211 = extractelement <4 x i32> %210, i64 1
  %212 = load <4 x i32>, <4 x i32>* %w, align 16
  %213 = extractelement <4 x i32> %212, i64 2
  %214 = load <4 x i32>, <4 x i32>* %w, align 16
  %215 = extractelement <4 x i32> %214, i64 3
  %216 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.50, i32 0, i32 0), i32 %209, i32 %211, i32 %213, i32 %215)
  ret void
}