LLVM IR for D100495 reproduction

module.ll

; ModuleID = '__compute_module'
source_filename = "__compute_module"
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-grtev4-linux-gnu"

%complex128 = type <{ double, double }>

@0 = private unnamed_addr constant [16 x i8] c"\00\00\00\00\00\00\F0?\00\00\00\00\00\00\00\00", align 8
@1 = private unnamed_addr constant [16 x i8] zeroinitializer, align 8
@2 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00", align 8
@3 = private unnamed_addr constant [8 x i8] zeroinitializer, align 8
@4 = private unnamed_addr constant [4 x i8] c"\01\00\00\00", align 4
@5 = private unnamed_addr constant [4 x i8] zeroinitializer, align 4
@6 = private unnamed_addr constant [4 x i8] c"\02\00\00\00", align 4
@7 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@8 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
@9 = private unnamed_addr constant [1 x i8] c"\01", align 1
@10 = private unnamed_addr constant [8 x i8] zeroinitializer
@11 = private unnamed_addr constant [16 x i8] zeroinitializer
@12 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@13 = private unnamed_addr constant [8 x i8] zeroinitializer
@14 = private unnamed_addr constant [8 x i8] c"\CC;\7Ff\9E\A0\E6?"
@15 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@16 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@17 = private unnamed_addr constant [8 x i8] zeroinitializer
@18 = private unnamed_addr constant [4 x i8] zeroinitializer
@19 = private unnamed_addr constant [8 x i8] zeroinitializer
@20 = private unnamed_addr constant [8 x i8] c"\03\00\00\00\00\00\00\00"
@21 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@22 = private unnamed_addr constant [8 x i8] zeroinitializer
@23 = private unnamed_addr constant [8 x i8] c"\CC;\7Ff\9E\A0\E6?"
@24 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@25 = private unnamed_addr constant [8 x i8] zeroinitializer
@26 = private unnamed_addr constant [8 x i8] c"\CC;\7Ff\9E\A0\E6?"
@27 = private unnamed_addr constant [16 x i8] zeroinitializer
@28 = private unnamed_addr constant [8 x i8] zeroinitializer
@29 = private unnamed_addr constant [8 x i8] c"\02\00\00\00\00\00\00\00"
@30 = private unnamed_addr constant [4 x i8] zeroinitializer
@31 = private unnamed_addr constant [1 x i8] c"\01"
@32 = private unnamed_addr constant [4 x i8] zeroinitializer
@33 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@34 = private unnamed_addr constant [8 x i8] zeroinitializer
@35 = private unnamed_addr constant [8 x i8] c"\02\00\00\00\00\00\00\00"
@36 = private unnamed_addr constant [4 x i8] zeroinitializer
@37 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@38 = private unnamed_addr constant [8 x i8] zeroinitializer
@39 = private unnamed_addr constant [8 x i8] c"\04\00\00\00\00\00\00\00"
@40 = private unnamed_addr constant [4 x i8] zeroinitializer
@41 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@42 = private unnamed_addr constant [8 x i8] zeroinitializer
@43 = private unnamed_addr constant [8 x i8] c"\04\00\00\00\00\00\00\00"
@44 = private unnamed_addr constant [4 x i8] c"\02\00\00\00"
@45 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@46 = private unnamed_addr constant [8 x i8] zeroinitializer
@47 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@48 = private unnamed_addr constant [8 x i8] zeroinitializer
@49 = private unnamed_addr constant [8 x i8] zeroinitializer
@50 = private unnamed_addr constant [8 x i8] c"\02\00\00\00\00\00\00\00"
@51 = private unnamed_addr constant [4 x i8] zeroinitializer
@52 = private unnamed_addr constant [4 x i8] zeroinitializer
@53 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@54 = private unnamed_addr constant [8 x i8] zeroinitializer
@55 = private unnamed_addr constant [8 x i8] c"\04\00\00\00\00\00\00\00"
@56 = private unnamed_addr constant [1 x i8] c"\01"
@57 = private unnamed_addr constant [4 x i8] zeroinitializer
@58 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\02\00\00\00"
@59 = private unnamed_addr constant [4 x i8] zeroinitializer
@60 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@61 = private unnamed_addr constant [8 x i8] zeroinitializer
@62 = private unnamed_addr constant [8 x i8] c"\04\00\00\00\00\00\00\00"
@63 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@64 = private unnamed_addr constant [8 x i8] zeroinitializer
@65 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@66 = private unnamed_addr constant [16 x i8] zeroinitializer
@67 = private unnamed_addr constant [4 x i8] zeroinitializer
@68 = private unnamed_addr constant [8 x i8] c"\01\00\00\00\00\00\00\00"
@69 = private unnamed_addr constant [8 x i8] zeroinitializer
@70 = private unnamed_addr constant [8 x i8] c"\04\00\00\00\00\00\00\00"
@71 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@72 = private unnamed_addr constant [8 x i8] zeroinitializer
@73 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@74 = private unnamed_addr constant [8 x i8] zeroinitializer
@75 = private unnamed_addr constant [8 x i8] zeroinitializer
@76 = private unnamed_addr constant [8 x i8] c"\02\00\00\00\00\00\00\00"
@77 = private unnamed_addr constant [16 x i8] zeroinitializer
@78 = private unnamed_addr constant [16 x i8] c"\00\00\00\00\00\00\F8\7F\00\00\00\00\00\00\00\00"
@79 = private unnamed_addr constant [16 x i8] zeroinitializer
@80 = private unnamed_addr constant [16 x i8] zeroinitializer
@81 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@82 = private unnamed_addr constant [16 x i8] zeroinitializer
@83 = private unnamed_addr constant [8 x i8] c"\00\00\00\00\00\00\B0<"
@84 = private unnamed_addr constant [8 x i8] zeroinitializer

; Function Attrs: uwtable
define internal void @wide.unblocked_body.14.(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %fusion.invar_address.dim.1 = alloca i64, align 8
  %fusion.invar_address.dim.0 = alloca i64, align 8
  %fusion.1.invar_address.dim.1 = alloca i64, align 8
  %fusion.1.invar_address.dim.0 = alloca i64, align 8
  %fusion.2.invar_address.dim.1 = alloca i64, align 8
  %fusion.2.invar_address.dim.0 = alloca i64, align 8
  %subtract.3.invar_address.dim.1 = alloca i64, align 8
  %subtract.3.invar_address.dim.0 = alloca i64, align 8
  %fusion.3.invar_address.dim.1 = alloca i64, align 8
  %fusion.3.invar_address.dim.0 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 864
  %wide_param.9 = bitcast i8* %2 to [5 x i8*]*
  %3 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.9, i64 0, i64 2
  %4 = load i8*, i8** %3, align 8, !dereferenceable !3, !align !2
  %5 = bitcast i8* %4 to [2 x [2 x %complex128]]*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %8 = getelementptr inbounds i8, i8* %7, i64 448
  %fusion.3 = bitcast i8* %8 to [2 x [2 x %complex128]]*
  store i64 0, i64* %fusion.3.invar_address.dim.0, align 8
  br label %fusion.3.loop_header.dim.0

fusion.3.loop_header.dim.0:                       ; preds = %fusion.3.loop_exit.dim.1, %entry
  %fusion.3.indvar.dim.0 = load i64, i64* %fusion.3.invar_address.dim.0, align 8
  %9 = icmp uge i64 %fusion.3.indvar.dim.0, 2
  br i1 %9, label %fusion.3.loop_exit.dim.0, label %fusion.3.loop_body.dim.0

fusion.3.loop_body.dim.0:                         ; preds = %fusion.3.loop_header.dim.0
  store i64 0, i64* %fusion.3.invar_address.dim.1, align 8
  br label %fusion.3.loop_header.dim.1

fusion.3.loop_header.dim.1:                       ; preds = %fusion.3.loop_body.dim.1, %fusion.3.loop_body.dim.0
  %fusion.3.indvar.dim.1 = load i64, i64* %fusion.3.invar_address.dim.1, align 8
  %10 = icmp uge i64 %fusion.3.indvar.dim.1, 2
  br i1 %10, label %fusion.3.loop_exit.dim.1, label %fusion.3.loop_body.dim.1

fusion.3.loop_body.dim.1:                         ; preds = %fusion.3.loop_header.dim.1
  %11 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %5, i64 0, i64 %fusion.3.indvar.dim.0, i64 %fusion.3.indvar.dim.1
  %12 = load %complex128, %complex128* %11, align 1, !alias.scope !4, !noalias !7
  %13 = extractvalue %complex128 %12, 0
  %14 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %5, i64 0, i64 %fusion.3.indvar.dim.0, i64 %fusion.3.indvar.dim.1
  %15 = load %complex128, %complex128* %14, align 1, !alias.scope !4, !noalias !7
  %16 = extractvalue %complex128 %15, 1
  %17 = fneg reassoc nsz contract double %16
  %18 = insertvalue %complex128 zeroinitializer, double %13, 0
  %19 = insertvalue %complex128 %18, double %17, 1
  %20 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %fusion.3, i64 0, i64 %fusion.3.indvar.dim.0, i64 %fusion.3.indvar.dim.1
  store %complex128 %19, %complex128* %20, align 1, !alias.scope !13, !noalias !14
  %invar.inc1 = add nuw nsw i64 %fusion.3.indvar.dim.1, 1
  store i64 %invar.inc1, i64* %fusion.3.invar_address.dim.1, align 8
  br label %fusion.3.loop_header.dim.1

fusion.3.loop_exit.dim.1:                         ; preds = %fusion.3.loop_header.dim.1
  %invar.inc = add nuw nsw i64 %fusion.3.indvar.dim.0, 1
  store i64 %invar.inc, i64* %fusion.3.invar_address.dim.0, align 8
  br label %fusion.3.loop_header.dim.0

fusion.3.loop_exit.dim.0:                         ; preds = %fusion.3.loop_header.dim.0
  %21 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %22 = load i8*, i8** %21, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %23 = getelementptr inbounds i8, i8* %22, i64 384
  %dot.27 = bitcast i8* %23 to [2 x [2 x %complex128]]*
  %24 = bitcast [2 x [2 x %complex128]]* %dot.27 to %complex128*
  %25 = bitcast [2 x [2 x %complex128]]* %fusion.3 to %complex128*
  %26 = bitcast [2 x [2 x %complex128]]* %5 to %complex128*
  call void @__xla_cpu_runtime_EigenMatMulC128(i8* %run_options, %complex128* %24, %complex128* %25, %complex128* %26, i64 2, i64 2, i64 2, i32 1, i32 0)
  %27 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.9, i64 0, i64 1
  %28 = load i8*, i8** %27, align 8, !dereferenceable !3, !align !2
  %29 = bitcast i8* %28 to [2 x [2 x %complex128]]*
  %30 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %31 = load i8*, i8** %30, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %32 = getelementptr inbounds i8, i8* %31, i64 384
  %subtract.3 = bitcast i8* %32 to [2 x [2 x %complex128]]*
  store i64 0, i64* %subtract.3.invar_address.dim.0, align 8
  br label %subtract.3.loop_header.dim.0

subtract.3.loop_header.dim.0:                     ; preds = %subtract.3.loop_exit.dim.1, %fusion.3.loop_exit.dim.0
  %subtract.3.indvar.dim.0 = load i64, i64* %subtract.3.invar_address.dim.0, align 8
  %33 = icmp uge i64 %subtract.3.indvar.dim.0, 2
  br i1 %33, label %subtract.3.loop_exit.dim.0, label %subtract.3.loop_body.dim.0

subtract.3.loop_body.dim.0:                       ; preds = %subtract.3.loop_header.dim.0
  store i64 0, i64* %subtract.3.invar_address.dim.1, align 8
  br label %subtract.3.loop_header.dim.1

subtract.3.loop_header.dim.1:                     ; preds = %subtract.3.loop_body.dim.1, %subtract.3.loop_body.dim.0
  %subtract.3.indvar.dim.1 = load i64, i64* %subtract.3.invar_address.dim.1, align 8
  %34 = icmp uge i64 %subtract.3.indvar.dim.1, 2
  br i1 %34, label %subtract.3.loop_exit.dim.1, label %subtract.3.loop_body.dim.1

subtract.3.loop_body.dim.1:                       ; preds = %subtract.3.loop_header.dim.1
  %35 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %29, i64 0, i64 %subtract.3.indvar.dim.0, i64 %subtract.3.indvar.dim.1
  %36 = load %complex128, %complex128* %35, align 1, !alias.scope !15, !noalias !17
  %37 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %dot.27, i64 0, i64 %subtract.3.indvar.dim.0, i64 %subtract.3.indvar.dim.1
  %38 = load %complex128, %complex128* %37, align 1, !alias.scope !21, !noalias !22
  %39 = extractvalue %complex128 %36, 0
  %40 = extractvalue %complex128 %38, 0
  %41 = fsub reassoc nsz contract double %39, %40
  %42 = extractvalue %complex128 %36, 1
  %43 = extractvalue %complex128 %38, 1
  %44 = fsub reassoc nsz contract double %42, %43
  %45 = insertvalue %complex128 zeroinitializer, double %41, 0
  %46 = insertvalue %complex128 %45, double %44, 1
  %47 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %subtract.3, i64 0, i64 %subtract.3.indvar.dim.0, i64 %subtract.3.indvar.dim.1
  store %complex128 %46, %complex128* %47, align 1, !alias.scope !21, !noalias !23
  %invar.inc3 = add nuw nsw i64 %subtract.3.indvar.dim.1, 1
  store i64 %invar.inc3, i64* %subtract.3.invar_address.dim.1, align 8
  br label %subtract.3.loop_header.dim.1

subtract.3.loop_exit.dim.1:                       ; preds = %subtract.3.loop_header.dim.1
  %invar.inc2 = add nuw nsw i64 %subtract.3.indvar.dim.0, 1
  store i64 %invar.inc2, i64* %subtract.3.invar_address.dim.0, align 8
  br label %subtract.3.loop_header.dim.0

subtract.3.loop_exit.dim.0:                       ; preds = %subtract.3.loop_header.dim.0
  %48 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.9, i64 0, i64 0
  %49 = load i8*, i8** %48, align 8, !dereferenceable !24, !align !24
  %50 = bitcast i8* %49 to i32*
  %51 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %52 = load i8*, i8** %51, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %53 = getelementptr inbounds i8, i8* %52, i64 96
  %copy.41 = bitcast i8* %53 to i32*
  %54 = bitcast i32* %copy.41 to i8*
  %55 = bitcast i32* %50 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %54, i8* align 1 %55, i64 4, i1 false)
  %56 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %57 = load i8*, i8** %56, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.2 = bitcast i8* %57 to [1 x [1 x double]]*
  store i64 0, i64* %fusion.2.invar_address.dim.0, align 8
  br label %fusion.2.loop_header.dim.0

fusion.2.loop_header.dim.0:                       ; preds = %fusion.2.loop_exit.dim.1, %subtract.3.loop_exit.dim.0
  %fusion.2.indvar.dim.0 = load i64, i64* %fusion.2.invar_address.dim.0, align 8
  %58 = icmp uge i64 %fusion.2.indvar.dim.0, 1
  br i1 %58, label %fusion.2.loop_exit.dim.0, label %fusion.2.loop_body.dim.0

fusion.2.loop_body.dim.0:                         ; preds = %fusion.2.loop_header.dim.0
  store i64 0, i64* %fusion.2.invar_address.dim.1, align 8
  br label %fusion.2.loop_header.dim.1

fusion.2.loop_header.dim.1:                       ; preds = %fusion.2.loop_body.dim.1, %fusion.2.loop_body.dim.0
  %fusion.2.indvar.dim.1 = load i64, i64* %fusion.2.invar_address.dim.1, align 8
  %59 = icmp uge i64 %fusion.2.indvar.dim.1, 1
  br i1 %59, label %fusion.2.loop_exit.dim.1, label %fusion.2.loop_body.dim.1

fusion.2.loop_body.dim.1:                         ; preds = %fusion.2.loop_header.dim.1
  %60 = load i32, i32* %copy.41, align 4, !alias.scope !26, !noalias !27
  %61 = sext i32 %60 to i64
  %62 = icmp sge i64 0, %61
  %63 = select i1 %62, i64 0, i64 %61
  %64 = icmp sle i64 1, %63
  %dynamic-slice.75.start_idx0 = select i1 %64, i64 1, i64 %63
  %65 = load i32, i32* %copy.41, align 4, !alias.scope !26, !noalias !27
  %66 = sext i32 %65 to i64
  %67 = icmp sge i64 0, %66
  %68 = select i1 %67, i64 0, i64 %66
  %69 = icmp sle i64 1, %68
  %dynamic-slice.75.start_idx1 = select i1 %69, i64 1, i64 %68
  %70 = add i64 %dynamic-slice.75.start_idx0, %fusion.2.indvar.dim.0
  %71 = add i64 %dynamic-slice.75.start_idx1, %fusion.2.indvar.dim.1
  %72 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %subtract.3, i64 0, i64 %70, i64 %71
  %73 = load %complex128, %complex128* %72, align 1, !alias.scope !21, !noalias !23
  %74 = extractvalue %complex128 %73, 0
  %75 = call reassoc nsz contract double @llvm.sqrt.f64(double %74)
  %76 = getelementptr inbounds [1 x [1 x double]], [1 x [1 x double]]* %fusion.2, i64 0, i64 0, i64 0
  store double %75, double* %76, align 8, !alias.scope !29, !noalias !30
  %invar.inc5 = add nuw nsw i64 %fusion.2.indvar.dim.1, 1
  store i64 %invar.inc5, i64* %fusion.2.invar_address.dim.1, align 8
  br label %fusion.2.loop_header.dim.1

fusion.2.loop_exit.dim.1:                         ; preds = %fusion.2.loop_header.dim.1
  %invar.inc4 = add nuw nsw i64 %fusion.2.indvar.dim.0, 1
  store i64 %invar.inc4, i64* %fusion.2.invar_address.dim.0, align 8
  br label %fusion.2.loop_header.dim.0

fusion.2.loop_exit.dim.0:                         ; preds = %fusion.2.loop_header.dim.0
  %77 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.9, i64 0, i64 4
  %78 = load i8*, i8** %77, align 8, !dereferenceable !24, !align !24
  %79 = bitcast i8* %78 to [2 x [2 x i8]]*
  %80 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %81 = load i8*, i8** %80, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %82 = getelementptr inbounds i8, i8* %81, i64 512
  %fusion.1 = bitcast i8* %82 to [2 x [2 x %complex128]]*
  store i64 0, i64* %fusion.1.invar_address.dim.0, align 8
  br label %fusion.1.loop_header.dim.0

fusion.1.loop_header.dim.0:                       ; preds = %fusion.1.loop_exit.dim.1, %fusion.2.loop_exit.dim.0
  %fusion.1.indvar.dim.0 = load i64, i64* %fusion.1.invar_address.dim.0, align 8
  %83 = icmp uge i64 %fusion.1.indvar.dim.0, 2
  br i1 %83, label %fusion.1.loop_exit.dim.0, label %fusion.1.loop_body.dim.0

fusion.1.loop_body.dim.0:                         ; preds = %fusion.1.loop_header.dim.0
  store i64 0, i64* %fusion.1.invar_address.dim.1, align 8
  br label %fusion.1.loop_header.dim.1

fusion.1.loop_header.dim.1:                       ; preds = %fusion.1.loop_body.dim.1, %fusion.1.loop_body.dim.0
  %fusion.1.indvar.dim.1 = load i64, i64* %fusion.1.invar_address.dim.1, align 8
  %84 = icmp uge i64 %fusion.1.indvar.dim.1, 2
  br i1 %84, label %fusion.1.loop_exit.dim.1, label %fusion.1.loop_body.dim.1

fusion.1.loop_body.dim.1:                         ; preds = %fusion.1.loop_header.dim.1
  %85 = getelementptr inbounds [2 x [2 x i8]], [2 x [2 x i8]]* %79, i64 0, i64 %fusion.1.indvar.dim.0, i64 %fusion.1.indvar.dim.1
  %86 = load i8, i8* %85, align 1, !alias.scope !31, !noalias !32
  %87 = mul nuw nsw i64 %fusion.1.indvar.dim.1, 1
  %88 = add nuw nsw i64 0, %87
  %89 = trunc i64 %88 to i32
  %90 = load i32, i32* %copy.41, align 4, !alias.scope !26, !noalias !27
  %91 = icmp eq i32 %89, %90
  %92 = zext i1 %91 to i8
  %93 = and i8 %86, %92
  %94 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %subtract.3, i64 0, i64 %fusion.1.indvar.dim.0, i64 %fusion.1.indvar.dim.1
  %95 = load %complex128, %complex128* %94, align 1, !alias.scope !21, !noalias !23
  %96 = getelementptr inbounds [1 x [1 x double]], [1 x [1 x double]]* %fusion.2, i64 0, i64 0, i64 0
  %97 = load double, double* %96, align 8, !alias.scope !29, !noalias !30
  %constant.1454 = load double, double* getelementptr inbounds ([1 x [1 x double]], [1 x [1 x double]]* bitcast ([8 x i8]* @10 to [1 x [1 x double]]*), i64 0, i64 0, i64 0), align 8
  %98 = insertvalue %complex128 zeroinitializer, double %97, 0
  %99 = insertvalue %complex128 %98, double %constant.1454, 1
  %100 = extractvalue %complex128 %95, 0
  %101 = extractvalue %complex128 %95, 1
  %102 = extractvalue %complex128 %99, 0
  %103 = extractvalue %complex128 %99, 1
  %104 = fdiv reassoc nsz contract double %102, %103
  %105 = fmul reassoc nsz contract double %104, %102
  %106 = fadd reassoc nsz contract double %103, %105
  %107 = fdiv reassoc nsz contract double %103, %102
  %108 = fmul reassoc nsz contract double %107, %103
  %109 = fadd reassoc nsz contract double %102, %108
  %110 = call reassoc nsz contract double @llvm.fabs.f64(double %102)
  %111 = call reassoc nsz contract double @llvm.fabs.f64(double %103)
  %112 = fcmp reassoc nsz contract olt double %110, %111
  %113 = fmul reassoc nsz contract double %104, %100
  %114 = fadd reassoc nsz contract double %113, %101
  %115 = fdiv reassoc nsz contract double %114, %106
  %116 = fmul reassoc nsz contract double %107, %101
  %117 = fadd reassoc nsz contract double %116, %100
  %118 = fdiv reassoc nsz contract double %117, %109
  %119 = select reassoc nsz contract i1 %112, double %115, double %118
  %120 = fmul reassoc nsz contract double %104, %101
  %121 = fsub reassoc nsz contract double %120, %100
  %122 = fdiv reassoc nsz contract double %121, %106
  %123 = fmul reassoc nsz contract double %107, %100
  %124 = fsub reassoc nsz contract double %101, %123
  %125 = fdiv reassoc nsz contract double %124, %109
  %126 = select reassoc nsz contract i1 %112, double %122, double %125
  %127 = insertvalue %complex128 zeroinitializer, double %119, 0
  %128 = insertvalue %complex128 %127, double %126, 1
  %129 = fcmp reassoc nsz contract oeq double %102, 0.000000e+00
  %130 = fcmp reassoc nsz contract oeq double %103, 0.000000e+00
  %131 = and i1 %129, %130
  %132 = fcmp reassoc nsz contract one double %100, 0.000000e+00
  %133 = sub i1 false, %132
  %134 = fcmp reassoc nsz contract one double %101, 0.000000e+00
  %135 = sub i1 false, %134
  %136 = or i1 %133, %135
  %137 = and i1 %131, %136
  %138 = call reassoc nsz contract double @llvm.copysign.f64(double 0x7FF0000000000000, double %100)
  %139 = fmul reassoc nsz contract double %138, %100
  %140 = fmul reassoc nsz contract double %138, %101
  %141 = insertvalue %complex128 zeroinitializer, double %139, 0
  %142 = insertvalue %complex128 %141, double %140, 1
  %143 = call reassoc nsz contract double @llvm.fabs.f64(double %102)
  %144 = fcmp reassoc nsz contract one double %143, 0x7FF0000000000000
  %145 = call reassoc nsz contract double @llvm.fabs.f64(double %103)
  %146 = fcmp reassoc nsz contract one double %145, 0x7FF0000000000000
  %147 = fcmp reassoc nsz contract oeq double %100, 0x7FF0000000000000
  %148 = fcmp reassoc nsz contract oeq double %101, 0x7FF0000000000000
  %149 = or i1 %147, %148
  %150 = and i1 %144, %146
  %151 = and i1 %149, %150
  %152 = fcmp reassoc nsz contract oeq double %100, 0x7FF0000000000000
  %153 = select reassoc nsz contract i1 %152, double 1.000000e+00, double 0.000000e+00
  %154 = call reassoc nsz contract double @llvm.copysign.f64(double %153, double %100)
  %155 = fcmp reassoc nsz contract oeq double %101, 0x7FF0000000000000
  %156 = select reassoc nsz contract i1 %155, double 1.000000e+00, double 0.000000e+00
  %157 = call reassoc nsz contract double @llvm.copysign.f64(double %156, double %101)
  %158 = fmul reassoc nsz contract double %154, %102
  %159 = fmul reassoc nsz contract double %157, %103
  %160 = fadd reassoc nsz contract double %158, %159
  %161 = fmul reassoc nsz contract double 0x7FF0000000000000, %160
  %162 = fmul reassoc nsz contract double %157, %102
  %163 = fmul reassoc nsz contract double %154, %103
  %164 = fsub reassoc nsz contract double %162, %163
  %165 = fmul reassoc nsz contract double 0x7FF0000000000000, %164
  %166 = insertvalue %complex128 zeroinitializer, double %161, 0
  %167 = insertvalue %complex128 %166, double %165, 1
  %168 = call reassoc nsz contract double @llvm.fabs.f64(double %100)
  %169 = fcmp reassoc nsz contract one double %168, 0x7FF0000000000000
  %170 = call reassoc nsz contract double @llvm.fabs.f64(double %101)
  %171 = fcmp reassoc nsz contract one double %170, 0x7FF0000000000000
  %172 = fcmp reassoc nsz contract oeq double %102, 0x7FF0000000000000
  %173 = fcmp reassoc nsz contract oeq double %103, 0x7FF0000000000000
  %174 = or i1 %172, %173
  %175 = and i1 %169, %171
  %176 = and i1 %174, %175
  %177 = fcmp reassoc nsz contract oeq double %102, 0x7FF0000000000000
  %178 = select reassoc nsz contract i1 %177, double 1.000000e+00, double 0.000000e+00
  %179 = call reassoc nsz contract double @llvm.copysign.f64(double %178, double %102)
  %180 = fcmp reassoc nsz contract oeq double %103, 0x7FF0000000000000
  %181 = select reassoc nsz contract i1 %180, double 1.000000e+00, double 0.000000e+00
  %182 = call reassoc nsz contract double @llvm.copysign.f64(double %181, double %103)
  %183 = fmul reassoc nsz contract double %100, %179
  %184 = fmul reassoc nsz contract double %101, %182
  %185 = fadd reassoc nsz contract double %183, %184
  %186 = fmul reassoc nsz contract double 0.000000e+00, %185
  %187 = fmul reassoc nsz contract double %101, %179
  %188 = fmul reassoc nsz contract double %100, %182
  %189 = fsub reassoc nsz contract double %187, %188
  %190 = fmul reassoc nsz contract double 0.000000e+00, %189
  %191 = insertvalue %complex128 zeroinitializer, double %186, 0
  %192 = insertvalue %complex128 %191, double %190, 1
  %193 = fcmp reassoc nsz contract uno double %119, 0.000000e+00
  %194 = fcmp reassoc nsz contract uno double %126, 0.000000e+00
  %195 = and i1 %193, %194
  %196 = select i1 %176, %complex128 %192, %complex128 %128
  %197 = select i1 %151, %complex128 %167, %complex128 %196
  %198 = select i1 %137, %complex128 %142, %complex128 %197
  %199 = select i1 %195, %complex128 %198, %complex128 %128
  %constant.1453 = load %complex128, %complex128* bitcast ([16 x i8]* @11 to %complex128*), align 1
  %200 = trunc i8 %93 to i1
  %201 = select i1 %200, %complex128 %199, %complex128 %constant.1453
  %202 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %5, i64 0, i64 %fusion.1.indvar.dim.0, i64 %fusion.1.indvar.dim.1
  %203 = load %complex128, %complex128* %202, align 1, !alias.scope !4, !noalias !7
  %204 = extractvalue %complex128 %201, 0
  %205 = extractvalue %complex128 %203, 0
  %206 = fadd reassoc nsz contract double %204, %205
  %207 = extractvalue %complex128 %201, 1
  %208 = extractvalue %complex128 %203, 1
  %209 = fadd reassoc nsz contract double %207, %208
  %210 = insertvalue %complex128 zeroinitializer, double %206, 0
  %211 = insertvalue %complex128 %210, double %209, 1
  %212 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %fusion.1, i64 0, i64 %fusion.1.indvar.dim.0, i64 %fusion.1.indvar.dim.1
  store %complex128 %211, %complex128* %212, align 1, !alias.scope !4, !noalias !33
  %invar.inc7 = add nuw nsw i64 %fusion.1.indvar.dim.1, 1
  store i64 %invar.inc7, i64* %fusion.1.invar_address.dim.1, align 8
  br label %fusion.1.loop_header.dim.1

fusion.1.loop_exit.dim.1:                         ; preds = %fusion.1.loop_header.dim.1
  %invar.inc6 = add nuw nsw i64 %fusion.1.indvar.dim.0, 1
  store i64 %invar.inc6, i64* %fusion.1.invar_address.dim.0, align 8
  br label %fusion.1.loop_header.dim.0

fusion.1.loop_exit.dim.0:                         ; preds = %fusion.1.loop_header.dim.0
  %213 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.9, i64 0, i64 3
  %214 = load i8*, i8** %213, align 8, !dereferenceable !34, !align !34
  %215 = bitcast i8* %214 to [1 x [1 x i8]]*
  %216 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %217 = load i8*, i8** %216, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %218 = getelementptr inbounds i8, i8* %217, i64 112
  %fusion = bitcast i8* %218 to [1 x [1 x i8]]*
  store i64 0, i64* %fusion.invar_address.dim.0, align 8
  br label %fusion.loop_header.dim.0

fusion.loop_header.dim.0:                         ; preds = %fusion.loop_exit.dim.1, %fusion.1.loop_exit.dim.0
  %fusion.indvar.dim.0 = load i64, i64* %fusion.invar_address.dim.0, align 8
  %219 = icmp uge i64 %fusion.indvar.dim.0, 1
  br i1 %219, label %fusion.loop_exit.dim.0, label %fusion.loop_body.dim.0

fusion.loop_body.dim.0:                           ; preds = %fusion.loop_header.dim.0
  store i64 0, i64* %fusion.invar_address.dim.1, align 8
  br label %fusion.loop_header.dim.1

fusion.loop_header.dim.1:                         ; preds = %fusion.loop_body.dim.1, %fusion.loop_body.dim.0
  %fusion.indvar.dim.1 = load i64, i64* %fusion.invar_address.dim.1, align 8
  %220 = icmp uge i64 %fusion.indvar.dim.1, 1
  br i1 %220, label %fusion.loop_exit.dim.1, label %fusion.loop_body.dim.1

fusion.loop_body.dim.1:                           ; preds = %fusion.loop_header.dim.1
  %221 = getelementptr inbounds [1 x [1 x i8]], [1 x [1 x i8]]* %215, i64 0, i64 0, i64 0
  %222 = load i8, i8* %221, align 1, !alias.scope !35, !noalias !29
  %223 = getelementptr inbounds [1 x [1 x double]], [1 x [1 x double]]* %fusion.2, i64 0, i64 0, i64 0
  %224 = load double, double* %223, align 8, !alias.scope !29, !noalias !30
  %225 = getelementptr inbounds [1 x [1 x double]], [1 x [1 x double]]* %fusion.2, i64 0, i64 0, i64 0
  %226 = load double, double* %225, align 8, !alias.scope !29, !noalias !30
  %compare.212 = fcmp reassoc nsz contract une double %224, %226
  %227 = zext i1 %compare.212 to i8
  %228 = or i8 %222, %227
  %229 = getelementptr inbounds [1 x [1 x i8]], [1 x [1 x i8]]* %fusion, i64 0, i64 0, i64 0
  store i8 %228, i8* %229, align 1, !alias.scope !35, !noalias !36
  %invar.inc9 = add nuw nsw i64 %fusion.indvar.dim.1, 1
  store i64 %invar.inc9, i64* %fusion.invar_address.dim.1, align 8
  br label %fusion.loop_header.dim.1

fusion.loop_exit.dim.1:                           ; preds = %fusion.loop_header.dim.1
  %invar.inc8 = add nuw nsw i64 %fusion.indvar.dim.0, 1
  store i64 %invar.inc8, i64* %fusion.invar_address.dim.0, align 8
  br label %fusion.loop_header.dim.0

fusion.loop_exit.dim.0:                           ; preds = %fusion.loop_header.dim.0
  %230 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %231 = load i8*, i8** %230, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %add.56 = bitcast i8* %231 to i32*
  %232 = load i32, i32* %copy.41, align 4, !alias.scope !26, !noalias !27
  %233 = load i32, i32* bitcast ([4 x i8]* @4 to i32*), align 4, !alias.scope !37, !noalias !38
  %234 = add i32 %232, %233
  store i32 %234, i32* %add.56, align 4, !alias.scope !39, !noalias !40
  %235 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %236 = load i8*, i8** %235, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %237 = getelementptr inbounds i8, i8* %236, i64 864
  %tuple.307 = bitcast i8* %237 to [5 x i8*]*
  %238 = bitcast i32* %add.56 to i8*
  %239 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.307, i64 0, i64 0
  store i8* %238, i8** %239, align 8, !alias.scope !41, !noalias !42
  %240 = bitcast [2 x [2 x %complex128]]* %29 to i8*
  %241 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.307, i64 0, i64 1
  store i8* %240, i8** %241, align 8, !alias.scope !41, !noalias !42
  %242 = bitcast [2 x [2 x %complex128]]* %fusion.1 to i8*
  %243 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.307, i64 0, i64 2
  store i8* %242, i8** %243, align 8, !alias.scope !41, !noalias !42
  %244 = bitcast [1 x [1 x i8]]* %fusion to i8*
  %245 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.307, i64 0, i64 3
  store i8* %244, i8** %245, align 8, !alias.scope !41, !noalias !42
  %246 = bitcast [2 x [2 x i8]]* %79 to i8*
  %247 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.307, i64 0, i64 4
  store i8* %246, i8** %247, align 8, !alias.scope !41, !noalias !42
  ret void
}

; Function Attrs: argmemonly nounwind
declare void @__xla_cpu_runtime_EigenMatMulC128(i8*, %complex128*, %complex128*, %complex128*, i64, i64, i64, i32, i32) #1

; Function Attrs: argmemonly nofree nosync nounwind willreturn
declare void @llvm.memcpy.p0i8.p0i8.i64(i8* noalias nocapture writeonly, i8* noalias nocapture readonly, i64, i1 immarg) #2

; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
declare double @llvm.sqrt.f64(double) #3

; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
declare double @llvm.fabs.f64(double) #3

; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
declare double @llvm.copysign.f64(double, double) #3

; Function Attrs: uwtable
define internal void @wide.unblocked_condition.52.(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 864
  %wide_param.8 = bitcast i8* %2 to [5 x i8*]*
  %3 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.8, i64 0, i64 0
  %4 = load i8*, i8** %3, align 8, !dereferenceable !24, !align !24
  %5 = bitcast i8* %4 to i32*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %compare.59 = getelementptr inbounds i8, i8* %7, i64 96
  %8 = load i32, i32* %5, align 4, !alias.scope !39, !noalias !43
  %9 = load i32, i32* bitcast ([4 x i8]* @6 to i32*), align 4, !alias.scope !46, !noalias !47
  %10 = icmp slt i32 %8, %9
  %11 = zext i1 %10 to i8
  store i8 %11, i8* %compare.59, align 1, !alias.scope !48, !noalias !49
  ret void
}

; Function Attrs: uwtable
define internal void @wide.body_computation__12.149.clone.1.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 832
  %wide_param.29 = bitcast i8* %2 to [3 x i8*]*
  %3 = getelementptr inbounds [3 x i8*], [3 x i8*]* %wide_param.29, i64 0, i64 2
  %4 = load i8*, i8** %3, align 8, !dereferenceable !50, !align !50
  %5 = bitcast i8* %4 to double*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %8 = getelementptr inbounds i8, i8* %7, i64 736
  %copy.11 = bitcast i8* %8 to double*
  %9 = bitcast double* %copy.11 to i8*
  %10 = bitcast double* %5 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %9, i8* align 1 %10, i64 8, i1 false)
  %11 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %12 = load i8*, i8** %11, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %copy.63 = getelementptr inbounds i8, i8* %12, i64 720
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %copy.63, i8* align 1 getelementptr inbounds ([1 x i8], [1 x i8]* @7, i32 0, i32 0), i64 1, i1 false)
  %13 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %14 = load i8*, i8** %13, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %15 = getelementptr inbounds i8, i8* %14, i64 832
  %tuple.297 = bitcast i8* %15 to [3 x i8*]*
  %16 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.297, i64 0, i64 0
  store i8* %copy.63, i8** %16, align 8, !alias.scope !51, !noalias !53
  %17 = bitcast double* %copy.11 to i8*
  %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.297, i64 0, i64 1
  store i8* %17, i8** %18, align 8, !alias.scope !51, !noalias !53
  %19 = bitcast double* %5 to i8*
  %20 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.297, i64 0, i64 2
  store i8* %19, i8** %20, align 8, !alias.scope !51, !noalias !53
  ret void
}

; Function Attrs: uwtable
define internal void @wide.cond_computation__12.182.clone.1.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 832
  %wide_param.28 = bitcast i8* %2 to [3 x i8*]*
  %3 = getelementptr inbounds [3 x i8*], [3 x i8*]* %wide_param.28, i64 0, i64 0
  %4 = load i8*, i8** %3, align 8, !dereferenceable !34, !align !34
  ret void
}

; Function Attrs: uwtable
define internal void @wide.body_computation__14.216.clone.1(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 800
  %wide_param.21 = bitcast i8* %2 to [3 x i8*]*
  %3 = getelementptr inbounds [3 x i8*], [3 x i8*]* %wide_param.21, i64 0, i64 2
  %4 = load i8*, i8** %3, align 8, !dereferenceable !50, !align !50
  %5 = bitcast i8* %4 to double*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %8 = getelementptr inbounds i8, i8* %7, i64 736
  %copy.5 = bitcast i8* %8 to double*
  %9 = bitcast double* %copy.5 to i8*
  %10 = bitcast double* %5 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %9, i8* align 1 %10, i64 8, i1 false)
  %11 = getelementptr inbounds [3 x i8*], [3 x i8*]* %wide_param.21, i64 0, i64 0
  %12 = load i8*, i8** %11, align 8, !dereferenceable !50, !align !50
  %13 = bitcast i8* %12 to i64*
  %14 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %15 = load i8*, i8** %14, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %16 = getelementptr inbounds i8, i8* %15, i64 800
  %tuple.294 = bitcast i8* %16 to [3 x i8*]*
  %17 = bitcast i64* %13 to i8*
  %18 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.294, i64 0, i64 0
  store i8* %17, i8** %18, align 8, !alias.scope !57, !noalias !59
  %19 = bitcast double* %copy.5 to i8*
  %20 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.294, i64 0, i64 1
  store i8* %19, i8** %20, align 8, !alias.scope !57, !noalias !59
  %21 = bitcast double* %5 to i8*
  %22 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.294, i64 0, i64 2
  store i8* %21, i8** %22, align 8, !alias.scope !57, !noalias !59
  ret void
}

; Function Attrs: uwtable
define internal void @wide.cond_computation__14.249.clone.1(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 800
  %wide_param.20 = bitcast i8* %2 to [3 x i8*]*
  %3 = getelementptr inbounds [3 x i8*], [3 x i8*]* %wide_param.20, i64 0, i64 0
  %4 = load i8*, i8** %3, align 8, !dereferenceable !50, !align !50
  %5 = bitcast i8* %4 to i64*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %compare.101 = getelementptr inbounds i8, i8* %7, i64 592
  %8 = load i64, i64* %5, align 8, !alias.scope !61, !noalias !62
  %9 = load i64, i64* bitcast ([8 x i8]* @2 to i64*), align 8, !alias.scope !65, !noalias !66
  %10 = icmp slt i64 %8, %9
  %11 = zext i1 %10 to i8
  store i8 %11, i8* %compare.101, align 1, !alias.scope !67, !noalias !68
  ret void
}

; Function Attrs: uwtable
define internal void @wide.body_computation__13.259.clone.1.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %add.125.invar_address.dim.0 = alloca i64, align 8
  %dot_acc = alloca double, align 8
  %dot.130.inner.invar_address = alloca i64, align 8
  %imag.72.invar_address.dim.0 = alloca i64, align 8
  %subtract.11.invar_address.dim.0 = alloca i64, align 8
  %accum_address4 = alloca %complex128, align 8
  %dot.76.invar_address.reduction = alloca i64, align 8
  %dot.76.invar_address.lhs.0 = alloca i64, align 8
  %accum_address = alloca %complex128, align 8
  %dot.75.invar_address.reduction = alloca i64, align 8
  %dot.75.invar_address.lhs.1 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 960
  %wide_param.35 = bitcast i8* %2 to [6 x i8*]*
  %3 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 2
  %4 = load i8*, i8** %3, align 8, !dereferenceable !25, !align !2
  %5 = bitcast i8* %4 to [3 x %complex128]*
  %6 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 5
  %7 = load i8*, i8** %6, align 8, !dereferenceable !69, !align !2
  %8 = bitcast i8* %7 to [3 x [3 x %complex128]]*
  %9 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %10 = load i8*, i8** %9, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %11 = getelementptr inbounds i8, i8* %10, i64 528
  %dot.75 = bitcast i8* %11 to [3 x %complex128]*
  store i64 0, i64* %dot.75.invar_address.lhs.1, align 8
  br label %dot.75.loop_header.lhs.1

dot.75.loop_header.lhs.1:                         ; preds = %dot.75.loop_exit.reduction, %entry
  %dot.75.indvar.lhs.1 = load i64, i64* %dot.75.invar_address.lhs.1, align 8
  %12 = icmp uge i64 %dot.75.indvar.lhs.1, 3
  br i1 %12, label %dot.75.loop_exit.lhs.1, label %dot.75.loop_body.lhs.1

dot.75.loop_body.lhs.1:                           ; preds = %dot.75.loop_header.lhs.1
  store i64 0, i64* %dot.75.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address, align 1
  br label %dot.75.loop_header.reduction

dot.75.loop_header.reduction:                     ; preds = %dot.75.loop_body.reduction, %dot.75.loop_body.lhs.1
  %dot.75.indvar.reduction = load i64, i64* %dot.75.invar_address.reduction, align 8
  %13 = icmp uge i64 %dot.75.indvar.reduction, 3
  br i1 %13, label %dot.75.loop_exit.reduction, label %dot.75.loop_body.reduction

dot.75.loop_body.reduction:                       ; preds = %dot.75.loop_header.reduction
  %14 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %8, i64 0, i64 %dot.75.indvar.reduction, i64 %dot.75.indvar.lhs.1
  %15 = load %complex128, %complex128* %14, align 1, !alias.scope !70, !noalias !72
  %16 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %5, i64 0, i64 %dot.75.indvar.reduction
  %17 = load %complex128, %complex128* %16, align 1, !alias.scope !79, !noalias !80
  %18 = load %complex128, %complex128* %accum_address, align 1
  %19 = extractvalue %complex128 %15, 0
  %20 = extractvalue %complex128 %17, 0
  %21 = fmul reassoc nsz contract double %19, %20
  %22 = extractvalue %complex128 %15, 1
  %23 = extractvalue %complex128 %17, 1
  %24 = fmul reassoc nsz contract double %22, %23
  %25 = fsub reassoc nsz contract double %21, %24
  %26 = extractvalue %complex128 %15, 0
  %27 = extractvalue %complex128 %17, 1
  %28 = fmul reassoc nsz contract double %26, %27
  %29 = extractvalue %complex128 %15, 1
  %30 = extractvalue %complex128 %17, 0
  %31 = fmul reassoc nsz contract double %29, %30
  %32 = fadd reassoc nsz contract double %28, %31
  %33 = extractvalue %complex128 %18, 0
  %34 = fadd reassoc nsz contract double %33, %25
  %35 = insertvalue %complex128 %18, double %34, 0
  %36 = extractvalue %complex128 %18, 1
  %37 = fadd reassoc nsz contract double %36, %32
  %38 = insertvalue %complex128 %35, double %37, 1
  store %complex128 %38, %complex128* %accum_address, align 1
  %invar.inc1 = add nuw nsw i64 %dot.75.indvar.reduction, 1
  store i64 %invar.inc1, i64* %dot.75.invar_address.reduction, align 8
  br label %dot.75.loop_header.reduction

dot.75.loop_exit.reduction:                       ; preds = %dot.75.loop_header.reduction
  %39 = load %complex128, %complex128* %accum_address, align 1
  %40 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.75, i64 0, i64 %dot.75.indvar.lhs.1
  store %complex128 %39, %complex128* %40, align 1, !alias.scope !82, !noalias !83
  %invar.inc = add nuw nsw i64 %dot.75.indvar.lhs.1, 1
  store i64 %invar.inc, i64* %dot.75.invar_address.lhs.1, align 8
  br label %dot.75.loop_header.lhs.1

dot.75.loop_exit.lhs.1:                           ; preds = %dot.75.loop_header.lhs.1
  %41 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 0
  %42 = load i8*, i8** %41, align 8, !dereferenceable !69, !align !2
  %43 = bitcast i8* %42 to [3 x [3 x %complex128]]*
  %44 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %45 = load i8*, i8** %44, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %46 = getelementptr inbounds i8, i8* %45, i64 576
  %dot.76 = bitcast i8* %46 to [3 x %complex128]*
  store i64 0, i64* %dot.76.invar_address.lhs.0, align 8
  br label %dot.76.loop_header.lhs.0

dot.76.loop_header.lhs.0:                         ; preds = %dot.76.loop_exit.reduction, %dot.75.loop_exit.lhs.1
  %dot.76.indvar.lhs.0 = load i64, i64* %dot.76.invar_address.lhs.0, align 8
  %47 = icmp uge i64 %dot.76.indvar.lhs.0, 3
  br i1 %47, label %dot.76.loop_exit.lhs.0, label %dot.76.loop_body.lhs.0

dot.76.loop_body.lhs.0:                           ; preds = %dot.76.loop_header.lhs.0
  store i64 0, i64* %dot.76.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address4, align 1
  br label %dot.76.loop_header.reduction

dot.76.loop_header.reduction:                     ; preds = %dot.76.loop_body.reduction, %dot.76.loop_body.lhs.0
  %dot.76.indvar.reduction = load i64, i64* %dot.76.invar_address.reduction, align 8
  %48 = icmp uge i64 %dot.76.indvar.reduction, 3
  br i1 %48, label %dot.76.loop_exit.reduction, label %dot.76.loop_body.reduction

dot.76.loop_body.reduction:                       ; preds = %dot.76.loop_header.reduction
  %49 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %43, i64 0, i64 %dot.76.indvar.lhs.0, i64 %dot.76.indvar.reduction
  %50 = load %complex128, %complex128* %49, align 1, !alias.scope !84, !noalias !85
  %51 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.75, i64 0, i64 %dot.76.indvar.reduction
  %52 = load %complex128, %complex128* %51, align 1, !alias.scope !82, !noalias !83
  %53 = load %complex128, %complex128* %accum_address4, align 1
  %54 = extractvalue %complex128 %50, 0
  %55 = extractvalue %complex128 %52, 0
  %56 = fmul reassoc nsz contract double %54, %55
  %57 = extractvalue %complex128 %50, 1
  %58 = extractvalue %complex128 %52, 1
  %59 = fmul reassoc nsz contract double %57, %58
  %60 = fsub reassoc nsz contract double %56, %59
  %61 = extractvalue %complex128 %50, 0
  %62 = extractvalue %complex128 %52, 1
  %63 = fmul reassoc nsz contract double %61, %62
  %64 = extractvalue %complex128 %50, 1
  %65 = extractvalue %complex128 %52, 0
  %66 = fmul reassoc nsz contract double %64, %65
  %67 = fadd reassoc nsz contract double %63, %66
  %68 = extractvalue %complex128 %53, 0
  %69 = fadd reassoc nsz contract double %68, %60
  %70 = insertvalue %complex128 %53, double %69, 0
  %71 = extractvalue %complex128 %53, 1
  %72 = fadd reassoc nsz contract double %71, %67
  %73 = insertvalue %complex128 %70, double %72, 1
  store %complex128 %73, %complex128* %accum_address4, align 1
  %invar.inc3 = add nuw nsw i64 %dot.76.indvar.reduction, 1
  store i64 %invar.inc3, i64* %dot.76.invar_address.reduction, align 8
  br label %dot.76.loop_header.reduction, !llvm.loop !86

dot.76.loop_exit.reduction:                       ; preds = %dot.76.loop_header.reduction
  %74 = load %complex128, %complex128* %accum_address4, align 1
  %75 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.76, i64 0, i64 %dot.76.indvar.lhs.0
  store %complex128 %74, %complex128* %75, align 1, !alias.scope !88, !noalias !89
  %invar.inc2 = add nuw nsw i64 %dot.76.indvar.lhs.0, 1
  store i64 %invar.inc2, i64* %dot.76.invar_address.lhs.0, align 8
  br label %dot.76.loop_header.lhs.0

dot.76.loop_exit.lhs.0:                           ; preds = %dot.76.loop_header.lhs.0
  %76 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %77 = load i8*, i8** %76, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %78 = getelementptr inbounds i8, i8* %77, i64 480
  %subtract.11 = bitcast i8* %78 to [3 x %complex128]*
  store i64 0, i64* %subtract.11.invar_address.dim.0, align 8
  br label %subtract.11.loop_header.dim.0

subtract.11.loop_header.dim.0:                    ; preds = %subtract.11.loop_body.dim.0, %dot.76.loop_exit.lhs.0
  %subtract.11.indvar.dim.0 = load i64, i64* %subtract.11.invar_address.dim.0, align 8
  %79 = icmp uge i64 %subtract.11.indvar.dim.0, 3
  br i1 %79, label %subtract.11.loop_exit.dim.0, label %subtract.11.loop_body.dim.0

subtract.11.loop_body.dim.0:                      ; preds = %subtract.11.loop_header.dim.0
  %80 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %5, i64 0, i64 %subtract.11.indvar.dim.0
  %81 = load %complex128, %complex128* %80, align 1, !alias.scope !79, !noalias !80
  %82 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.76, i64 0, i64 %subtract.11.indvar.dim.0
  %83 = load %complex128, %complex128* %82, align 1, !alias.scope !88, !noalias !89
  %84 = extractvalue %complex128 %81, 0
  %85 = extractvalue %complex128 %83, 0
  %86 = fsub reassoc nsz contract double %84, %85
  %87 = extractvalue %complex128 %81, 1
  %88 = extractvalue %complex128 %83, 1
  %89 = fsub reassoc nsz contract double %87, %88
  %90 = insertvalue %complex128 zeroinitializer, double %86, 0
  %91 = insertvalue %complex128 %90, double %89, 1
  %92 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.11, i64 0, i64 %subtract.11.indvar.dim.0
  store %complex128 %91, %complex128* %92, align 1, !alias.scope !79, !noalias !90
  %invar.inc5 = add nuw nsw i64 %subtract.11.indvar.dim.0, 1
  store i64 %invar.inc5, i64* %subtract.11.invar_address.dim.0, align 8
  br label %subtract.11.loop_header.dim.0

subtract.11.loop_exit.dim.0:                      ; preds = %subtract.11.loop_header.dim.0
  %93 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %94 = load i8*, i8** %93, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %95 = getelementptr inbounds i8, i8* %94, i64 576
  %imag.72 = bitcast i8* %95 to [3 x double]*
  store i64 0, i64* %imag.72.invar_address.dim.0, align 8
  br label %imag.72.loop_header.dim.0

imag.72.loop_header.dim.0:                        ; preds = %imag.72.loop_body.dim.0, %subtract.11.loop_exit.dim.0
  %imag.72.indvar.dim.0 = load i64, i64* %imag.72.invar_address.dim.0, align 8
  %96 = icmp uge i64 %imag.72.indvar.dim.0, 3
  br i1 %96, label %imag.72.loop_exit.dim.0, label %imag.72.loop_body.dim.0

imag.72.loop_body.dim.0:                          ; preds = %imag.72.loop_header.dim.0
  %97 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.11, i64 0, i64 %imag.72.indvar.dim.0
  %98 = load %complex128, %complex128* %97, align 1, !alias.scope !79, !noalias !90
  %99 = extractvalue %complex128 %98, 1
  %100 = getelementptr inbounds [3 x double], [3 x double]* %imag.72, i64 0, i64 %imag.72.indvar.dim.0
  store double %99, double* %100, align 8, !alias.scope !92, !noalias !93
  %invar.inc6 = add nuw nsw i64 %imag.72.indvar.dim.0, 1
  store i64 %invar.inc6, i64* %imag.72.invar_address.dim.0, align 8
  br label %imag.72.loop_header.dim.0

imag.72.loop_exit.dim.0:                          ; preds = %imag.72.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc, align 8
  %101 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %102 = load i8*, i8** %101, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %103 = getelementptr inbounds i8, i8* %102, i64 608
  %fusion.6 = bitcast i8* %103 to double*
  store i64 0, i64* %dot.130.inner.invar_address, align 8
  br label %dot.130.inner.loop_header

dot.130.inner.loop_header:                        ; preds = %dot.130.inner.loop_body, %imag.72.loop_exit.dim.0
  %dot.130.inner.indvar = load i64, i64* %dot.130.inner.invar_address, align 8
  %104 = icmp uge i64 %dot.130.inner.indvar, 3
  br i1 %104, label %dot.130.inner.loop_exit, label %dot.130.inner.loop_body

dot.130.inner.loop_body:                          ; preds = %dot.130.inner.loop_header
  %105 = load double, double* %dot_acc, align 8
  %106 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.11, i64 0, i64 %dot.130.inner.indvar
  %107 = load %complex128, %complex128* %106, align 1, !alias.scope !79, !noalias !90
  %108 = extractvalue %complex128 %107, 0
  %109 = fmul reassoc nsz contract double %108, %108
  %110 = fadd reassoc nsz contract double %105, %109
  store double %110, double* %dot_acc, align 8
  %invar.inc7 = add nuw nsw i64 %dot.130.inner.indvar, 1
  store i64 %invar.inc7, i64* %dot.130.inner.invar_address, align 8
  br label %dot.130.inner.loop_header

dot.130.inner.loop_exit:                          ; preds = %dot.130.inner.loop_header
  %111 = load double, double* %dot_acc, align 8
  store double %111, double* %fusion.6, align 8, !alias.scope !94, !noalias !95
  %112 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %113 = load i8*, i8** %112, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %114 = getelementptr inbounds i8, i8* %113, i64 608
  %fusion.5 = bitcast i8* %114 to double*
  %115 = bitcast [3 x double]* %imag.72 to double*
  %116 = bitcast [3 x double]* %imag.72 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %115, double* %116, double* %fusion.6, double* %fusion.5)
  %117 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %118 = load i8*, i8** %117, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %119 = getelementptr inbounds i8, i8* %118, i64 608
  %fusion.4 = bitcast i8* %119 to double*
  %120 = load double, double* %fusion.5, align 8, !alias.scope !94, !noalias !92
  %121 = call reassoc nsz contract double @llvm.sqrt.f64(double %120)
  %constant.1457 = load double, double* bitcast ([8 x i8]* @12 to double*), align 8
  %compare.214 = fcmp reassoc nsz contract ogt double %121, %constant.1457
  %122 = zext i1 %compare.214 to i8
  %constant.1456 = load double, double* bitcast ([8 x i8]* @13 to double*), align 8
  %123 = trunc i8 %122 to i1
  %124 = select reassoc nsz contract i1 %123, double %121, double %constant.1456
  %constant.1455 = load double, double* bitcast ([8 x i8]* @14 to double*), align 8
  %multiply.29 = fmul reassoc nsz contract double %124, %constant.1455
  store double %multiply.29, double* %fusion.4, align 8, !alias.scope !94, !noalias !96
  %125 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 1
  %126 = load i8*, i8** %125, align 8, !dereferenceable !50, !align !50
  %127 = bitcast i8* %126 to i64*
  %128 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %129 = load i8*, i8** %128, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %130 = getelementptr inbounds i8, i8* %129, i64 576
  %copy.16 = bitcast i8* %130 to i64*
  %131 = bitcast i64* %copy.16 to i8*
  %132 = bitcast i64* %127 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %131, i8* align 1 %132, i64 8, i1 false)
  %133 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 4
  %134 = load i8*, i8** %133, align 8, !dereferenceable !50, !align !50
  %135 = bitcast i8* %134 to double*
  %136 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %137 = load i8*, i8** %136, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %138 = getelementptr inbounds i8, i8* %137, i64 800
  %tuple.292 = bitcast i8* %138 to [3 x i8*]*
  %139 = bitcast i64* %copy.16 to i8*
  %140 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.292, i64 0, i64 0
  store i8* %139, i8** %140, align 8, !alias.scope !57, !noalias !59
  %141 = bitcast double* %135 to i8*
  %142 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.292, i64 0, i64 1
  store i8* %141, i8** %142, align 8, !alias.scope !57, !noalias !59
  %143 = bitcast double* %fusion.4 to i8*
  %144 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.292, i64 0, i64 2
  store i8* %143, i8** %144, align 8, !alias.scope !57, !noalias !59
  br label %while.67.header

while.67.header:                                  ; preds = %while.67.body, %dot.130.inner.loop_exit
  call void @wide.cond_computation__14.249.clone.1(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %145 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %146 = load i8*, i8** %145, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %147 = getelementptr inbounds i8, i8* %146, i64 592
  %148 = load i8, i8* %147, align 1
  %149 = icmp ne i8 %148, 0
  br i1 %149, label %while.67.body, label %while.67.exit

while.67.body:                                    ; preds = %while.67.header
  call void @wide.body_computation__14.216.clone.1(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.67.header

while.67.exit:                                    ; preds = %while.67.header
  %150 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.292, i64 0, i64 1
  %151 = load i8*, i8** %150, align 8, !dereferenceable !50, !align !50
  %152 = bitcast i8* %151 to double*
  %153 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.35, i64 0, i64 3
  %154 = load i8*, i8** %153, align 8, !dereferenceable !25, !align !2
  %155 = bitcast i8* %154 to [3 x %complex128]*
  %156 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %157 = load i8*, i8** %156, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %add.125 = bitcast i8* %157 to [3 x %complex128]*
  store i64 0, i64* %add.125.invar_address.dim.0, align 8
  br label %add.125.loop_header.dim.0

add.125.loop_header.dim.0:                        ; preds = %add.125.loop_body.dim.0, %while.67.exit
  %add.125.indvar.dim.0 = load i64, i64* %add.125.invar_address.dim.0, align 8
  %158 = icmp uge i64 %add.125.indvar.dim.0, 3
  br i1 %158, label %add.125.loop_exit.dim.0, label %add.125.loop_body.dim.0

add.125.loop_body.dim.0:                          ; preds = %add.125.loop_header.dim.0
  %159 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %155, i64 0, i64 %add.125.indvar.dim.0
  %160 = load %complex128, %complex128* %159, align 1, !alias.scope !97, !noalias !82
  %161 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.75, i64 0, i64 %add.125.indvar.dim.0
  %162 = load %complex128, %complex128* %161, align 1, !alias.scope !82, !noalias !83
  %163 = extractvalue %complex128 %160, 0
  %164 = extractvalue %complex128 %162, 0
  %165 = fadd reassoc nsz contract double %163, %164
  %166 = extractvalue %complex128 %160, 1
  %167 = extractvalue %complex128 %162, 1
  %168 = fadd reassoc nsz contract double %166, %167
  %169 = insertvalue %complex128 zeroinitializer, double %165, 0
  %170 = insertvalue %complex128 %169, double %168, 1
  %171 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %add.125, i64 0, i64 %add.125.indvar.dim.0
  store %complex128 %170, %complex128* %171, align 1, !alias.scope !97, !noalias !98
  %invar.inc8 = add nuw nsw i64 %add.125.indvar.dim.0, 1
  store i64 %invar.inc8, i64* %add.125.invar_address.dim.0, align 8
  br label %add.125.loop_header.dim.0

add.125.loop_exit.dim.0:                          ; preds = %add.125.loop_header.dim.0
  %172 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %173 = load i8*, i8** %172, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %174 = getelementptr inbounds i8, i8* %173, i64 720
  %add.126 = bitcast i8* %174 to i64*
  %175 = load i64, i64* %copy.16, align 8, !alias.scope !61, !noalias !99
  %176 = load i64, i64* bitcast ([8 x i8]* @2 to i64*), align 8, !alias.scope !101, !noalias !102
  %177 = add i64 %175, %176
  store i64 %177, i64* %add.126, align 8, !alias.scope !103, !noalias !104
  %178 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %179 = load i8*, i8** %178, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %180 = getelementptr inbounds i8, i8* %179, i64 960
  %tuple.301 = bitcast i8* %180 to [6 x i8*]*
  %181 = bitcast [3 x [3 x %complex128]]* %43 to i8*
  %182 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 0
  store i8* %181, i8** %182, align 8, !alias.scope !105, !noalias !106
  %183 = bitcast i64* %add.126 to i8*
  %184 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 1
  store i8* %183, i8** %184, align 8, !alias.scope !105, !noalias !106
  %185 = bitcast [3 x %complex128]* %subtract.11 to i8*
  %186 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 2
  store i8* %185, i8** %186, align 8, !alias.scope !105, !noalias !106
  %187 = bitcast [3 x %complex128]* %add.125 to i8*
  %188 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 3
  store i8* %187, i8** %188, align 8, !alias.scope !105, !noalias !106
  %189 = bitcast double* %152 to i8*
  %190 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 4
  store i8* %189, i8** %190, align 8, !alias.scope !105, !noalias !106
  %191 = bitcast [3 x [3 x %complex128]]* %8 to i8*
  %192 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.301, i64 0, i64 5
  store i8* %191, i8** %192, align 8, !alias.scope !105, !noalias !106
  ret void
}

; Function Attrs: uwtable
define internal void @col_major_gemv_F64_4_8_1_3_with_addend(double* %0, double* %1, double* %2, double* %3) #0 {
entry:
  %dot.inner.epilg.inner.invar_address79 = alloca i64, align 8
  %dot.inner.epilg.outer.invar_address73 = alloca i64, align 8
  %dot.inner.tiled.invar_address67 = alloca i64, align 8
  %dot.inner.epilg.inner.invar_address52 = alloca i64, align 8
  %dot.inner.epilg.outer.invar_address46 = alloca i64, align 8
  %dot.inner.tiled.invar_address40 = alloca i64, align 8
  %dot.outer.tiled.invar_address = alloca i64, align 8
  %dot.inner.epilg.inner.invar_address = alloca i64, align 8
  %dot.inner.epilg.outer.invar_address = alloca i64, align 8
  %dot.inner.tiled.invar_address = alloca i64, align 8
  br i1 false, label %-true, label %-false

-after:                                           ; preds = %-false, %dot.outer.tiled.loop_exit
  %4 = getelementptr inbounds double, double* %0, i64 0
  %5 = getelementptr inbounds double, double* %0, i64 1
  %6 = getelementptr inbounds double, double* %0, i64 2
  %7 = getelementptr inbounds double, double* %1, i64 0
  %8 = getelementptr inbounds double, double* %7, i64 0
  %9 = load double, double* %8, align 8
  %.splatinsert58 = insertelement <4 x double> poison, double %9, i32 0
  %.splat59 = shufflevector <4 x double> %.splatinsert58, <4 x double> poison, <4 x i32> zeroinitializer
  %10 = getelementptr inbounds double, double* %7, i64 1
  %11 = load double, double* %10, align 8
  %.splatinsert60 = insertelement <4 x double> poison, double %11, i32 0
  %.splat61 = shufflevector <4 x double> %.splatinsert60, <4 x double> poison, <4 x i32> zeroinitializer
  %12 = getelementptr inbounds double, double* %7, i64 2
  %13 = load double, double* %12, align 8
  %.splatinsert62 = insertelement <4 x double> poison, double %13, i32 0
  %.splat63 = shufflevector <4 x double> %.splatinsert62, <4 x double> poison, <4 x i32> zeroinitializer
  store i64 0, i64* %dot.inner.tiled.invar_address67, align 8
  br label %dot.inner.tiled.loop_header65

dot.inner.tiled.loop_header65:                    ; preds = %dot.inner.tiled.loop_body66, %-after
  %dot.inner.tiled.indvar68 = load i64, i64* %dot.inner.tiled.invar_address67, align 8
  %14 = icmp uge i64 %dot.inner.tiled.indvar68, 0
  br i1 %14, label %dot.inner.tiled.loop_exit64, label %dot.inner.tiled.loop_body66

dot.inner.tiled.loop_body66:                      ; preds = %dot.inner.tiled.loop_header65
  %invar.inc69 = add nuw nsw i64 %dot.inner.tiled.indvar68, 4
  store i64 %invar.inc69, i64* %dot.inner.tiled.invar_address67, align 8
  %15 = icmp eq i64 %dot.inner.tiled.indvar68, 0
  %16 = getelementptr inbounds double, double* %4, i64 %dot.inner.tiled.indvar68
  %17 = bitcast double* %16 to <4 x double>*
  %18 = load <4 x double>, <4 x double>* %17, align 8
  %19 = getelementptr inbounds double, double* %5, i64 %dot.inner.tiled.indvar68
  %20 = bitcast double* %19 to <4 x double>*
  %21 = load <4 x double>, <4 x double>* %20, align 8
  %22 = getelementptr inbounds double, double* %6, i64 %dot.inner.tiled.indvar68
  %23 = bitcast double* %22 to <4 x double>*
  %24 = load <4 x double>, <4 x double>* %23, align 8
  %25 = getelementptr inbounds double, double* %2, i64 %dot.inner.tiled.indvar68
  %26 = bitcast double* %25 to <4 x double>*
  %27 = load <4 x double>, <4 x double>* %26, align 8
  %28 = fmul reassoc nsz contract <4 x double> %18, %.splat59
  %29 = fadd reassoc nsz contract <4 x double> %27, %28
  %30 = fmul reassoc nsz contract <4 x double> %21, %.splat61
  %31 = fadd reassoc nsz contract <4 x double> %29, %30
  %32 = fmul reassoc nsz contract <4 x double> %24, %.splat63
  %33 = fadd reassoc nsz contract <4 x double> %31, %32
  %34 = getelementptr inbounds double, double* %3, i64 %dot.inner.tiled.indvar68
  %35 = bitcast double* %34 to <4 x double>*
  store <4 x double> %33, <4 x double>* %35, align 8
  br label %dot.inner.tiled.loop_header65, !llvm.loop !107

dot.inner.tiled.loop_exit64:                      ; preds = %dot.inner.tiled.loop_header65
  store i64 0, i64* %dot.inner.epilg.outer.invar_address73, align 8
  br label %dot.inner.epilg.outer.loop_header71

dot.inner.epilg.outer.loop_header71:              ; preds = %dot.inner.epilg.inner.loop_exit76, %dot.inner.tiled.loop_exit64
  %dot.inner.epilg.outer.indvar74 = load i64, i64* %dot.inner.epilg.outer.invar_address73, align 8
  %36 = icmp uge i64 %dot.inner.epilg.outer.indvar74, 3
  br i1 %36, label %dot.inner.epilg.outer.loop_exit70, label %dot.inner.epilg.outer.loop_body72

dot.inner.epilg.outer.loop_body72:                ; preds = %dot.inner.epilg.outer.loop_header71
  %invar.inc75 = add nuw nsw i64 %dot.inner.epilg.outer.indvar74, 1
  store i64 %invar.inc75, i64* %dot.inner.epilg.outer.invar_address73, align 8
  %37 = icmp eq i64 %dot.inner.epilg.outer.indvar74, 0
  %38 = getelementptr inbounds double, double* %1, i64 %dot.inner.epilg.outer.indvar74
  %39 = load double, double* %38, align 8
  %40 = mul i64 %dot.inner.epilg.outer.indvar74, 1
  %41 = getelementptr inbounds double, double* %0, i64 %40
  store i64 0, i64* %dot.inner.epilg.inner.invar_address79, align 8
  br label %dot.inner.epilg.inner.loop_header77

dot.inner.epilg.inner.loop_header77:              ; preds = %-after84, %dot.inner.epilg.outer.loop_body72
  %dot.inner.epilg.inner.indvar80 = load i64, i64* %dot.inner.epilg.inner.invar_address79, align 8
  %42 = icmp uge i64 %dot.inner.epilg.inner.indvar80, 1
  br i1 %42, label %dot.inner.epilg.inner.loop_exit76, label %dot.inner.epilg.inner.loop_body78

dot.inner.epilg.inner.loop_body78:                ; preds = %dot.inner.epilg.inner.loop_header77
  %invar.inc81 = add nuw nsw i64 %dot.inner.epilg.inner.indvar80, 1
  store i64 %invar.inc81, i64* %dot.inner.epilg.inner.invar_address79, align 8
  %43 = icmp eq i64 %dot.inner.epilg.inner.indvar80, 0
  %44 = getelementptr inbounds double, double* %41, i64 %dot.inner.epilg.inner.indvar80
  %45 = load double, double* %44, align 8
  %46 = fmul reassoc nsz contract double %45, %39
  br i1 %37, label %-true82, label %-false83

-after84:                                         ; preds = %-false83, %-true82
  br label %dot.inner.epilg.inner.loop_header77, !llvm.loop !109

dot.inner.epilg.inner.loop_exit76:                ; preds = %dot.inner.epilg.inner.loop_header77
  br label %dot.inner.epilg.outer.loop_header71, !llvm.loop !110

dot.inner.epilg.outer.loop_exit70:                ; preds = %dot.inner.epilg.outer.loop_header71
  ret void

-true:                                            ; preds = %entry
  %47 = getelementptr inbounds double, double* %0, i64 0
  %48 = getelementptr inbounds double, double* %0, i64 1
  %49 = getelementptr inbounds double, double* %0, i64 2
  %50 = getelementptr inbounds double, double* %0, i64 3
  %51 = getelementptr inbounds double, double* %0, i64 4
  %52 = getelementptr inbounds double, double* %0, i64 5
  %53 = getelementptr inbounds double, double* %0, i64 6
  %54 = getelementptr inbounds double, double* %0, i64 7
  %55 = getelementptr inbounds double, double* %1, i64 0
  %56 = getelementptr inbounds double, double* %55, i64 0
  %57 = load double, double* %56, align 8
  %.splatinsert = insertelement <4 x double> poison, double %57, i32 0
  %.splat = shufflevector <4 x double> %.splatinsert, <4 x double> poison, <4 x i32> zeroinitializer
  %58 = getelementptr inbounds double, double* %55, i64 1
  %59 = load double, double* %58, align 8
  %.splatinsert1 = insertelement <4 x double> poison, double %59, i32 0
  %.splat2 = shufflevector <4 x double> %.splatinsert1, <4 x double> poison, <4 x i32> zeroinitializer
  %60 = getelementptr inbounds double, double* %55, i64 2
  %61 = load double, double* %60, align 8
  %.splatinsert3 = insertelement <4 x double> poison, double %61, i32 0
  %.splat4 = shufflevector <4 x double> %.splatinsert3, <4 x double> poison, <4 x i32> zeroinitializer
  %62 = getelementptr inbounds double, double* %55, i64 3
  %63 = load double, double* %62, align 8
  %.splatinsert5 = insertelement <4 x double> poison, double %63, i32 0
  %.splat6 = shufflevector <4 x double> %.splatinsert5, <4 x double> poison, <4 x i32> zeroinitializer
  %64 = getelementptr inbounds double, double* %55, i64 4
  %65 = load double, double* %64, align 8
  %.splatinsert7 = insertelement <4 x double> poison, double %65, i32 0
  %.splat8 = shufflevector <4 x double> %.splatinsert7, <4 x double> poison, <4 x i32> zeroinitializer
  %66 = getelementptr inbounds double, double* %55, i64 5
  %67 = load double, double* %66, align 8
  %.splatinsert9 = insertelement <4 x double> poison, double %67, i32 0
  %.splat10 = shufflevector <4 x double> %.splatinsert9, <4 x double> poison, <4 x i32> zeroinitializer
  %68 = getelementptr inbounds double, double* %55, i64 6
  %69 = load double, double* %68, align 8
  %.splatinsert11 = insertelement <4 x double> poison, double %69, i32 0
  %.splat12 = shufflevector <4 x double> %.splatinsert11, <4 x double> poison, <4 x i32> zeroinitializer
  %70 = getelementptr inbounds double, double* %55, i64 7
  %71 = load double, double* %70, align 8
  %.splatinsert13 = insertelement <4 x double> poison, double %71, i32 0
  %.splat14 = shufflevector <4 x double> %.splatinsert13, <4 x double> poison, <4 x i32> zeroinitializer
  store i64 0, i64* %dot.inner.tiled.invar_address, align 8
  br label %dot.inner.tiled.loop_header

dot.inner.tiled.loop_header:                      ; preds = %dot.inner.tiled.loop_body, %-true
  %dot.inner.tiled.indvar = load i64, i64* %dot.inner.tiled.invar_address, align 8
  %72 = icmp uge i64 %dot.inner.tiled.indvar, 0
  br i1 %72, label %dot.inner.tiled.loop_exit, label %dot.inner.tiled.loop_body

dot.inner.tiled.loop_body:                        ; preds = %dot.inner.tiled.loop_header
  %invar.inc = add nuw nsw i64 %dot.inner.tiled.indvar, 4
  store i64 %invar.inc, i64* %dot.inner.tiled.invar_address, align 8
  %73 = icmp eq i64 %dot.inner.tiled.indvar, 0
  %74 = getelementptr inbounds double, double* %47, i64 %dot.inner.tiled.indvar
  %75 = bitcast double* %74 to <4 x double>*
  %76 = load <4 x double>, <4 x double>* %75, align 8
  %77 = getelementptr inbounds double, double* %48, i64 %dot.inner.tiled.indvar
  %78 = bitcast double* %77 to <4 x double>*
  %79 = load <4 x double>, <4 x double>* %78, align 8
  %80 = getelementptr inbounds double, double* %49, i64 %dot.inner.tiled.indvar
  %81 = bitcast double* %80 to <4 x double>*
  %82 = load <4 x double>, <4 x double>* %81, align 8
  %83 = getelementptr inbounds double, double* %50, i64 %dot.inner.tiled.indvar
  %84 = bitcast double* %83 to <4 x double>*
  %85 = load <4 x double>, <4 x double>* %84, align 8
  %86 = getelementptr inbounds double, double* %51, i64 %dot.inner.tiled.indvar
  %87 = bitcast double* %86 to <4 x double>*
  %88 = load <4 x double>, <4 x double>* %87, align 8
  %89 = getelementptr inbounds double, double* %52, i64 %dot.inner.tiled.indvar
  %90 = bitcast double* %89 to <4 x double>*
  %91 = load <4 x double>, <4 x double>* %90, align 8
  %92 = getelementptr inbounds double, double* %53, i64 %dot.inner.tiled.indvar
  %93 = bitcast double* %92 to <4 x double>*
  %94 = load <4 x double>, <4 x double>* %93, align 8
  %95 = getelementptr inbounds double, double* %54, i64 %dot.inner.tiled.indvar
  %96 = bitcast double* %95 to <4 x double>*
  %97 = load <4 x double>, <4 x double>* %96, align 8
  %98 = getelementptr inbounds double, double* %2, i64 %dot.inner.tiled.indvar
  %99 = bitcast double* %98 to <4 x double>*
  %100 = load <4 x double>, <4 x double>* %99, align 8
  %101 = fmul reassoc nsz contract <4 x double> %76, %.splat
  %102 = fadd reassoc nsz contract <4 x double> %100, %101
  %103 = fmul reassoc nsz contract <4 x double> %79, %.splat2
  %104 = fadd reassoc nsz contract <4 x double> %102, %103
  %105 = fmul reassoc nsz contract <4 x double> %82, %.splat4
  %106 = fadd reassoc nsz contract <4 x double> %104, %105
  %107 = fmul reassoc nsz contract <4 x double> %85, %.splat6
  %108 = fadd reassoc nsz contract <4 x double> %106, %107
  %109 = fmul reassoc nsz contract <4 x double> %88, %.splat8
  %110 = fadd reassoc nsz contract <4 x double> %108, %109
  %111 = fmul reassoc nsz contract <4 x double> %91, %.splat10
  %112 = fadd reassoc nsz contract <4 x double> %110, %111
  %113 = fmul reassoc nsz contract <4 x double> %94, %.splat12
  %114 = fadd reassoc nsz contract <4 x double> %112, %113
  %115 = fmul reassoc nsz contract <4 x double> %97, %.splat14
  %116 = fadd reassoc nsz contract <4 x double> %114, %115
  %117 = getelementptr inbounds double, double* %3, i64 %dot.inner.tiled.indvar
  %118 = bitcast double* %117 to <4 x double>*
  store <4 x double> %116, <4 x double>* %118, align 8
  br label %dot.inner.tiled.loop_header, !llvm.loop !111

dot.inner.tiled.loop_exit:                        ; preds = %dot.inner.tiled.loop_header
  store i64 0, i64* %dot.inner.epilg.outer.invar_address, align 8
  br label %dot.inner.epilg.outer.loop_header

dot.inner.epilg.outer.loop_header:                ; preds = %dot.inner.epilg.inner.loop_exit, %dot.inner.tiled.loop_exit
  %dot.inner.epilg.outer.indvar = load i64, i64* %dot.inner.epilg.outer.invar_address, align 8
  %119 = icmp uge i64 %dot.inner.epilg.outer.indvar, 8
  br i1 %119, label %dot.inner.epilg.outer.loop_exit, label %dot.inner.epilg.outer.loop_body

dot.inner.epilg.outer.loop_body:                  ; preds = %dot.inner.epilg.outer.loop_header
  %invar.inc15 = add nuw nsw i64 %dot.inner.epilg.outer.indvar, 1
  store i64 %invar.inc15, i64* %dot.inner.epilg.outer.invar_address, align 8
  %120 = icmp eq i64 %dot.inner.epilg.outer.indvar, 0
  %121 = getelementptr inbounds double, double* %1, i64 %dot.inner.epilg.outer.indvar
  %122 = load double, double* %121, align 8
  %123 = mul i64 %dot.inner.epilg.outer.indvar, 1
  %124 = getelementptr inbounds double, double* %0, i64 %123
  store i64 0, i64* %dot.inner.epilg.inner.invar_address, align 8
  br label %dot.inner.epilg.inner.loop_header

dot.inner.epilg.inner.loop_header:                ; preds = %-after19, %dot.inner.epilg.outer.loop_body
  %dot.inner.epilg.inner.indvar = load i64, i64* %dot.inner.epilg.inner.invar_address, align 8
  %125 = icmp uge i64 %dot.inner.epilg.inner.indvar, 1
  br i1 %125, label %dot.inner.epilg.inner.loop_exit, label %dot.inner.epilg.inner.loop_body

dot.inner.epilg.inner.loop_body:                  ; preds = %dot.inner.epilg.inner.loop_header
  %invar.inc16 = add nuw nsw i64 %dot.inner.epilg.inner.indvar, 1
  store i64 %invar.inc16, i64* %dot.inner.epilg.inner.invar_address, align 8
  %126 = icmp eq i64 %dot.inner.epilg.inner.indvar, 0
  %127 = getelementptr inbounds double, double* %124, i64 %dot.inner.epilg.inner.indvar
  %128 = load double, double* %127, align 8
  %129 = fmul reassoc nsz contract double %128, %122
  br i1 %120, label %-true17, label %-false18

-after19:                                         ; preds = %-false18, %-true17
  br label %dot.inner.epilg.inner.loop_header, !llvm.loop !112

dot.inner.epilg.inner.loop_exit:                  ; preds = %dot.inner.epilg.inner.loop_header
  br label %dot.inner.epilg.outer.loop_header, !llvm.loop !113

dot.inner.epilg.outer.loop_exit:                  ; preds = %dot.inner.epilg.outer.loop_header
  store i64 8, i64* %dot.outer.tiled.invar_address, align 8
  br label %dot.outer.tiled.loop_header

dot.outer.tiled.loop_header:                      ; preds = %dot.inner.epilg.outer.loop_exit43, %dot.inner.epilg.outer.loop_exit
  %dot.outer.tiled.indvar = load i64, i64* %dot.outer.tiled.invar_address, align 8
  %130 = icmp uge i64 %dot.outer.tiled.indvar, 0
  br i1 %130, label %dot.outer.tiled.loop_exit, label %dot.outer.tiled.loop_body

dot.outer.tiled.loop_body:                        ; preds = %dot.outer.tiled.loop_header
  %invar.inc20 = add nuw nsw i64 %dot.outer.tiled.indvar, 8
  store i64 %invar.inc20, i64* %dot.outer.tiled.invar_address, align 8
  %131 = icmp eq i64 %dot.outer.tiled.indvar, 8
  %132 = add i64 0, %dot.outer.tiled.indvar
  %133 = mul i64 1, %132
  %134 = getelementptr inbounds double, double* %0, i64 %133
  %135 = add i64 1, %dot.outer.tiled.indvar
  %136 = mul i64 1, %135
  %137 = getelementptr inbounds double, double* %0, i64 %136
  %138 = add i64 2, %dot.outer.tiled.indvar
  %139 = mul i64 1, %138
  %140 = getelementptr inbounds double, double* %0, i64 %139
  %141 = add i64 3, %dot.outer.tiled.indvar
  %142 = mul i64 1, %141
  %143 = getelementptr inbounds double, double* %0, i64 %142
  %144 = add i64 4, %dot.outer.tiled.indvar
  %145 = mul i64 1, %144
  %146 = getelementptr inbounds double, double* %0, i64 %145
  %147 = add i64 5, %dot.outer.tiled.indvar
  %148 = mul i64 1, %147
  %149 = getelementptr inbounds double, double* %0, i64 %148
  %150 = add i64 6, %dot.outer.tiled.indvar
  %151 = mul i64 1, %150
  %152 = getelementptr inbounds double, double* %0, i64 %151
  %153 = add i64 7, %dot.outer.tiled.indvar
  %154 = mul i64 1, %153
  %155 = getelementptr inbounds double, double* %0, i64 %154
  %156 = getelementptr inbounds double, double* %1, i64 %dot.outer.tiled.indvar
  %157 = getelementptr inbounds double, double* %156, i64 0
  %158 = load double, double* %157, align 8
  %.splatinsert21 = insertelement <4 x double> poison, double %158, i32 0
  %.splat22 = shufflevector <4 x double> %.splatinsert21, <4 x double> poison, <4 x i32> zeroinitializer
  %159 = getelementptr inbounds double, double* %156, i64 1
  %160 = load double, double* %159, align 8
  %.splatinsert23 = insertelement <4 x double> poison, double %160, i32 0
  %.splat24 = shufflevector <4 x double> %.splatinsert23, <4 x double> poison, <4 x i32> zeroinitializer
  %161 = getelementptr inbounds double, double* %156, i64 2
  %162 = load double, double* %161, align 8
  %.splatinsert25 = insertelement <4 x double> poison, double %162, i32 0
  %.splat26 = shufflevector <4 x double> %.splatinsert25, <4 x double> poison, <4 x i32> zeroinitializer
  %163 = getelementptr inbounds double, double* %156, i64 3
  %164 = load double, double* %163, align 8
  %.splatinsert27 = insertelement <4 x double> poison, double %164, i32 0
  %.splat28 = shufflevector <4 x double> %.splatinsert27, <4 x double> poison, <4 x i32> zeroinitializer
  %165 = getelementptr inbounds double, double* %156, i64 4
  %166 = load double, double* %165, align 8
  %.splatinsert29 = insertelement <4 x double> poison, double %166, i32 0
  %.splat30 = shufflevector <4 x double> %.splatinsert29, <4 x double> poison, <4 x i32> zeroinitializer
  %167 = getelementptr inbounds double, double* %156, i64 5
  %168 = load double, double* %167, align 8
  %.splatinsert31 = insertelement <4 x double> poison, double %168, i32 0
  %.splat32 = shufflevector <4 x double> %.splatinsert31, <4 x double> poison, <4 x i32> zeroinitializer
  %169 = getelementptr inbounds double, double* %156, i64 6
  %170 = load double, double* %169, align 8
  %.splatinsert33 = insertelement <4 x double> poison, double %170, i32 0
  %.splat34 = shufflevector <4 x double> %.splatinsert33, <4 x double> poison, <4 x i32> zeroinitializer
  %171 = getelementptr inbounds double, double* %156, i64 7
  %172 = load double, double* %171, align 8
  %.splatinsert35 = insertelement <4 x double> poison, double %172, i32 0
  %.splat36 = shufflevector <4 x double> %.splatinsert35, <4 x double> poison, <4 x i32> zeroinitializer
  store i64 0, i64* %dot.inner.tiled.invar_address40, align 8
  br label %dot.inner.tiled.loop_header38

dot.inner.tiled.loop_header38:                    ; preds = %dot.inner.tiled.loop_body39, %dot.outer.tiled.loop_body
  %dot.inner.tiled.indvar41 = load i64, i64* %dot.inner.tiled.invar_address40, align 8
  %173 = icmp uge i64 %dot.inner.tiled.indvar41, 0
  br i1 %173, label %dot.inner.tiled.loop_exit37, label %dot.inner.tiled.loop_body39

dot.inner.tiled.loop_body39:                      ; preds = %dot.inner.tiled.loop_header38
  %invar.inc42 = add nuw nsw i64 %dot.inner.tiled.indvar41, 4
  store i64 %invar.inc42, i64* %dot.inner.tiled.invar_address40, align 8
  %174 = icmp eq i64 %dot.inner.tiled.indvar41, 0
  %175 = getelementptr inbounds double, double* %134, i64 %dot.inner.tiled.indvar41
  %176 = bitcast double* %175 to <4 x double>*
  %177 = load <4 x double>, <4 x double>* %176, align 8
  %178 = getelementptr inbounds double, double* %137, i64 %dot.inner.tiled.indvar41
  %179 = bitcast double* %178 to <4 x double>*
  %180 = load <4 x double>, <4 x double>* %179, align 8
  %181 = getelementptr inbounds double, double* %140, i64 %dot.inner.tiled.indvar41
  %182 = bitcast double* %181 to <4 x double>*
  %183 = load <4 x double>, <4 x double>* %182, align 8
  %184 = getelementptr inbounds double, double* %143, i64 %dot.inner.tiled.indvar41
  %185 = bitcast double* %184 to <4 x double>*
  %186 = load <4 x double>, <4 x double>* %185, align 8
  %187 = getelementptr inbounds double, double* %146, i64 %dot.inner.tiled.indvar41
  %188 = bitcast double* %187 to <4 x double>*
  %189 = load <4 x double>, <4 x double>* %188, align 8
  %190 = getelementptr inbounds double, double* %149, i64 %dot.inner.tiled.indvar41
  %191 = bitcast double* %190 to <4 x double>*
  %192 = load <4 x double>, <4 x double>* %191, align 8
  %193 = getelementptr inbounds double, double* %152, i64 %dot.inner.tiled.indvar41
  %194 = bitcast double* %193 to <4 x double>*
  %195 = load <4 x double>, <4 x double>* %194, align 8
  %196 = getelementptr inbounds double, double* %155, i64 %dot.inner.tiled.indvar41
  %197 = bitcast double* %196 to <4 x double>*
  %198 = load <4 x double>, <4 x double>* %197, align 8
  %199 = getelementptr inbounds double, double* %3, i64 %dot.inner.tiled.indvar41
  %200 = bitcast double* %199 to <4 x double>*
  %201 = load <4 x double>, <4 x double>* %200, align 8
  %202 = fmul reassoc nsz contract <4 x double> %177, %.splat22
  %203 = fadd reassoc nsz contract <4 x double> %201, %202
  %204 = fmul reassoc nsz contract <4 x double> %180, %.splat24
  %205 = fadd reassoc nsz contract <4 x double> %203, %204
  %206 = fmul reassoc nsz contract <4 x double> %183, %.splat26
  %207 = fadd reassoc nsz contract <4 x double> %205, %206
  %208 = fmul reassoc nsz contract <4 x double> %186, %.splat28
  %209 = fadd reassoc nsz contract <4 x double> %207, %208
  %210 = fmul reassoc nsz contract <4 x double> %189, %.splat30
  %211 = fadd reassoc nsz contract <4 x double> %209, %210
  %212 = fmul reassoc nsz contract <4 x double> %192, %.splat32
  %213 = fadd reassoc nsz contract <4 x double> %211, %212
  %214 = fmul reassoc nsz contract <4 x double> %195, %.splat34
  %215 = fadd reassoc nsz contract <4 x double> %213, %214
  %216 = fmul reassoc nsz contract <4 x double> %198, %.splat36
  %217 = fadd reassoc nsz contract <4 x double> %215, %216
  %218 = getelementptr inbounds double, double* %3, i64 %dot.inner.tiled.indvar41
  %219 = bitcast double* %218 to <4 x double>*
  store <4 x double> %217, <4 x double>* %219, align 8
  br label %dot.inner.tiled.loop_header38, !llvm.loop !114

dot.inner.tiled.loop_exit37:                      ; preds = %dot.inner.tiled.loop_header38
  %220 = add i64 8, %dot.outer.tiled.indvar
  store i64 %dot.outer.tiled.indvar, i64* %dot.inner.epilg.outer.invar_address46, align 8
  br label %dot.inner.epilg.outer.loop_header44

dot.inner.epilg.outer.loop_header44:              ; preds = %dot.inner.epilg.inner.loop_exit49, %dot.inner.tiled.loop_exit37
  %dot.inner.epilg.outer.indvar47 = load i64, i64* %dot.inner.epilg.outer.invar_address46, align 8
  %221 = icmp uge i64 %dot.inner.epilg.outer.indvar47, %220
  br i1 %221, label %dot.inner.epilg.outer.loop_exit43, label %dot.inner.epilg.outer.loop_body45

dot.inner.epilg.outer.loop_body45:                ; preds = %dot.inner.epilg.outer.loop_header44
  %invar.inc48 = add nuw nsw i64 %dot.inner.epilg.outer.indvar47, 1
  store i64 %invar.inc48, i64* %dot.inner.epilg.outer.invar_address46, align 8
  %222 = icmp eq i64 %dot.inner.epilg.outer.indvar47, %dot.outer.tiled.indvar
  %223 = getelementptr inbounds double, double* %1, i64 %dot.inner.epilg.outer.indvar47
  %224 = load double, double* %223, align 8
  %225 = mul i64 %dot.inner.epilg.outer.indvar47, 1
  %226 = getelementptr inbounds double, double* %0, i64 %225
  store i64 0, i64* %dot.inner.epilg.inner.invar_address52, align 8
  br label %dot.inner.epilg.inner.loop_header50

dot.inner.epilg.inner.loop_header50:              ; preds = %-after57, %dot.inner.epilg.outer.loop_body45
  %dot.inner.epilg.inner.indvar53 = load i64, i64* %dot.inner.epilg.inner.invar_address52, align 8
  %227 = icmp uge i64 %dot.inner.epilg.inner.indvar53, 1
  br i1 %227, label %dot.inner.epilg.inner.loop_exit49, label %dot.inner.epilg.inner.loop_body51

dot.inner.epilg.inner.loop_body51:                ; preds = %dot.inner.epilg.inner.loop_header50
  %invar.inc54 = add nuw nsw i64 %dot.inner.epilg.inner.indvar53, 1
  store i64 %invar.inc54, i64* %dot.inner.epilg.inner.invar_address52, align 8
  %228 = icmp eq i64 %dot.inner.epilg.inner.indvar53, 0
  %229 = getelementptr inbounds double, double* %226, i64 %dot.inner.epilg.inner.indvar53
  %230 = load double, double* %229, align 8
  %231 = fmul reassoc nsz contract double %230, %224
  %232 = and i1 %222, false
  br i1 %232, label %-true55, label %-false56

-after57:                                         ; preds = %-false56, %-true55
  br label %dot.inner.epilg.inner.loop_header50, !llvm.loop !115

dot.inner.epilg.inner.loop_exit49:                ; preds = %dot.inner.epilg.inner.loop_header50
  br label %dot.inner.epilg.outer.loop_header44, !llvm.loop !116

dot.inner.epilg.outer.loop_exit43:                ; preds = %dot.inner.epilg.outer.loop_header44
  br label %dot.outer.tiled.loop_header, !llvm.loop !117

dot.outer.tiled.loop_exit:                        ; preds = %dot.outer.tiled.loop_header
  br label %-after

-false:                                           ; preds = %entry
  br label %-after

-true17:                                          ; preds = %dot.inner.epilg.inner.loop_body
  %233 = getelementptr inbounds double, double* %2, i64 %dot.inner.epilg.inner.indvar
  %234 = load double, double* %233, align 8
  %235 = fadd reassoc nsz contract double %234, %129
  %236 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar
  store double %235, double* %236, align 8
  br label %-after19

-false18:                                         ; preds = %dot.inner.epilg.inner.loop_body
  %237 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar
  %238 = load double, double* %237, align 8
  %239 = fadd reassoc nsz contract double %238, %129
  %240 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar
  store double %239, double* %240, align 8
  br label %-after19

-true55:                                          ; preds = %dot.inner.epilg.inner.loop_body51
  %241 = getelementptr inbounds double, double* %2, i64 %dot.inner.epilg.inner.indvar53
  %242 = load double, double* %241, align 8
  %243 = fadd reassoc nsz contract double %242, %231
  %244 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar53
  store double %243, double* %244, align 8
  br label %-after57

-false56:                                         ; preds = %dot.inner.epilg.inner.loop_body51
  %245 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar53
  %246 = load double, double* %245, align 8
  %247 = fadd reassoc nsz contract double %246, %231
  %248 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar53
  store double %247, double* %248, align 8
  br label %-after57

-true82:                                          ; preds = %dot.inner.epilg.inner.loop_body78
  %249 = getelementptr inbounds double, double* %2, i64 %dot.inner.epilg.inner.indvar80
  %250 = load double, double* %249, align 8
  %251 = fadd reassoc nsz contract double %250, %46
  %252 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar80
  store double %251, double* %252, align 8
  br label %-after84

-false83:                                         ; preds = %dot.inner.epilg.inner.loop_body78
  %253 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar80
  %254 = load double, double* %253, align 8
  %255 = fadd reassoc nsz contract double %254, %46
  %256 = getelementptr inbounds double, double* %3, i64 %dot.inner.epilg.inner.indvar80
  store double %255, double* %256, align 8
  br label %-after84
}

; Function Attrs: uwtable
define internal void @wide.cond_computation__13.309.clone.1.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %dot_acc = alloca double, align 8
  %dot.132.inner.invar_address = alloca i64, align 8
  %imag.69.invar_address.dim.0 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 960
  %wide_param.34 = bitcast i8* %2 to [6 x i8*]*
  %3 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.34, i64 0, i64 3
  %4 = load i8*, i8** %3, align 8, !dereferenceable !25, !align !2
  %5 = bitcast i8* %4 to [3 x %complex128]*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %8 = getelementptr inbounds i8, i8* %7, i64 528
  %imag.69 = bitcast i8* %8 to [3 x double]*
  store i64 0, i64* %imag.69.invar_address.dim.0, align 8
  br label %imag.69.loop_header.dim.0

imag.69.loop_header.dim.0:                        ; preds = %imag.69.loop_body.dim.0, %entry
  %imag.69.indvar.dim.0 = load i64, i64* %imag.69.invar_address.dim.0, align 8
  %9 = icmp uge i64 %imag.69.indvar.dim.0, 3
  br i1 %9, label %imag.69.loop_exit.dim.0, label %imag.69.loop_body.dim.0

imag.69.loop_body.dim.0:                          ; preds = %imag.69.loop_header.dim.0
  %10 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %5, i64 0, i64 %imag.69.indvar.dim.0
  %11 = load %complex128, %complex128* %10, align 1, !alias.scope !97, !noalias !118
  %12 = extractvalue %complex128 %11, 1
  %13 = getelementptr inbounds [3 x double], [3 x double]* %imag.69, i64 0, i64 %imag.69.indvar.dim.0
  store double %12, double* %13, align 8, !alias.scope !121, !noalias !122
  %invar.inc = add nuw nsw i64 %imag.69.indvar.dim.0, 1
  store i64 %invar.inc, i64* %imag.69.invar_address.dim.0, align 8
  br label %imag.69.loop_header.dim.0

imag.69.loop_exit.dim.0:                          ; preds = %imag.69.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc, align 8
  %14 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %15 = load i8*, i8** %14, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %16 = getelementptr inbounds i8, i8* %15, i64 560
  %fusion.9 = bitcast i8* %16 to double*
  store i64 0, i64* %dot.132.inner.invar_address, align 8
  br label %dot.132.inner.loop_header

dot.132.inner.loop_header:                        ; preds = %dot.132.inner.loop_body, %imag.69.loop_exit.dim.0
  %dot.132.inner.indvar = load i64, i64* %dot.132.inner.invar_address, align 8
  %17 = icmp uge i64 %dot.132.inner.indvar, 3
  br i1 %17, label %dot.132.inner.loop_exit, label %dot.132.inner.loop_body

dot.132.inner.loop_body:                          ; preds = %dot.132.inner.loop_header
  %18 = load double, double* %dot_acc, align 8
  %19 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %5, i64 0, i64 %dot.132.inner.indvar
  %20 = load %complex128, %complex128* %19, align 1, !alias.scope !97, !noalias !118
  %21 = extractvalue %complex128 %20, 0
  %22 = fmul reassoc nsz contract double %21, %21
  %23 = fadd reassoc nsz contract double %18, %22
  store double %23, double* %dot_acc, align 8
  %invar.inc1 = add nuw nsw i64 %dot.132.inner.indvar, 1
  store i64 %invar.inc1, i64* %dot.132.inner.invar_address, align 8
  br label %dot.132.inner.loop_header

dot.132.inner.loop_exit:                          ; preds = %dot.132.inner.loop_header
  %24 = load double, double* %dot_acc, align 8
  store double %24, double* %fusion.9, align 8, !alias.scope !123, !noalias !124
  %25 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %26 = load i8*, i8** %25, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %27 = getelementptr inbounds i8, i8* %26, i64 560
  %fusion.8 = bitcast i8* %27 to double*
  %28 = bitcast [3 x double]* %imag.69 to double*
  %29 = bitcast [3 x double]* %imag.69 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %28, double* %29, double* %fusion.9, double* %fusion.8)
  %30 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.34, i64 0, i64 4
  %31 = load i8*, i8** %30, align 8, !dereferenceable !50, !align !50
  %32 = bitcast i8* %31 to double*
  %33 = getelementptr inbounds [6 x i8*], [6 x i8*]* %wide_param.34, i64 0, i64 1
  %34 = load i8*, i8** %33, align 8, !dereferenceable !50, !align !50
  %35 = bitcast i8* %34 to i64*
  %36 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %37 = load i8*, i8** %36, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.7 = getelementptr inbounds i8, i8* %37, i64 528
  %38 = load i64, i64* %35, align 8, !alias.scope !103, !noalias !125
  %constant.1460 = load i64, i64* bitcast ([8 x i8]* @15 to i64*), align 8
  %39 = icmp slt i64 %38, %constant.1460
  %40 = zext i1 %39 to i8
  %41 = load double, double* %fusion.8, align 8, !alias.scope !123, !noalias !127
  %42 = call reassoc nsz contract double @llvm.sqrt.f64(double %41)
  %constant.1459 = load double, double* bitcast ([8 x i8]* @16 to double*), align 8
  %compare.216 = fcmp reassoc nsz contract ogt double %42, %constant.1459
  %43 = zext i1 %compare.216 to i8
  %constant.1458 = load double, double* bitcast ([8 x i8]* @17 to double*), align 8
  %44 = trunc i8 %43 to i1
  %45 = select reassoc nsz contract i1 %44, double %42, double %constant.1458
  %46 = load double, double* %32, align 8, !alias.scope !128, !noalias !129
  %compare.215 = fcmp reassoc nsz contract olt double %45, %46
  %47 = zext i1 %compare.215 to i8
  %48 = and i8 %40, %47
  store i8 %48, i8* %fusion.7, align 1, !alias.scope !130, !noalias !131
  ret void
}

; Function Attrs: uwtable
define internal void @and.reduce_sub_computation.2(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %and.5 = alloca i8, align 1
  %0 = getelementptr inbounds i8*, i8** %params, i64 0
  %lhs.2 = load i8*, i8** %0, align 8, !dereferenceable !34
  %1 = getelementptr inbounds i8*, i8** %params, i64 1
  %rhs.2 = load i8*, i8** %1, align 8, !dereferenceable !34
  %2 = load i8, i8* %lhs.2, align 1, !alias.scope !132, !noalias !134
  %3 = load i8, i8* %rhs.2, align 1, !alias.scope !136, !noalias !134
  %4 = and i8 %2, %3
  store i8 %4, i8* %and.5, align 1, !alias.scope !134
  %load_ret_value = load i8, i8* %and.5, align 1
  store i8 %load_ret_value, i8* %retval, align 1
  ret void
}

; Function Attrs: uwtable
define internal void @and.reduce_sub_computation(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %and.1 = alloca i8, align 1
  %0 = getelementptr inbounds i8*, i8** %params, i64 0
  %lhs = load i8*, i8** %0, align 8, !dereferenceable !34
  %1 = getelementptr inbounds i8*, i8** %params, i64 1
  %rhs = load i8*, i8** %1, align 8, !dereferenceable !34
  %2 = load i8, i8* %lhs, align 1, !alias.scope !138, !noalias !140
  %3 = load i8, i8* %rhs, align 1, !alias.scope !142, !noalias !140
  %4 = and i8 %2, %3
  store i8 %4, i8* %and.1, align 1, !alias.scope !140
  %load_ret_value = load i8, i8* %and.1, align 1
  store i8 %load_ret_value, i8* %retval, align 1
  ret void
}

; Function Attrs: uwtable
define internal void @wide.body_computation__11.373.clone.4(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %dynamic-update-slice.53.invar_address.dim.1 = alloca i64, align 8
  %dynamic-update-slice.53.invar_address.dim.0 = alloca i64, align 8
  %reduce_function_parameter_addresses49 = alloca i8*, i32 2, align 8
  %reduce_function_return_value_addr48 = alloca i8, align 1
  %arg_addr47 = alloca i8, align 1
  %arg_addr46 = alloca i8, align 1
  %reduce.19.inner.invar_address.reduction_dim.0 = alloca i64, align 8
  %accumulator_043 = alloca i8, align 1
  %fusion.27.invar_address.dim.0 = alloca i64, align 8
  %ret_value_addr = alloca %complex128, align 8
  %dynamic-update-slice.51.invar_address.dim.1 = alloca i64, align 8
  %dynamic-update-slice.51.invar_address.dim.0 = alloca i64, align 8
  %reduce_function_parameter_addresses = alloca i8*, i32 2, align 8
  %reduce_function_return_value_addr = alloca i8, align 1
  %arg_addr24 = alloca i8, align 1
  %arg_addr = alloca i8, align 1
  %reduce.18.inner.invar_address.reduction_dim.0 = alloca i64, align 8
  %accumulator_0 = alloca i8, align 1
  %fusion.13.invar_address.dim.0 = alloca i64, align 8
  %dot_acc20 = alloca double, align 8
  %dot.134.inner.invar_address = alloca i64, align 8
  %imag.116.invar_address.dim.0 = alloca i64, align 8
  %fusion.23.invar_address.dim.0 = alloca i64, align 8
  %dot_acc16 = alloca double, align 8
  %dot.138.inner.invar_address = alloca i64, align 8
  %imag.114.invar_address.dim.0 = alloca i64, align 8
  %dot_acc = alloca double, align 8
  %dot.136.inner.invar_address = alloca i64, align 8
  %imag.112.invar_address.dim.0 = alloca i64, align 8
  %subtract.17.invar_address.dim.0 = alloca i64, align 8
  %accum_address10 = alloca %complex128, align 8
  %dot.120.invar_address.reduction = alloca i64, align 8
  %dot.120.invar_address.lhs.0 = alloca i64, align 8
  %accum_address7 = alloca %complex128, align 8
  %dot.119.invar_address.reduction = alloca i64, align 8
  %dot.119.invar_address.lhs.1 = alloca i64, align 8
  %fusion.24.invar_address.dim.1 = alloca i64, align 8
  %fusion.24.invar_address.dim.0 = alloca i64, align 8
  %accum_address = alloca %complex128, align 8
  %dot.118.invar_address.reduction = alloca i64, align 8
  %dot.118.invar_address.lhs.0 = alloca i64, align 8
  %fusion.25.invar_address.dim.0 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 912
  %wide_param.47 = bitcast i8* %2 to [5 x i8*]*
  %3 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.47, i64 0, i64 4
  %4 = load i8*, i8** %3, align 8, !dereferenceable !50, !align !50
  %5 = bitcast i8* %4 to i64*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %8 = getelementptr inbounds i8, i8* %7, i64 624
  %copy.33 = bitcast i8* %8 to i64*
  %9 = bitcast i64* %copy.33 to i8*
  %10 = bitcast i64* %5 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %9, i8* align 1 %10, i64 8, i1 false)
  %11 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.47, i64 0, i64 1
  %12 = load i8*, i8** %11, align 8, !dereferenceable !69, !align !2
  %13 = bitcast i8* %12 to [3 x [3 x %complex128]]*
  %14 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %15 = load i8*, i8** %14, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.25 = bitcast i8* %15 to [3 x %complex128]*
  store i64 0, i64* %fusion.25.invar_address.dim.0, align 8
  br label %fusion.25.loop_header.dim.0

fusion.25.loop_header.dim.0:                      ; preds = %fusion.25.loop_body.dim.0, %entry
  %fusion.25.indvar.dim.0 = load i64, i64* %fusion.25.invar_address.dim.0, align 8
  %16 = icmp uge i64 %fusion.25.indvar.dim.0, 3
  br i1 %16, label %fusion.25.loop_exit.dim.0, label %fusion.25.loop_body.dim.0

fusion.25.loop_body.dim.0:                        ; preds = %fusion.25.loop_header.dim.0
  %constant.1493 = load i32, i32* bitcast ([4 x i8]* @18 to i32*), align 4
  %17 = sext i32 %constant.1493 to i64
  %18 = icmp sge i64 0, %17
  %19 = select i1 %18, i64 0, i64 %17
  %20 = icmp sle i64 0, %19
  %dynamic-slice.79.start_idx0 = select i1 %20, i64 0, i64 %19
  %21 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1492 = load i64, i64* bitcast ([8 x i8]* @19 to i64*), align 8
  %22 = icmp slt i64 %21, %constant.1492
  %23 = zext i1 %22 to i8
  %24 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1491 = load i64, i64* bitcast ([8 x i8]* @20 to i64*), align 8
  %25 = add i64 %24, %constant.1491
  %26 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %27 = trunc i8 %23 to i1
  %28 = select i1 %27, i64 %25, i64 %26
  %29 = trunc i64 %28 to i32
  %30 = sext i32 %29 to i64
  %31 = icmp sge i64 0, %30
  %32 = select i1 %31, i64 0, i64 %30
  %33 = icmp sle i64 2, %32
  %dynamic-slice.79.start_idx1 = select i1 %33, i64 2, i64 %32
  %34 = add i64 %dynamic-slice.79.start_idx0, %fusion.25.indvar.dim.0
  %35 = add i64 %dynamic-slice.79.start_idx1, 0
  %36 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %13, i64 0, i64 %34, i64 %35
  %37 = load %complex128, %complex128* %36, align 1, !alias.scope !84, !noalias !150
  %38 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.25, i64 0, i64 %fusion.25.indvar.dim.0
  store %complex128 %37, %complex128* %38, align 1, !alias.scope !97, !noalias !151
  %invar.inc = add nuw nsw i64 %fusion.25.indvar.dim.0, 1
  store i64 %invar.inc, i64* %fusion.25.invar_address.dim.0, align 8
  br label %fusion.25.loop_header.dim.0

fusion.25.loop_exit.dim.0:                        ; preds = %fusion.25.loop_header.dim.0
  %39 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.47, i64 0, i64 0
  %40 = load i8*, i8** %39, align 8, !dereferenceable !69, !align !2
  %41 = bitcast i8* %40 to [3 x [3 x %complex128]]*
  %42 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %43 = load i8*, i8** %42, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %44 = getelementptr inbounds i8, i8* %43, i64 528
  %dot.118 = bitcast i8* %44 to [3 x %complex128]*
  store i64 0, i64* %dot.118.invar_address.lhs.0, align 8
  br label %dot.118.loop_header.lhs.0

dot.118.loop_header.lhs.0:                        ; preds = %dot.118.loop_exit.reduction, %fusion.25.loop_exit.dim.0
  %dot.118.indvar.lhs.0 = load i64, i64* %dot.118.invar_address.lhs.0, align 8
  %45 = icmp uge i64 %dot.118.indvar.lhs.0, 3
  br i1 %45, label %dot.118.loop_exit.lhs.0, label %dot.118.loop_body.lhs.0

dot.118.loop_body.lhs.0:                          ; preds = %dot.118.loop_header.lhs.0
  store i64 0, i64* %dot.118.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address, align 1
  br label %dot.118.loop_header.reduction

dot.118.loop_header.reduction:                    ; preds = %dot.118.loop_body.reduction, %dot.118.loop_body.lhs.0
  %dot.118.indvar.reduction = load i64, i64* %dot.118.invar_address.reduction, align 8
  %46 = icmp uge i64 %dot.118.indvar.reduction, 3
  br i1 %46, label %dot.118.loop_exit.reduction, label %dot.118.loop_body.reduction

dot.118.loop_body.reduction:                      ; preds = %dot.118.loop_header.reduction
  %47 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %41, i64 0, i64 %dot.118.indvar.lhs.0, i64 %dot.118.indvar.reduction
  %48 = load %complex128, %complex128* %47, align 1, !alias.scope !153, !noalias !154
  %49 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.25, i64 0, i64 %dot.118.indvar.reduction
  %50 = load %complex128, %complex128* %49, align 1, !alias.scope !97, !noalias !151
  %51 = load %complex128, %complex128* %accum_address, align 1
  %52 = extractvalue %complex128 %48, 0
  %53 = extractvalue %complex128 %50, 0
  %54 = fmul reassoc nsz contract double %52, %53
  %55 = extractvalue %complex128 %48, 1
  %56 = extractvalue %complex128 %50, 1
  %57 = fmul reassoc nsz contract double %55, %56
  %58 = fsub reassoc nsz contract double %54, %57
  %59 = extractvalue %complex128 %48, 0
  %60 = extractvalue %complex128 %50, 1
  %61 = fmul reassoc nsz contract double %59, %60
  %62 = extractvalue %complex128 %48, 1
  %63 = extractvalue %complex128 %50, 0
  %64 = fmul reassoc nsz contract double %62, %63
  %65 = fadd reassoc nsz contract double %61, %64
  %66 = extractvalue %complex128 %51, 0
  %67 = fadd reassoc nsz contract double %66, %58
  %68 = insertvalue %complex128 %51, double %67, 0
  %69 = extractvalue %complex128 %51, 1
  %70 = fadd reassoc nsz contract double %69, %65
  %71 = insertvalue %complex128 %68, double %70, 1
  store %complex128 %71, %complex128* %accum_address, align 1
  %invar.inc2 = add nuw nsw i64 %dot.118.indvar.reduction, 1
  store i64 %invar.inc2, i64* %dot.118.invar_address.reduction, align 8
  br label %dot.118.loop_header.reduction, !llvm.loop !157

dot.118.loop_exit.reduction:                      ; preds = %dot.118.loop_header.reduction
  %72 = load %complex128, %complex128* %accum_address, align 1
  %73 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.118, i64 0, i64 %dot.118.indvar.lhs.0
  store %complex128 %72, %complex128* %73, align 1, !alias.scope !82, !noalias !158
  %invar.inc1 = add nuw nsw i64 %dot.118.indvar.lhs.0, 1
  store i64 %invar.inc1, i64* %dot.118.invar_address.lhs.0, align 8
  br label %dot.118.loop_header.lhs.0

dot.118.loop_exit.lhs.0:                          ; preds = %dot.118.loop_header.lhs.0
  %74 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %75 = load i8*, i8** %74, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.24 = bitcast i8* %75 to [3 x [3 x %complex128]]*
  store i64 0, i64* %fusion.24.invar_address.dim.0, align 8
  br label %fusion.24.loop_header.dim.0

fusion.24.loop_header.dim.0:                      ; preds = %fusion.24.loop_exit.dim.1, %dot.118.loop_exit.lhs.0
  %fusion.24.indvar.dim.0 = load i64, i64* %fusion.24.invar_address.dim.0, align 8
  %76 = icmp uge i64 %fusion.24.indvar.dim.0, 3
  br i1 %76, label %fusion.24.loop_exit.dim.0, label %fusion.24.loop_body.dim.0

fusion.24.loop_body.dim.0:                        ; preds = %fusion.24.loop_header.dim.0
  store i64 0, i64* %fusion.24.invar_address.dim.1, align 8
  br label %fusion.24.loop_header.dim.1

fusion.24.loop_header.dim.1:                      ; preds = %fusion.24.loop_body.dim.1, %fusion.24.loop_body.dim.0
  %fusion.24.indvar.dim.1 = load i64, i64* %fusion.24.invar_address.dim.1, align 8
  %77 = icmp uge i64 %fusion.24.indvar.dim.1, 3
  br i1 %77, label %fusion.24.loop_exit.dim.1, label %fusion.24.loop_body.dim.1

fusion.24.loop_body.dim.1:                        ; preds = %fusion.24.loop_header.dim.1
  %78 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %13, i64 0, i64 %fusion.24.indvar.dim.0, i64 %fusion.24.indvar.dim.1
  %79 = load %complex128, %complex128* %78, align 1, !alias.scope !84, !noalias !150
  %80 = extractvalue %complex128 %79, 0
  %81 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %13, i64 0, i64 %fusion.24.indvar.dim.0, i64 %fusion.24.indvar.dim.1
  %82 = load %complex128, %complex128* %81, align 1, !alias.scope !84, !noalias !150
  %83 = extractvalue %complex128 %82, 1
  %84 = fneg reassoc nsz contract double %83
  %85 = insertvalue %complex128 zeroinitializer, double %80, 0
  %86 = insertvalue %complex128 %85, double %84, 1
  %87 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %fusion.24, i64 0, i64 %fusion.24.indvar.dim.0, i64 %fusion.24.indvar.dim.1
  store %complex128 %86, %complex128* %87, align 1, !alias.scope !70, !noalias !72
  %invar.inc4 = add nuw nsw i64 %fusion.24.indvar.dim.1, 1
  store i64 %invar.inc4, i64* %fusion.24.invar_address.dim.1, align 8
  br label %fusion.24.loop_header.dim.1

fusion.24.loop_exit.dim.1:                        ; preds = %fusion.24.loop_header.dim.1
  %invar.inc3 = add nuw nsw i64 %fusion.24.indvar.dim.0, 1
  store i64 %invar.inc3, i64* %fusion.24.invar_address.dim.0, align 8
  br label %fusion.24.loop_header.dim.0

fusion.24.loop_exit.dim.0:                        ; preds = %fusion.24.loop_header.dim.0
  %88 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %89 = load i8*, i8** %88, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %dot.119 = bitcast i8* %89 to [3 x %complex128]*
  store i64 0, i64* %dot.119.invar_address.lhs.1, align 8
  br label %dot.119.loop_header.lhs.1

dot.119.loop_header.lhs.1:                        ; preds = %dot.119.loop_exit.reduction, %fusion.24.loop_exit.dim.0
  %dot.119.indvar.lhs.1 = load i64, i64* %dot.119.invar_address.lhs.1, align 8
  %90 = icmp uge i64 %dot.119.indvar.lhs.1, 3
  br i1 %90, label %dot.119.loop_exit.lhs.1, label %dot.119.loop_body.lhs.1

dot.119.loop_body.lhs.1:                          ; preds = %dot.119.loop_header.lhs.1
  store i64 0, i64* %dot.119.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address7, align 1
  br label %dot.119.loop_header.reduction

dot.119.loop_header.reduction:                    ; preds = %dot.119.loop_body.reduction, %dot.119.loop_body.lhs.1
  %dot.119.indvar.reduction = load i64, i64* %dot.119.invar_address.reduction, align 8
  %91 = icmp uge i64 %dot.119.indvar.reduction, 3
  br i1 %91, label %dot.119.loop_exit.reduction, label %dot.119.loop_body.reduction

dot.119.loop_body.reduction:                      ; preds = %dot.119.loop_header.reduction
  %92 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %fusion.24, i64 0, i64 %dot.119.indvar.reduction, i64 %dot.119.indvar.lhs.1
  %93 = load %complex128, %complex128* %92, align 1, !alias.scope !70, !noalias !72
  %94 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.118, i64 0, i64 %dot.119.indvar.reduction
  %95 = load %complex128, %complex128* %94, align 1, !alias.scope !82, !noalias !158
  %96 = load %complex128, %complex128* %accum_address7, align 1
  %97 = extractvalue %complex128 %93, 0
  %98 = extractvalue %complex128 %95, 0
  %99 = fmul reassoc nsz contract double %97, %98
  %100 = extractvalue %complex128 %93, 1
  %101 = extractvalue %complex128 %95, 1
  %102 = fmul reassoc nsz contract double %100, %101
  %103 = fsub reassoc nsz contract double %99, %102
  %104 = extractvalue %complex128 %93, 0
  %105 = extractvalue %complex128 %95, 1
  %106 = fmul reassoc nsz contract double %104, %105
  %107 = extractvalue %complex128 %93, 1
  %108 = extractvalue %complex128 %95, 0
  %109 = fmul reassoc nsz contract double %107, %108
  %110 = fadd reassoc nsz contract double %106, %109
  %111 = extractvalue %complex128 %96, 0
  %112 = fadd reassoc nsz contract double %111, %103
  %113 = insertvalue %complex128 %96, double %112, 0
  %114 = extractvalue %complex128 %96, 1
  %115 = fadd reassoc nsz contract double %114, %110
  %116 = insertvalue %complex128 %113, double %115, 1
  store %complex128 %116, %complex128* %accum_address7, align 1
  %invar.inc6 = add nuw nsw i64 %dot.119.indvar.reduction, 1
  store i64 %invar.inc6, i64* %dot.119.invar_address.reduction, align 8
  br label %dot.119.loop_header.reduction

dot.119.loop_exit.reduction:                      ; preds = %dot.119.loop_header.reduction
  %117 = load %complex128, %complex128* %accum_address7, align 1
  %118 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.119, i64 0, i64 %dot.119.indvar.lhs.1
  store %complex128 %117, %complex128* %118, align 1, !alias.scope !97, !noalias !159
  %invar.inc5 = add nuw nsw i64 %dot.119.indvar.lhs.1, 1
  store i64 %invar.inc5, i64* %dot.119.invar_address.lhs.1, align 8
  br label %dot.119.loop_header.lhs.1

dot.119.loop_exit.lhs.1:                          ; preds = %dot.119.loop_header.lhs.1
  %119 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %120 = load i8*, i8** %119, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %121 = getelementptr inbounds i8, i8* %120, i64 576
  %dot.120 = bitcast i8* %121 to [3 x %complex128]*
  store i64 0, i64* %dot.120.invar_address.lhs.0, align 8
  br label %dot.120.loop_header.lhs.0

dot.120.loop_header.lhs.0:                        ; preds = %dot.120.loop_exit.reduction, %dot.119.loop_exit.lhs.1
  %dot.120.indvar.lhs.0 = load i64, i64* %dot.120.invar_address.lhs.0, align 8
  %122 = icmp uge i64 %dot.120.indvar.lhs.0, 3
  br i1 %122, label %dot.120.loop_exit.lhs.0, label %dot.120.loop_body.lhs.0

dot.120.loop_body.lhs.0:                          ; preds = %dot.120.loop_header.lhs.0
  store i64 0, i64* %dot.120.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address10, align 1
  br label %dot.120.loop_header.reduction

dot.120.loop_header.reduction:                    ; preds = %dot.120.loop_body.reduction, %dot.120.loop_body.lhs.0
  %dot.120.indvar.reduction = load i64, i64* %dot.120.invar_address.reduction, align 8
  %123 = icmp uge i64 %dot.120.indvar.reduction, 3
  br i1 %123, label %dot.120.loop_exit.reduction, label %dot.120.loop_body.reduction

dot.120.loop_body.reduction:                      ; preds = %dot.120.loop_header.reduction
  %124 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %13, i64 0, i64 %dot.120.indvar.lhs.0, i64 %dot.120.indvar.reduction
  %125 = load %complex128, %complex128* %124, align 1, !alias.scope !84, !noalias !150
  %126 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.119, i64 0, i64 %dot.120.indvar.reduction
  %127 = load %complex128, %complex128* %126, align 1, !alias.scope !97, !noalias !159
  %128 = load %complex128, %complex128* %accum_address10, align 1
  %129 = extractvalue %complex128 %125, 0
  %130 = extractvalue %complex128 %127, 0
  %131 = fmul reassoc nsz contract double %129, %130
  %132 = extractvalue %complex128 %125, 1
  %133 = extractvalue %complex128 %127, 1
  %134 = fmul reassoc nsz contract double %132, %133
  %135 = fsub reassoc nsz contract double %131, %134
  %136 = extractvalue %complex128 %125, 0
  %137 = extractvalue %complex128 %127, 1
  %138 = fmul reassoc nsz contract double %136, %137
  %139 = extractvalue %complex128 %125, 1
  %140 = extractvalue %complex128 %127, 0
  %141 = fmul reassoc nsz contract double %139, %140
  %142 = fadd reassoc nsz contract double %138, %141
  %143 = extractvalue %complex128 %128, 0
  %144 = fadd reassoc nsz contract double %143, %135
  %145 = insertvalue %complex128 %128, double %144, 0
  %146 = extractvalue %complex128 %128, 1
  %147 = fadd reassoc nsz contract double %146, %142
  %148 = insertvalue %complex128 %145, double %147, 1
  store %complex128 %148, %complex128* %accum_address10, align 1
  %invar.inc9 = add nuw nsw i64 %dot.120.indvar.reduction, 1
  store i64 %invar.inc9, i64* %dot.120.invar_address.reduction, align 8
  br label %dot.120.loop_header.reduction, !llvm.loop !160

dot.120.loop_exit.reduction:                      ; preds = %dot.120.loop_header.reduction
  %149 = load %complex128, %complex128* %accum_address10, align 1
  %150 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.120, i64 0, i64 %dot.120.indvar.lhs.0
  store %complex128 %149, %complex128* %150, align 1, !alias.scope !88, !noalias !161
  %invar.inc8 = add nuw nsw i64 %dot.120.indvar.lhs.0, 1
  store i64 %invar.inc8, i64* %dot.120.invar_address.lhs.0, align 8
  br label %dot.120.loop_header.lhs.0

dot.120.loop_exit.lhs.0:                          ; preds = %dot.120.loop_header.lhs.0
  %151 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %152 = load i8*, i8** %151, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %153 = getelementptr inbounds i8, i8* %152, i64 480
  %subtract.17 = bitcast i8* %153 to [3 x %complex128]*
  store i64 0, i64* %subtract.17.invar_address.dim.0, align 8
  br label %subtract.17.loop_header.dim.0

subtract.17.loop_header.dim.0:                    ; preds = %subtract.17.loop_body.dim.0, %dot.120.loop_exit.lhs.0
  %subtract.17.indvar.dim.0 = load i64, i64* %subtract.17.invar_address.dim.0, align 8
  %154 = icmp uge i64 %subtract.17.indvar.dim.0, 3
  br i1 %154, label %subtract.17.loop_exit.dim.0, label %subtract.17.loop_body.dim.0

subtract.17.loop_body.dim.0:                      ; preds = %subtract.17.loop_header.dim.0
  %155 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.118, i64 0, i64 %subtract.17.indvar.dim.0
  %156 = load %complex128, %complex128* %155, align 1, !alias.scope !82, !noalias !158
  %157 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.120, i64 0, i64 %subtract.17.indvar.dim.0
  %158 = load %complex128, %complex128* %157, align 1, !alias.scope !88, !noalias !161
  %159 = extractvalue %complex128 %156, 0
  %160 = extractvalue %complex128 %158, 0
  %161 = fsub reassoc nsz contract double %159, %160
  %162 = extractvalue %complex128 %156, 1
  %163 = extractvalue %complex128 %158, 1
  %164 = fsub reassoc nsz contract double %162, %163
  %165 = insertvalue %complex128 zeroinitializer, double %161, 0
  %166 = insertvalue %complex128 %165, double %164, 1
  %167 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.17, i64 0, i64 %subtract.17.indvar.dim.0
  store %complex128 %166, %complex128* %167, align 1, !alias.scope !79, !noalias !162
  %invar.inc11 = add nuw nsw i64 %subtract.17.indvar.dim.0, 1
  store i64 %invar.inc11, i64* %subtract.17.invar_address.dim.0, align 8
  br label %subtract.17.loop_header.dim.0

subtract.17.loop_exit.dim.0:                      ; preds = %subtract.17.loop_header.dim.0
  %168 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %169 = load i8*, i8** %168, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %170 = getelementptr inbounds i8, i8* %169, i64 576
  %imag.112 = bitcast i8* %170 to [3 x double]*
  store i64 0, i64* %imag.112.invar_address.dim.0, align 8
  br label %imag.112.loop_header.dim.0

imag.112.loop_header.dim.0:                       ; preds = %imag.112.loop_body.dim.0, %subtract.17.loop_exit.dim.0
  %imag.112.indvar.dim.0 = load i64, i64* %imag.112.invar_address.dim.0, align 8
  %171 = icmp uge i64 %imag.112.indvar.dim.0, 3
  br i1 %171, label %imag.112.loop_exit.dim.0, label %imag.112.loop_body.dim.0

imag.112.loop_body.dim.0:                         ; preds = %imag.112.loop_header.dim.0
  %172 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.17, i64 0, i64 %imag.112.indvar.dim.0
  %173 = load %complex128, %complex128* %172, align 1, !alias.scope !79, !noalias !162
  %174 = extractvalue %complex128 %173, 1
  %175 = getelementptr inbounds [3 x double], [3 x double]* %imag.112, i64 0, i64 %imag.112.indvar.dim.0
  store double %174, double* %175, align 8, !alias.scope !92, !noalias !93
  %invar.inc12 = add nuw nsw i64 %imag.112.indvar.dim.0, 1
  store i64 %invar.inc12, i64* %imag.112.invar_address.dim.0, align 8
  br label %imag.112.loop_header.dim.0

imag.112.loop_exit.dim.0:                         ; preds = %imag.112.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc, align 8
  %176 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %177 = load i8*, i8** %176, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %178 = getelementptr inbounds i8, i8* %177, i64 608
  %fusion.19 = bitcast i8* %178 to double*
  store i64 0, i64* %dot.136.inner.invar_address, align 8
  br label %dot.136.inner.loop_header

dot.136.inner.loop_header:                        ; preds = %dot.136.inner.loop_body, %imag.112.loop_exit.dim.0
  %dot.136.inner.indvar = load i64, i64* %dot.136.inner.invar_address, align 8
  %179 = icmp uge i64 %dot.136.inner.indvar, 3
  br i1 %179, label %dot.136.inner.loop_exit, label %dot.136.inner.loop_body

dot.136.inner.loop_body:                          ; preds = %dot.136.inner.loop_header
  %180 = load double, double* %dot_acc, align 8
  %181 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.17, i64 0, i64 %dot.136.inner.indvar
  %182 = load %complex128, %complex128* %181, align 1, !alias.scope !79, !noalias !162
  %183 = extractvalue %complex128 %182, 0
  %184 = fmul reassoc nsz contract double %183, %183
  %185 = fadd reassoc nsz contract double %180, %184
  store double %185, double* %dot_acc, align 8
  %invar.inc13 = add nuw nsw i64 %dot.136.inner.indvar, 1
  store i64 %invar.inc13, i64* %dot.136.inner.invar_address, align 8
  br label %dot.136.inner.loop_header

dot.136.inner.loop_exit:                          ; preds = %dot.136.inner.loop_header
  %186 = load double, double* %dot_acc, align 8
  store double %186, double* %fusion.19, align 8, !alias.scope !94, !noalias !95
  %187 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %188 = load i8*, i8** %187, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %189 = getelementptr inbounds i8, i8* %188, i64 608
  %fusion.18 = bitcast i8* %189 to double*
  %190 = bitcast [3 x double]* %imag.112 to double*
  %191 = bitcast [3 x double]* %imag.112 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %190, double* %191, double* %fusion.19, double* %fusion.18)
  %192 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %193 = load i8*, i8** %192, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %194 = getelementptr inbounds i8, i8* %193, i64 608
  %fusion.17 = bitcast i8* %194 to double*
  %195 = load double, double* %fusion.18, align 8, !alias.scope !94, !noalias !92
  %196 = call reassoc nsz contract double @llvm.sqrt.f64(double %195)
  %constant.1486 = load double, double* bitcast ([8 x i8]* @21 to double*), align 8
  %compare.233 = fcmp reassoc nsz contract ogt double %196, %constant.1486
  %197 = zext i1 %compare.233 to i8
  %constant.1485 = load double, double* bitcast ([8 x i8]* @22 to double*), align 8
  %198 = trunc i8 %197 to i1
  %199 = select reassoc nsz contract i1 %198, double %196, double %constant.1485
  %constant.1484 = load double, double* bitcast ([8 x i8]* @23 to double*), align 8
  %multiply.33 = fmul reassoc nsz contract double %199, %constant.1484
  store double %multiply.33, double* %fusion.17, align 8, !alias.scope !94, !noalias !163
  %200 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %201 = load i8*, i8** %200, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %202 = getelementptr inbounds i8, i8* %201, i64 576
  %imag.114 = bitcast i8* %202 to [3 x double]*
  store i64 0, i64* %imag.114.invar_address.dim.0, align 8
  br label %imag.114.loop_header.dim.0

imag.114.loop_header.dim.0:                       ; preds = %imag.114.loop_body.dim.0, %dot.136.inner.loop_exit
  %imag.114.indvar.dim.0 = load i64, i64* %imag.114.invar_address.dim.0, align 8
  %203 = icmp uge i64 %imag.114.indvar.dim.0, 3
  br i1 %203, label %imag.114.loop_exit.dim.0, label %imag.114.loop_body.dim.0

imag.114.loop_body.dim.0:                         ; preds = %imag.114.loop_header.dim.0
  %204 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.118, i64 0, i64 %imag.114.indvar.dim.0
  %205 = load %complex128, %complex128* %204, align 1, !alias.scope !82, !noalias !158
  %206 = extractvalue %complex128 %205, 1
  %207 = getelementptr inbounds [3 x double], [3 x double]* %imag.114, i64 0, i64 %imag.114.indvar.dim.0
  store double %206, double* %207, align 8, !alias.scope !92, !noalias !164
  %invar.inc14 = add nuw nsw i64 %imag.114.indvar.dim.0, 1
  store i64 %invar.inc14, i64* %imag.114.invar_address.dim.0, align 8
  br label %imag.114.loop_header.dim.0

imag.114.loop_exit.dim.0:                         ; preds = %imag.114.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc16, align 8
  %208 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %209 = load i8*, i8** %208, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %210 = getelementptr inbounds i8, i8* %209, i64 752
  %fusion.22 = bitcast i8* %210 to double*
  store i64 0, i64* %dot.138.inner.invar_address, align 8
  br label %dot.138.inner.loop_header

dot.138.inner.loop_header:                        ; preds = %dot.138.inner.loop_body, %imag.114.loop_exit.dim.0
  %dot.138.inner.indvar = load i64, i64* %dot.138.inner.invar_address, align 8
  %211 = icmp uge i64 %dot.138.inner.indvar, 3
  br i1 %211, label %dot.138.inner.loop_exit, label %dot.138.inner.loop_body

dot.138.inner.loop_body:                          ; preds = %dot.138.inner.loop_header
  %212 = load double, double* %dot_acc16, align 8
  %213 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.118, i64 0, i64 %dot.138.inner.indvar
  %214 = load %complex128, %complex128* %213, align 1, !alias.scope !82, !noalias !158
  %215 = extractvalue %complex128 %214, 0
  %216 = fmul reassoc nsz contract double %215, %215
  %217 = fadd reassoc nsz contract double %212, %216
  store double %217, double* %dot_acc16, align 8
  %invar.inc15 = add nuw nsw i64 %dot.138.inner.indvar, 1
  store i64 %invar.inc15, i64* %dot.138.inner.invar_address, align 8
  br label %dot.138.inner.loop_header

dot.138.inner.loop_exit:                          ; preds = %dot.138.inner.loop_header
  %218 = load double, double* %dot_acc16, align 8
  store double %218, double* %fusion.22, align 8, !alias.scope !165, !noalias !166
  %219 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %220 = load i8*, i8** %219, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %221 = getelementptr inbounds i8, i8* %220, i64 752
  %fusion.21 = bitcast i8* %221 to double*
  %222 = bitcast [3 x double]* %imag.114 to double*
  %223 = bitcast [3 x double]* %imag.114 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %222, double* %223, double* %fusion.22, double* %fusion.21)
  %224 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %225 = load i8*, i8** %224, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %226 = getelementptr inbounds i8, i8* %225, i64 752
  %sqrt.36 = bitcast i8* %226 to double*
  %227 = load double, double* %fusion.21, align 8, !alias.scope !165, !noalias !92
  %228 = call reassoc nsz contract double @llvm.sqrt.f64(double %227)
  store double %228, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %229 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %230 = load i8*, i8** %229, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %231 = getelementptr inbounds i8, i8* %230, i64 736
  %fusion.20 = bitcast i8* %231 to double*
  %232 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1489 = load double, double* bitcast ([8 x i8]* @24 to double*), align 8
  %compare.235 = fcmp reassoc nsz contract ogt double %232, %constant.1489
  %233 = zext i1 %compare.235 to i8
  %234 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1488 = load double, double* bitcast ([8 x i8]* @25 to double*), align 8
  %235 = trunc i8 %233 to i1
  %236 = select reassoc nsz contract i1 %235, double %234, double %constant.1488
  %constant.1487 = load double, double* bitcast ([8 x i8]* @26 to double*), align 8
  %multiply.34 = fmul reassoc nsz contract double %236, %constant.1487
  store double %multiply.34, double* %fusion.20, align 8, !alias.scope !128, !noalias !168
  %237 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %238 = load i8*, i8** %237, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %copy.67 = getelementptr inbounds i8, i8* %238, i64 720
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %copy.67, i8* align 1 getelementptr inbounds ([1 x i8], [1 x i8]* @9, i32 0, i32 0), i64 1, i1 false)
  %239 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %240 = load i8*, i8** %239, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %241 = getelementptr inbounds i8, i8* %240, i64 832
  %tuple.295 = bitcast i8* %241 to [3 x i8*]*
  %242 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.295, i64 0, i64 0
  store i8* %copy.67, i8** %242, align 8, !alias.scope !51, !noalias !53
  %243 = bitcast double* %fusion.20 to i8*
  %244 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.295, i64 0, i64 1
  store i8* %243, i8** %244, align 8, !alias.scope !51, !noalias !53
  %245 = bitcast double* %fusion.17 to i8*
  %246 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.295, i64 0, i64 2
  store i8* %245, i8** %246, align 8, !alias.scope !51, !noalias !53
  br label %while.92.header

while.92.header:                                  ; preds = %while.92.body, %dot.138.inner.loop_exit
  call void @wide.cond_computation__12.182.clone.1.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %247 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %248 = load i8*, i8** %247, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %249 = getelementptr inbounds i8, i8* %248, i64 720
  %250 = load i8, i8* %249, align 1
  %251 = icmp ne i8 %250, 0
  br i1 %251, label %while.92.body, label %while.92.exit

while.92.body:                                    ; preds = %while.92.header
  call void @wide.body_computation__12.149.clone.1.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.92.header

while.92.exit:                                    ; preds = %while.92.header
  %252 = getelementptr inbounds [3 x i8*], [3 x i8*]* %tuple.295, i64 0, i64 1
  %253 = load i8*, i8** %252, align 8, !dereferenceable !50, !align !50
  %254 = bitcast i8* %253 to double*
  %255 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %256 = load i8*, i8** %255, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.23 = bitcast i8* %256 to [3 x %complex128]*
  store i64 0, i64* %fusion.23.invar_address.dim.0, align 8
  br label %fusion.23.loop_header.dim.0

fusion.23.loop_header.dim.0:                      ; preds = %fusion.23.loop_body.dim.0, %while.92.exit
  %fusion.23.indvar.dim.0 = load i64, i64* %fusion.23.invar_address.dim.0, align 8
  %257 = icmp uge i64 %fusion.23.indvar.dim.0, 3
  br i1 %257, label %fusion.23.loop_exit.dim.0, label %fusion.23.loop_body.dim.0

fusion.23.loop_body.dim.0:                        ; preds = %fusion.23.loop_header.dim.0
  %constant.1490 = load %complex128, %complex128* bitcast ([16 x i8]* @27 to %complex128*), align 1
  %258 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.119, i64 0, i64 %fusion.23.indvar.dim.0
  %259 = load %complex128, %complex128* %258, align 1, !alias.scope !97, !noalias !159
  %260 = extractvalue %complex128 %constant.1490, 0
  %261 = extractvalue %complex128 %259, 0
  %262 = fadd reassoc nsz contract double %260, %261
  %263 = extractvalue %complex128 %constant.1490, 1
  %264 = extractvalue %complex128 %259, 1
  %265 = fadd reassoc nsz contract double %263, %264
  %266 = insertvalue %complex128 zeroinitializer, double %262, 0
  %267 = insertvalue %complex128 %266, double %265, 1
  %268 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.23, i64 0, i64 %fusion.23.indvar.dim.0
  store %complex128 %267, %complex128* %268, align 1, !alias.scope !97, !noalias !169
  %invar.inc17 = add nuw nsw i64 %fusion.23.indvar.dim.0, 1
  store i64 %invar.inc17, i64* %fusion.23.invar_address.dim.0, align 8
  br label %fusion.23.loop_header.dim.0

fusion.23.loop_exit.dim.0:                        ; preds = %fusion.23.loop_header.dim.0
  %269 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %270 = load i8*, i8** %269, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %271 = getelementptr inbounds i8, i8* %270, i64 720
  %copy.12 = bitcast i8* %271 to i64*
  %272 = bitcast i64* %copy.12 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %272, i8* align 1 getelementptr inbounds ([8 x i8], [8 x i8]* @2, i32 0, i32 0), i64 8, i1 false)
  %273 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %274 = load i8*, i8** %273, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %275 = getelementptr inbounds i8, i8* %274, i64 960
  %tuple.298 = bitcast i8* %275 to [6 x i8*]*
  %276 = bitcast [3 x [3 x %complex128]]* %13 to i8*
  %277 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 0
  store i8* %276, i8** %277, align 8, !alias.scope !105, !noalias !106
  %278 = bitcast i64* %copy.12 to i8*
  %279 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 1
  store i8* %278, i8** %279, align 8, !alias.scope !105, !noalias !106
  %280 = bitcast [3 x %complex128]* %subtract.17 to i8*
  %281 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 2
  store i8* %280, i8** %281, align 8, !alias.scope !105, !noalias !106
  %282 = bitcast [3 x %complex128]* %fusion.23 to i8*
  %283 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 3
  store i8* %282, i8** %283, align 8, !alias.scope !105, !noalias !106
  %284 = bitcast double* %254 to i8*
  %285 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 4
  store i8* %284, i8** %285, align 8, !alias.scope !105, !noalias !106
  %286 = bitcast [3 x [3 x %complex128]]* %fusion.24 to i8*
  %287 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 5
  store i8* %286, i8** %287, align 8, !alias.scope !105, !noalias !106
  br label %while.93.header

while.93.header:                                  ; preds = %while.93.body, %fusion.23.loop_exit.dim.0
  call void @wide.cond_computation__13.309.clone.1.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %288 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %289 = load i8*, i8** %288, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %290 = getelementptr inbounds i8, i8* %289, i64 528
  %291 = load i8, i8* %290, align 1
  %292 = icmp ne i8 %291, 0
  br i1 %292, label %while.93.body, label %while.93.exit

while.93.body:                                    ; preds = %while.93.header
  call void @wide.body_computation__13.259.clone.1.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.93.header

while.93.exit:                                    ; preds = %while.93.header
  %293 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 2
  %294 = load i8*, i8** %293, align 8, !dereferenceable !25, !align !2
  %295 = bitcast i8* %294 to [3 x %complex128]*
  %296 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %297 = load i8*, i8** %296, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %298 = getelementptr inbounds i8, i8* %297, i64 528
  %imag.116 = bitcast i8* %298 to [3 x double]*
  store i64 0, i64* %imag.116.invar_address.dim.0, align 8
  br label %imag.116.loop_header.dim.0

imag.116.loop_header.dim.0:                       ; preds = %imag.116.loop_body.dim.0, %while.93.exit
  %imag.116.indvar.dim.0 = load i64, i64* %imag.116.invar_address.dim.0, align 8
  %299 = icmp uge i64 %imag.116.indvar.dim.0, 3
  br i1 %299, label %imag.116.loop_exit.dim.0, label %imag.116.loop_body.dim.0

imag.116.loop_body.dim.0:                         ; preds = %imag.116.loop_header.dim.0
  %300 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %295, i64 0, i64 %imag.116.indvar.dim.0
  %301 = load %complex128, %complex128* %300, align 1, !alias.scope !79, !noalias !170
  %302 = extractvalue %complex128 %301, 1
  %303 = getelementptr inbounds [3 x double], [3 x double]* %imag.116, i64 0, i64 %imag.116.indvar.dim.0
  store double %302, double* %303, align 8, !alias.scope !121, !noalias !171
  %invar.inc18 = add nuw nsw i64 %imag.116.indvar.dim.0, 1
  store i64 %invar.inc18, i64* %imag.116.invar_address.dim.0, align 8
  br label %imag.116.loop_header.dim.0

imag.116.loop_exit.dim.0:                         ; preds = %imag.116.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc20, align 8
  %304 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %305 = load i8*, i8** %304, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %306 = getelementptr inbounds i8, i8* %305, i64 736
  %fusion.16 = bitcast i8* %306 to double*
  store i64 0, i64* %dot.134.inner.invar_address, align 8
  br label %dot.134.inner.loop_header

dot.134.inner.loop_header:                        ; preds = %dot.134.inner.loop_body, %imag.116.loop_exit.dim.0
  %dot.134.inner.indvar = load i64, i64* %dot.134.inner.invar_address, align 8
  %307 = icmp uge i64 %dot.134.inner.indvar, 3
  br i1 %307, label %dot.134.inner.loop_exit, label %dot.134.inner.loop_body

dot.134.inner.loop_body:                          ; preds = %dot.134.inner.loop_header
  %308 = load double, double* %dot_acc20, align 8
  %309 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %295, i64 0, i64 %dot.134.inner.indvar
  %310 = load %complex128, %complex128* %309, align 1, !alias.scope !79, !noalias !170
  %311 = extractvalue %complex128 %310, 0
  %312 = fmul reassoc nsz contract double %311, %311
  %313 = fadd reassoc nsz contract double %308, %312
  store double %313, double* %dot_acc20, align 8
  %invar.inc19 = add nuw nsw i64 %dot.134.inner.indvar, 1
  store i64 %invar.inc19, i64* %dot.134.inner.invar_address, align 8
  br label %dot.134.inner.loop_header

dot.134.inner.loop_exit:                          ; preds = %dot.134.inner.loop_header
  %314 = load double, double* %dot_acc20, align 8
  store double %314, double* %fusion.16, align 8, !alias.scope !128, !noalias !172
  %315 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %316 = load i8*, i8** %315, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %317 = getelementptr inbounds i8, i8* %316, i64 736
  %fusion.15 = bitcast i8* %317 to double*
  %318 = bitcast [3 x double]* %imag.116 to double*
  %319 = bitcast [3 x double]* %imag.116 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %318, double* %319, double* %fusion.16, double* %fusion.15)
  %320 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %321 = load i8*, i8** %320, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %322 = getelementptr inbounds i8, i8* %321, i64 736
  %sqrt.37 = bitcast i8* %322 to double*
  %323 = load double, double* %fusion.15, align 8, !alias.scope !128, !noalias !121
  %324 = call reassoc nsz contract double @llvm.sqrt.f64(double %323)
  store double %324, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %325 = getelementptr inbounds [6 x i8*], [6 x i8*]* %tuple.298, i64 0, i64 3
  %326 = load i8*, i8** %325, align 8, !dereferenceable !25, !align !2
  %327 = bitcast i8* %326 to [3 x %complex128]*
  %328 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %329 = load i8*, i8** %328, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %330 = getelementptr inbounds i8, i8* %329, i64 720
  %fusion.13 = bitcast i8* %330 to [2 x i32]*
  store i64 0, i64* %fusion.13.invar_address.dim.0, align 8
  br label %fusion.13.loop_header.dim.0

fusion.13.loop_header.dim.0:                      ; preds = %concatenate.40.merge, %dot.134.inner.loop_exit
  %fusion.13.indvar.dim.0 = load i64, i64* %fusion.13.invar_address.dim.0, align 8
  %331 = icmp uge i64 %fusion.13.indvar.dim.0, 2
  br i1 %331, label %fusion.13.loop_exit.dim.0, label %fusion.13.loop_body.dim.0

fusion.13.loop_body.dim.0:                        ; preds = %fusion.13.loop_header.dim.0
  %332 = icmp ult i64 %fusion.13.indvar.dim.0, 1
  br i1 %332, label %concat_index_from_operand_id0, label %concat_index_not_from_operand0

concat_index_from_operand_id0:                    ; preds = %fusion.13.loop_body.dim.0
  %333 = phi i64 [ 0, %fusion.13.loop_body.dim.0 ]
  %334 = sub nsw i64 %fusion.13.indvar.dim.0, %333
  %335 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1475 = load i64, i64* bitcast ([8 x i8]* @28 to i64*), align 8
  %336 = icmp slt i64 %335, %constant.1475
  %337 = zext i1 %336 to i8
  %338 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1474 = load i64, i64* bitcast ([8 x i8]* @29 to i64*), align 8
  %339 = add i64 %338, %constant.1474
  %340 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %341 = trunc i8 %337 to i1
  %342 = select i1 %341, i64 %339, i64 %340
  %343 = trunc i64 %342 to i32
  br label %concatenate.40.merge

concat_index_from_operand_id1:                    ; preds = %concat_index_not_from_operand0
  %344 = phi i64 [ 1, %concat_index_not_from_operand0 ]
  %345 = sub nsw i64 %fusion.13.indvar.dim.0, %344
  %constant.1476 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* bitcast ([4 x i8]* @30 to [1 x i32]*), i64 0, i64 0), align 4
  br label %concatenate.40.merge

concat_index_not_from_operand0:                   ; preds = %fusion.13.loop_body.dim.0
  %346 = icmp ult i64 %fusion.13.indvar.dim.0, 2
  br i1 %346, label %concat_index_from_operand_id1, label %concat_index_not_from_operand1

concat_index_not_from_operand1:                   ; preds = %concat_index_not_from_operand0
  unreachable

concatenate.40.merge:                             ; preds = %concat_index_from_operand_id1, %concat_index_from_operand_id0
  %347 = phi i32 [ %343, %concat_index_from_operand_id0 ], [ %constant.1476, %concat_index_from_operand_id1 ]
  %348 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.13, i64 0, i64 %fusion.13.indvar.dim.0
  store i32 %347, i32* %348, align 4, !alias.scope !103, !noalias !174
  %invar.inc21 = add nuw nsw i64 %fusion.13.indvar.dim.0, 1
  store i64 %invar.inc21, i64* %fusion.13.invar_address.dim.0, align 8
  br label %fusion.13.loop_header.dim.0

fusion.13.loop_exit.dim.0:                        ; preds = %fusion.13.loop_header.dim.0
  %349 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %350 = load i8*, i8** %349, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.12 = getelementptr inbounds i8, i8* %350, i64 528
  %constant.1472 = load i8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @31, i32 0, i32 0), align 1
  store i8 %constant.1472, i8* %accumulator_0, align 1
  store i64 0, i64* %reduce.18.inner.invar_address.reduction_dim.0, align 8
  br label %reduce.18.inner.loop_header.reduction_dim.0

reduce.18.inner.loop_header.reduction_dim.0:      ; preds = %reduce.18.inner.loop_body.reduction_dim.0, %fusion.13.loop_exit.dim.0
  %reduce.18.inner.indvar.reduction_dim.0 = load i64, i64* %reduce.18.inner.invar_address.reduction_dim.0, align 8
  %351 = icmp uge i64 %reduce.18.inner.indvar.reduction_dim.0, 2
  br i1 %351, label %reduce.18.inner.loop_exit.reduction_dim.0, label %reduce.18.inner.loop_body.reduction_dim.0

reduce.18.inner.loop_body.reduction_dim.0:        ; preds = %reduce.18.inner.loop_header.reduction_dim.0
  %352 = load i8, i8* %accumulator_0, align 1
  %constant.1473 = load i32, i32* bitcast ([4 x i8]* @32 to i32*), align 4
  %353 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.13, i64 0, i64 %reduce.18.inner.indvar.reduction_dim.0
  %354 = load i32, i32* %353, align 4, !alias.scope !103, !noalias !174
  %355 = icmp sle i32 %constant.1473, %354
  %356 = zext i1 %355 to i8
  %constant.1471 = getelementptr inbounds [2 x i32], [2 x i32]* bitcast ([8 x i8]* @33 to [2 x i32]*), i64 0, i64 %reduce.18.inner.indvar.reduction_dim.0
  %constant.147123 = load i32, i32* %constant.1471, align 4
  %357 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.13, i64 0, i64 %reduce.18.inner.indvar.reduction_dim.0
  %358 = load i32, i32* %357, align 4, !alias.scope !103, !noalias !174
  %359 = icmp sge i32 %constant.147123, %358
  %360 = zext i1 %359 to i8
  %361 = and i8 %356, %360
  store i8 %352, i8* %arg_addr, align 1
  store i8 %361, i8* %arg_addr24, align 1
  %362 = getelementptr inbounds i8*, i8** %reduce_function_parameter_addresses, i64 0
  store i8* %arg_addr, i8** %362, align 8
  %363 = getelementptr inbounds i8*, i8** %reduce_function_parameter_addresses, i64 1
  store i8* %arg_addr24, i8** %363, align 8
  call void @and.reduce_sub_computation.2(i8* %reduce_function_return_value_addr, i8* %run_options, i8** %reduce_function_parameter_addresses, i8** null, i64* %prof_counters)
  %364 = load i8, i8* %reduce_function_return_value_addr, align 1
  store i8 %364, i8* %accumulator_0, align 1
  %invar.inc22 = add nuw nsw i64 %reduce.18.inner.indvar.reduction_dim.0, 1
  store i64 %invar.inc22, i64* %reduce.18.inner.invar_address.reduction_dim.0, align 8
  br label %reduce.18.inner.loop_header.reduction_dim.0

reduce.18.inner.loop_exit.reduction_dim.0:        ; preds = %reduce.18.inner.loop_header.reduction_dim.0
  %365 = load i8, i8* %accumulator_0, align 1
  store i8 %365, i8* %fusion.12, align 1, !alias.scope !130, !noalias !175
  %366 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.47, i64 0, i64 2
  %367 = load i8*, i8** %366, align 8, !dereferenceable !176, !align !2
  %368 = bitcast i8* %367 to [2 x [3 x %complex128]]*
  %369 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %370 = load i8*, i8** %369, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %371 = getelementptr inbounds i8, i8* %370, i64 384
  %fusion.11 = bitcast i8* %371 to [2 x [3 x %complex128]]*
  %372 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1468 = load i64, i64* bitcast ([8 x i8]* @34 to i64*), align 8
  %373 = icmp slt i64 %372, %constant.1468
  %374 = zext i1 %373 to i8
  %375 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1464 = load i64, i64* bitcast ([8 x i8]* @35 to i64*), align 8
  %376 = add i64 %375, %constant.1464
  %377 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %378 = trunc i8 %374 to i1
  %379 = select i1 %378, i64 %376, i64 %377
  %380 = trunc i64 %379 to i32
  %381 = icmp sge i32 0, %380
  %382 = select i1 %381, i32 0, i32 %380
  %383 = icmp sle i32 1, %382
  %384 = select i1 %383, i32 1, i32 %382
  %constant.1470 = load i32, i32* bitcast ([4 x i8]* @36 to i32*), align 4
  %385 = icmp sge i32 0, %constant.1470
  %386 = select i1 %385, i32 0, i32 %constant.1470
  %387 = icmp sle i32 0, %386
  %388 = select i1 %387, i32 0, i32 %386
  store i64 0, i64* %dynamic-update-slice.51.invar_address.dim.0, align 8
  br label %dynamic-update-slice.51.loop_header.dim.0

dynamic-update-slice.51.loop_header.dim.0:        ; preds = %dynamic-update-slice.51.loop_exit.dim.1, %reduce.18.inner.loop_exit.reduction_dim.0
  %dynamic-update-slice.51.indvar.dim.0 = load i64, i64* %dynamic-update-slice.51.invar_address.dim.0, align 8
  %389 = icmp uge i64 %dynamic-update-slice.51.indvar.dim.0, 1
  br i1 %389, label %dynamic-update-slice.51.loop_exit.dim.0, label %dynamic-update-slice.51.loop_body.dim.0

dynamic-update-slice.51.loop_body.dim.0:          ; preds = %dynamic-update-slice.51.loop_header.dim.0
  store i64 0, i64* %dynamic-update-slice.51.invar_address.dim.1, align 8
  br label %dynamic-update-slice.51.loop_header.dim.1

dynamic-update-slice.51.loop_header.dim.1:        ; preds = %slice_intersection-after, %dynamic-update-slice.51.loop_body.dim.0
  %dynamic-update-slice.51.indvar.dim.1 = load i64, i64* %dynamic-update-slice.51.invar_address.dim.1, align 8
  %390 = icmp uge i64 %dynamic-update-slice.51.indvar.dim.1, 3
  br i1 %390, label %dynamic-update-slice.51.loop_exit.dim.1, label %dynamic-update-slice.51.loop_body.dim.1

dynamic-update-slice.51.loop_body.dim.1:          ; preds = %dynamic-update-slice.51.loop_header.dim.1
  %391 = sext i32 %384 to i64
  %392 = add i64 %391, %dynamic-update-slice.51.indvar.dim.0
  %393 = sext i32 %388 to i64
  %394 = add i64 %393, %dynamic-update-slice.51.indvar.dim.1
  %395 = load i8, i8* %fusion.12, align 1, !alias.scope !130, !noalias !175
  %396 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1469 = load i64, i64* bitcast ([8 x i8]* @37 to i64*), align 8
  %397 = add i64 %396, %constant.1469
  %constant.146827 = load i64, i64* bitcast ([8 x i8]* @38 to i64*), align 8
  %398 = icmp slt i64 %397, %constant.146827
  %399 = zext i1 %398 to i8
  %400 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1467 = load i64, i64* bitcast ([8 x i8]* @39 to i64*), align 8
  %401 = add i64 %400, %constant.1467
  %402 = trunc i8 %399 to i1
  %403 = select i1 %402, i64 %401, i64 %397
  %404 = trunc i64 %403 to i32
  %405 = sext i32 %404 to i64
  %406 = icmp sge i64 0, %405
  %407 = select i1 %406, i64 0, i64 %405
  %408 = icmp sle i64 2, %407
  %dynamic-update-slice.52.start_idx0 = select i1 %408, i64 2, i64 %407
  %409 = add i64 %dynamic-update-slice.52.start_idx0, 1
  %410 = icmp sge i64 %dynamic-update-slice.51.indvar.dim.1, %dynamic-update-slice.52.start_idx0
  %slice_intersection = and i1 true, %410
  %411 = icmp slt i64 %dynamic-update-slice.51.indvar.dim.1, %409
  %slice_intersection28 = and i1 %slice_intersection, %411
  br i1 %slice_intersection28, label %slice_intersection-true, label %slice_intersection-false

slice_intersection-after:                         ; preds = %slice_intersection-false, %slice_intersection-true
  %412 = load %complex128, %complex128* %ret_value_addr, align 1
  %413 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.146835 = load i64, i64* bitcast ([8 x i8]* @49 to i64*), align 8
  %414 = icmp slt i64 %413, %constant.146835
  %415 = zext i1 %414 to i8
  %416 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.146436 = load i64, i64* bitcast ([8 x i8]* @50 to i64*), align 8
  %417 = add i64 %416, %constant.146436
  %418 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %419 = trunc i8 %415 to i1
  %420 = select i1 %419, i64 %417, i64 %418
  %421 = trunc i64 %420 to i32
  %422 = sext i32 %421 to i64
  %423 = icmp sge i64 0, %422
  %424 = select i1 %423, i64 0, i64 %422
  %425 = icmp sle i64 1, %424
  %dynamic-slice.76.start_idx0 = select i1 %425, i64 1, i64 %424
  %constant.147037 = load i32, i32* bitcast ([4 x i8]* @51 to i32*), align 4
  %426 = sext i32 %constant.147037 to i64
  %427 = icmp sge i64 0, %426
  %428 = select i1 %427, i64 0, i64 %426
  %429 = icmp sle i64 0, %428
  %dynamic-slice.76.start_idx1 = select i1 %429, i64 0, i64 %428
  %430 = add i64 %dynamic-slice.76.start_idx0, %dynamic-update-slice.51.indvar.dim.0
  %431 = add i64 %dynamic-slice.76.start_idx1, %dynamic-update-slice.51.indvar.dim.1
  %432 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %368, i64 0, i64 %430, i64 %431
  %433 = load %complex128, %complex128* %432, align 1, !alias.scope !177, !noalias !178
  %434 = trunc i8 %395 to i1
  %435 = select i1 %434, %complex128 %412, %complex128 %433
  %436 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %fusion.11, i64 0, i64 %392, i64 %394
  store %complex128 %435, %complex128* %436, align 1, !alias.scope !177, !noalias !179
  %invar.inc26 = add nuw nsw i64 %dynamic-update-slice.51.indvar.dim.1, 1
  store i64 %invar.inc26, i64* %dynamic-update-slice.51.invar_address.dim.1, align 8
  br label %dynamic-update-slice.51.loop_header.dim.1

dynamic-update-slice.51.loop_exit.dim.1:          ; preds = %dynamic-update-slice.51.loop_header.dim.1
  %invar.inc25 = add nuw nsw i64 %dynamic-update-slice.51.indvar.dim.0, 1
  store i64 %invar.inc25, i64* %dynamic-update-slice.51.invar_address.dim.0, align 8
  br label %dynamic-update-slice.51.loop_header.dim.0

dynamic-update-slice.51.loop_exit.dim.0:          ; preds = %dynamic-update-slice.51.loop_header.dim.0
  %437 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %438 = load i8*, i8** %437, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.27 = bitcast i8* %438 to [2 x i32]*
  store i64 0, i64* %fusion.27.invar_address.dim.0, align 8
  br label %fusion.27.loop_header.dim.0

slice_intersection-true:                          ; preds = %dynamic-update-slice.51.loop_body.dim.1
  %439 = sub i64 %dynamic-update-slice.51.indvar.dim.1, %dynamic-update-slice.52.start_idx0
  %constant.147029 = load i32, i32* bitcast ([4 x i8]* @40 to i32*), align 4
  %440 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.146930 = load i64, i64* bitcast ([8 x i8]* @41 to i64*), align 8
  %441 = add i64 %440, %constant.146930
  %constant.146831 = load i64, i64* bitcast ([8 x i8]* @42 to i64*), align 8
  %442 = icmp slt i64 %441, %constant.146831
  %443 = zext i1 %442 to i8
  %444 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.146732 = load i64, i64* bitcast ([8 x i8]* @43 to i64*), align 8
  %445 = add i64 %444, %constant.146732
  %446 = trunc i8 %443 to i1
  %447 = select i1 %446, i64 %445, i64 %441
  %448 = trunc i64 %447 to i32
  %449 = icmp sle i32 %constant.147029, %448
  %450 = zext i1 %449 to i8
  %constant.1463 = load i32, i32* bitcast ([4 x i8]* @44 to i32*), align 4
  %451 = icmp sge i32 %constant.1463, %448
  %452 = zext i1 %451 to i8
  %453 = and i8 %450, %452
  %454 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %455 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1466 = load double, double* bitcast ([8 x i8]* @45 to double*), align 8
  %compare.224 = fcmp reassoc nsz contract ogt double %455, %constant.1466
  %456 = zext i1 %compare.224 to i8
  %457 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1465 = load double, double* bitcast ([8 x i8]* @46 to double*), align 8
  %458 = trunc i8 %456 to i1
  %459 = select reassoc nsz contract i1 %458, double %457, double %constant.1465
  %constant.146633 = load double, double* bitcast ([8 x i8]* @47 to double*), align 8
  %multiply.31 = fmul reassoc nsz contract double %459, %constant.146633
  %460 = insertvalue %complex128 zeroinitializer, double %multiply.31, 0
  %461 = extractvalue %complex128 %460, 0
  %compare.223 = fcmp reassoc nsz contract ogt double %454, %461
  %462 = zext i1 %compare.223 to i8
  %463 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %constant.146534 = load double, double* bitcast ([8 x i8]* @48 to double*), align 8
  %464 = trunc i8 %462 to i1
  %465 = select reassoc nsz contract i1 %464, double %463, double %constant.146534
  %466 = insertvalue %complex128 zeroinitializer, double %465, 0
  %467 = sext i32 %448 to i64
  %468 = icmp sge i64 0, %467
  %469 = select i1 %468, i64 0, i64 %467
  %470 = icmp sle i64 2, %469
  %dynamic-slice.77.start_idx0 = select i1 %470, i64 2, i64 %469
  %471 = add i64 %dynamic-slice.77.start_idx0, %439
  %472 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %327, i64 0, i64 %471
  %473 = load %complex128, %complex128* %472, align 1, !alias.scope !97, !noalias !180
  %474 = trunc i8 %453 to i1
  %475 = select i1 %474, %complex128 %466, %complex128 %473
  store %complex128 %475, %complex128* %ret_value_addr, align 1
  br label %slice_intersection-after

slice_intersection-false:                         ; preds = %dynamic-update-slice.51.loop_body.dim.1
  %476 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %327, i64 0, i64 %dynamic-update-slice.51.indvar.dim.1
  %477 = load %complex128, %complex128* %476, align 1, !alias.scope !97, !noalias !180
  store %complex128 %477, %complex128* %ret_value_addr, align 1
  br label %slice_intersection-after

fusion.27.loop_header.dim.0:                      ; preds = %concatenate.41.merge, %dynamic-update-slice.51.loop_exit.dim.0
  %fusion.27.indvar.dim.0 = load i64, i64* %fusion.27.invar_address.dim.0, align 8
  %478 = icmp uge i64 %fusion.27.indvar.dim.0, 2
  br i1 %478, label %fusion.27.loop_exit.dim.0, label %fusion.27.loop_body.dim.0

fusion.27.loop_body.dim.0:                        ; preds = %fusion.27.loop_header.dim.0
  %479 = icmp ult i64 %fusion.27.indvar.dim.0, 1
  br i1 %479, label %concat_index_from_operand_id039, label %concat_index_not_from_operand041

concat_index_from_operand_id039:                  ; preds = %fusion.27.loop_body.dim.0
  %480 = phi i64 [ 0, %fusion.27.loop_body.dim.0 ]
  %481 = sub nsw i64 %fusion.27.indvar.dim.0, %480
  %constant.1500 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* bitcast ([4 x i8]* @52 to [1 x i32]*), i64 0, i64 0), align 4
  br label %concatenate.41.merge

concat_index_from_operand_id140:                  ; preds = %concat_index_not_from_operand041
  %482 = phi i64 [ 1, %concat_index_not_from_operand041 ]
  %483 = sub nsw i64 %fusion.27.indvar.dim.0, %482
  %484 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1499 = load i64, i64* bitcast ([8 x i8]* @53 to i64*), align 8
  %485 = add i64 %484, %constant.1499
  %constant.1498 = load i64, i64* bitcast ([8 x i8]* @54 to i64*), align 8
  %486 = icmp slt i64 %485, %constant.1498
  %487 = zext i1 %486 to i8
  %488 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1497 = load i64, i64* bitcast ([8 x i8]* @55 to i64*), align 8
  %489 = add i64 %488, %constant.1497
  %490 = trunc i8 %487 to i1
  %491 = select i1 %490, i64 %489, i64 %485
  %492 = trunc i64 %491 to i32
  br label %concatenate.41.merge

concat_index_not_from_operand041:                 ; preds = %fusion.27.loop_body.dim.0
  %493 = icmp ult i64 %fusion.27.indvar.dim.0, 2
  br i1 %493, label %concat_index_from_operand_id140, label %concat_index_not_from_operand142

concat_index_not_from_operand142:                 ; preds = %concat_index_not_from_operand041
  unreachable

concatenate.41.merge:                             ; preds = %concat_index_from_operand_id140, %concat_index_from_operand_id039
  %494 = phi i32 [ %constant.1500, %concat_index_from_operand_id039 ], [ %492, %concat_index_from_operand_id140 ]
  %495 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.27, i64 0, i64 %fusion.27.indvar.dim.0
  store i32 %494, i32* %495, align 4, !alias.scope !29, !noalias !181
  %invar.inc38 = add nuw nsw i64 %fusion.27.indvar.dim.0, 1
  store i64 %invar.inc38, i64* %fusion.27.invar_address.dim.0, align 8
  br label %fusion.27.loop_header.dim.0

fusion.27.loop_exit.dim.0:                        ; preds = %fusion.27.loop_header.dim.0
  %496 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %497 = load i8*, i8** %496, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.26 = getelementptr inbounds i8, i8* %497, i64 720
  %constant.1494 = load i8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @56, i32 0, i32 0), align 1
  store i8 %constant.1494, i8* %accumulator_043, align 1
  store i64 0, i64* %reduce.19.inner.invar_address.reduction_dim.0, align 8
  br label %reduce.19.inner.loop_header.reduction_dim.0

reduce.19.inner.loop_header.reduction_dim.0:      ; preds = %reduce.19.inner.loop_body.reduction_dim.0, %fusion.27.loop_exit.dim.0
  %reduce.19.inner.indvar.reduction_dim.0 = load i64, i64* %reduce.19.inner.invar_address.reduction_dim.0, align 8
  %498 = icmp uge i64 %reduce.19.inner.indvar.reduction_dim.0, 2
  br i1 %498, label %reduce.19.inner.loop_exit.reduction_dim.0, label %reduce.19.inner.loop_body.reduction_dim.0

reduce.19.inner.loop_body.reduction_dim.0:        ; preds = %reduce.19.inner.loop_header.reduction_dim.0
  %499 = load i8, i8* %accumulator_043, align 1
  %constant.1496 = load i32, i32* bitcast ([4 x i8]* @57 to i32*), align 4
  %500 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.27, i64 0, i64 %reduce.19.inner.indvar.reduction_dim.0
  %501 = load i32, i32* %500, align 4, !alias.scope !29, !noalias !181
  %502 = icmp sle i32 %constant.1496, %501
  %503 = zext i1 %502 to i8
  %constant.1495 = getelementptr inbounds [2 x i32], [2 x i32]* bitcast ([8 x i8]* @58 to [2 x i32]*), i64 0, i64 %reduce.19.inner.indvar.reduction_dim.0
  %constant.149545 = load i32, i32* %constant.1495, align 4
  %504 = getelementptr inbounds [2 x i32], [2 x i32]* %fusion.27, i64 0, i64 %reduce.19.inner.indvar.reduction_dim.0
  %505 = load i32, i32* %504, align 4, !alias.scope !29, !noalias !181
  %506 = icmp sge i32 %constant.149545, %505
  %507 = zext i1 %506 to i8
  %508 = and i8 %503, %507
  store i8 %499, i8* %arg_addr46, align 1
  store i8 %508, i8* %arg_addr47, align 1
  %509 = getelementptr inbounds i8*, i8** %reduce_function_parameter_addresses49, i64 0
  store i8* %arg_addr46, i8** %509, align 8
  %510 = getelementptr inbounds i8*, i8** %reduce_function_parameter_addresses49, i64 1
  store i8* %arg_addr47, i8** %510, align 8
  call void @and.reduce_sub_computation(i8* %reduce_function_return_value_addr48, i8* %run_options, i8** %reduce_function_parameter_addresses49, i8** null, i64* %prof_counters)
  %511 = load i8, i8* %reduce_function_return_value_addr48, align 1
  store i8 %511, i8* %accumulator_043, align 1
  %invar.inc44 = add nuw nsw i64 %reduce.19.inner.indvar.reduction_dim.0, 1
  store i64 %invar.inc44, i64* %reduce.19.inner.invar_address.reduction_dim.0, align 8
  br label %reduce.19.inner.loop_header.reduction_dim.0

reduce.19.inner.loop_exit.reduction_dim.0:        ; preds = %reduce.19.inner.loop_header.reduction_dim.0
  %512 = load i8, i8* %accumulator_043, align 1
  store i8 %512, i8* %fusion.26, align 1, !alias.scope !182, !noalias !183
  %513 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %514 = load i8*, i8** %513, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %515 = getelementptr inbounds i8, i8* %514, i64 144
  %fusion.14 = bitcast i8* %515 to [3 x [3 x %complex128]]*
  %constant.1483 = load i32, i32* bitcast ([4 x i8]* @59 to i32*), align 4
  %516 = icmp sge i32 0, %constant.1483
  %517 = select i1 %516, i32 0, i32 %constant.1483
  %518 = icmp sle i32 0, %517
  %519 = select i1 %518, i32 0, i32 %517
  %520 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1482 = load i64, i64* bitcast ([8 x i8]* @60 to i64*), align 8
  %521 = add i64 %520, %constant.1482
  %constant.1481 = load i64, i64* bitcast ([8 x i8]* @61 to i64*), align 8
  %522 = icmp slt i64 %521, %constant.1481
  %523 = zext i1 %522 to i8
  %524 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.1480 = load i64, i64* bitcast ([8 x i8]* @62 to i64*), align 8
  %525 = add i64 %524, %constant.1480
  %526 = trunc i8 %523 to i1
  %527 = select i1 %526, i64 %525, i64 %521
  %528 = trunc i64 %527 to i32
  %529 = icmp sge i32 0, %528
  %530 = select i1 %529, i32 0, i32 %528
  %531 = icmp sle i32 2, %530
  %532 = select i1 %531, i32 2, i32 %530
  store i64 0, i64* %dynamic-update-slice.53.invar_address.dim.0, align 8
  br label %dynamic-update-slice.53.loop_header.dim.0

dynamic-update-slice.53.loop_header.dim.0:        ; preds = %dynamic-update-slice.53.loop_exit.dim.1, %reduce.19.inner.loop_exit.reduction_dim.0
  %dynamic-update-slice.53.indvar.dim.0 = load i64, i64* %dynamic-update-slice.53.invar_address.dim.0, align 8
  %533 = icmp uge i64 %dynamic-update-slice.53.indvar.dim.0, 3
  br i1 %533, label %dynamic-update-slice.53.loop_exit.dim.0, label %dynamic-update-slice.53.loop_body.dim.0

dynamic-update-slice.53.loop_body.dim.0:          ; preds = %dynamic-update-slice.53.loop_header.dim.0
  store i64 0, i64* %dynamic-update-slice.53.invar_address.dim.1, align 8
  br label %dynamic-update-slice.53.loop_header.dim.1

dynamic-update-slice.53.loop_header.dim.1:        ; preds = %dynamic-update-slice.53.loop_body.dim.1, %dynamic-update-slice.53.loop_body.dim.0
  %dynamic-update-slice.53.indvar.dim.1 = load i64, i64* %dynamic-update-slice.53.invar_address.dim.1, align 8
  %534 = icmp uge i64 %dynamic-update-slice.53.indvar.dim.1, 1
  br i1 %534, label %dynamic-update-slice.53.loop_exit.dim.1, label %dynamic-update-slice.53.loop_body.dim.1

dynamic-update-slice.53.loop_body.dim.1:          ; preds = %dynamic-update-slice.53.loop_header.dim.1
  %535 = sext i32 %519 to i64
  %536 = add i64 %535, %dynamic-update-slice.53.indvar.dim.0
  %537 = sext i32 %532 to i64
  %538 = add i64 %537, %dynamic-update-slice.53.indvar.dim.1
  %539 = load i8, i8* %fusion.26, align 1, !alias.scope !182, !noalias !183
  %540 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %541 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1478 = load double, double* bitcast ([8 x i8]* @63 to double*), align 8
  %compare.231 = fcmp reassoc nsz contract ogt double %541, %constant.1478
  %542 = zext i1 %compare.231 to i8
  %543 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1477 = load double, double* bitcast ([8 x i8]* @64 to double*), align 8
  %544 = trunc i8 %542 to i1
  %545 = select reassoc nsz contract i1 %544, double %543, double %constant.1477
  %constant.147852 = load double, double* bitcast ([8 x i8]* @65 to double*), align 8
  %multiply.32 = fmul reassoc nsz contract double %545, %constant.147852
  %546 = insertvalue %complex128 zeroinitializer, double %multiply.32, 0
  %547 = extractvalue %complex128 %546, 0
  %compare.230 = fcmp reassoc nsz contract ogt double %540, %547
  %548 = zext i1 %compare.230 to i8
  %549 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %295, i64 0, i64 %dynamic-update-slice.53.indvar.dim.0
  %550 = load %complex128, %complex128* %549, align 1, !alias.scope !79, !noalias !170
  %551 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %552 = insertvalue %complex128 zeroinitializer, double %551, 0
  %553 = extractvalue %complex128 %550, 0
  %554 = extractvalue %complex128 %550, 1
  %555 = extractvalue %complex128 %552, 0
  %556 = extractvalue %complex128 %552, 1
  %557 = fdiv reassoc nsz contract double %555, %556
  %558 = fmul reassoc nsz contract double %557, %555
  %559 = fadd reassoc nsz contract double %556, %558
  %560 = fdiv reassoc nsz contract double %556, %555
  %561 = fmul reassoc nsz contract double %560, %556
  %562 = fadd reassoc nsz contract double %555, %561
  %563 = call reassoc nsz contract double @llvm.fabs.f64(double %555)
  %564 = call reassoc nsz contract double @llvm.fabs.f64(double %556)
  %565 = fcmp reassoc nsz contract olt double %563, %564
  %566 = fmul reassoc nsz contract double %557, %553
  %567 = fadd reassoc nsz contract double %566, %554
  %568 = fdiv reassoc nsz contract double %567, %559
  %569 = fmul reassoc nsz contract double %560, %554
  %570 = fadd reassoc nsz contract double %569, %553
  %571 = fdiv reassoc nsz contract double %570, %562
  %572 = select reassoc nsz contract i1 %565, double %568, double %571
  %573 = fmul reassoc nsz contract double %557, %554
  %574 = fsub reassoc nsz contract double %573, %553
  %575 = fdiv reassoc nsz contract double %574, %559
  %576 = fmul reassoc nsz contract double %560, %553
  %577 = fsub reassoc nsz contract double %554, %576
  %578 = fdiv reassoc nsz contract double %577, %562
  %579 = select reassoc nsz contract i1 %565, double %575, double %578
  %580 = insertvalue %complex128 zeroinitializer, double %572, 0
  %581 = insertvalue %complex128 %580, double %579, 1
  %582 = fcmp reassoc nsz contract oeq double %555, 0.000000e+00
  %583 = fcmp reassoc nsz contract oeq double %556, 0.000000e+00
  %584 = and i1 %582, %583
  %585 = fcmp reassoc nsz contract one double %553, 0.000000e+00
  %586 = sub i1 false, %585
  %587 = fcmp reassoc nsz contract one double %554, 0.000000e+00
  %588 = sub i1 false, %587
  %589 = or i1 %586, %588
  %590 = and i1 %584, %589
  %591 = call reassoc nsz contract double @llvm.copysign.f64(double 0x7FF0000000000000, double %553)
  %592 = fmul reassoc nsz contract double %591, %553
  %593 = fmul reassoc nsz contract double %591, %554
  %594 = insertvalue %complex128 zeroinitializer, double %592, 0
  %595 = insertvalue %complex128 %594, double %593, 1
  %596 = call reassoc nsz contract double @llvm.fabs.f64(double %555)
  %597 = fcmp reassoc nsz contract one double %596, 0x7FF0000000000000
  %598 = call reassoc nsz contract double @llvm.fabs.f64(double %556)
  %599 = fcmp reassoc nsz contract one double %598, 0x7FF0000000000000
  %600 = fcmp reassoc nsz contract oeq double %553, 0x7FF0000000000000
  %601 = fcmp reassoc nsz contract oeq double %554, 0x7FF0000000000000
  %602 = or i1 %600, %601
  %603 = and i1 %597, %599
  %604 = and i1 %602, %603
  %605 = fcmp reassoc nsz contract oeq double %553, 0x7FF0000000000000
  %606 = select reassoc nsz contract i1 %605, double 1.000000e+00, double 0.000000e+00
  %607 = call reassoc nsz contract double @llvm.copysign.f64(double %606, double %553)
  %608 = fcmp reassoc nsz contract oeq double %554, 0x7FF0000000000000
  %609 = select reassoc nsz contract i1 %608, double 1.000000e+00, double 0.000000e+00
  %610 = call reassoc nsz contract double @llvm.copysign.f64(double %609, double %554)
  %611 = fmul reassoc nsz contract double %607, %555
  %612 = fmul reassoc nsz contract double %610, %556
  %613 = fadd reassoc nsz contract double %611, %612
  %614 = fmul reassoc nsz contract double 0x7FF0000000000000, %613
  %615 = fmul reassoc nsz contract double %610, %555
  %616 = fmul reassoc nsz contract double %607, %556
  %617 = fsub reassoc nsz contract double %615, %616
  %618 = fmul reassoc nsz contract double 0x7FF0000000000000, %617
  %619 = insertvalue %complex128 zeroinitializer, double %614, 0
  %620 = insertvalue %complex128 %619, double %618, 1
  %621 = call reassoc nsz contract double @llvm.fabs.f64(double %553)
  %622 = fcmp reassoc nsz contract one double %621, 0x7FF0000000000000
  %623 = call reassoc nsz contract double @llvm.fabs.f64(double %554)
  %624 = fcmp reassoc nsz contract one double %623, 0x7FF0000000000000
  %625 = fcmp reassoc nsz contract oeq double %555, 0x7FF0000000000000
  %626 = fcmp reassoc nsz contract oeq double %556, 0x7FF0000000000000
  %627 = or i1 %625, %626
  %628 = and i1 %622, %624
  %629 = and i1 %627, %628
  %630 = fcmp reassoc nsz contract oeq double %555, 0x7FF0000000000000
  %631 = select reassoc nsz contract i1 %630, double 1.000000e+00, double 0.000000e+00
  %632 = call reassoc nsz contract double @llvm.copysign.f64(double %631, double %555)
  %633 = fcmp reassoc nsz contract oeq double %556, 0x7FF0000000000000
  %634 = select reassoc nsz contract i1 %633, double 1.000000e+00, double 0.000000e+00
  %635 = call reassoc nsz contract double @llvm.copysign.f64(double %634, double %556)
  %636 = fmul reassoc nsz contract double %553, %632
  %637 = fmul reassoc nsz contract double %554, %635
  %638 = fadd reassoc nsz contract double %636, %637
  %639 = fmul reassoc nsz contract double 0.000000e+00, %638
  %640 = fmul reassoc nsz contract double %554, %632
  %641 = fmul reassoc nsz contract double %553, %635
  %642 = fsub reassoc nsz contract double %640, %641
  %643 = fmul reassoc nsz contract double 0.000000e+00, %642
  %644 = insertvalue %complex128 zeroinitializer, double %639, 0
  %645 = insertvalue %complex128 %644, double %643, 1
  %646 = fcmp reassoc nsz contract uno double %572, 0.000000e+00
  %647 = fcmp reassoc nsz contract uno double %579, 0.000000e+00
  %648 = and i1 %646, %647
  %649 = select i1 %629, %complex128 %645, %complex128 %581
  %650 = select i1 %604, %complex128 %620, %complex128 %649
  %651 = select i1 %590, %complex128 %595, %complex128 %650
  %652 = select i1 %648, %complex128 %651, %complex128 %581
  %constant.1479 = load %complex128, %complex128* bitcast ([16 x i8]* @66 to %complex128*), align 1
  %653 = trunc i8 %548 to i1
  %654 = select i1 %653, %complex128 %652, %complex128 %constant.1479
  %constant.148353 = load i32, i32* bitcast ([4 x i8]* @67 to i32*), align 4
  %655 = sext i32 %constant.148353 to i64
  %656 = icmp sge i64 0, %655
  %657 = select i1 %656, i64 0, i64 %655
  %658 = icmp sle i64 0, %657
  %dynamic-slice.78.start_idx0 = select i1 %658, i64 0, i64 %657
  %659 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.148254 = load i64, i64* bitcast ([8 x i8]* @68 to i64*), align 8
  %660 = add i64 %659, %constant.148254
  %constant.148155 = load i64, i64* bitcast ([8 x i8]* @69 to i64*), align 8
  %661 = icmp slt i64 %660, %constant.148155
  %662 = zext i1 %661 to i8
  %663 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %constant.148056 = load i64, i64* bitcast ([8 x i8]* @70 to i64*), align 8
  %664 = add i64 %663, %constant.148056
  %665 = trunc i8 %662 to i1
  %666 = select i1 %665, i64 %664, i64 %660
  %667 = trunc i64 %666 to i32
  %668 = sext i32 %667 to i64
  %669 = icmp sge i64 0, %668
  %670 = select i1 %669, i64 0, i64 %668
  %671 = icmp sle i64 2, %670
  %dynamic-slice.78.start_idx1 = select i1 %671, i64 2, i64 %670
  %672 = add i64 %dynamic-slice.78.start_idx0, %dynamic-update-slice.53.indvar.dim.0
  %673 = add i64 %dynamic-slice.78.start_idx1, %dynamic-update-slice.53.indvar.dim.1
  %674 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %13, i64 0, i64 %672, i64 %673
  %675 = load %complex128, %complex128* %674, align 1, !alias.scope !84, !noalias !150
  %676 = trunc i8 %539 to i1
  %677 = select i1 %676, %complex128 %654, %complex128 %675
  %678 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %fusion.14, i64 0, i64 %536, i64 %538
  store %complex128 %677, %complex128* %678, align 1, !alias.scope !84, !noalias !184
  %invar.inc51 = add nuw nsw i64 %dynamic-update-slice.53.indvar.dim.1, 1
  store i64 %invar.inc51, i64* %dynamic-update-slice.53.invar_address.dim.1, align 8
  br label %dynamic-update-slice.53.loop_header.dim.1

dynamic-update-slice.53.loop_exit.dim.1:          ; preds = %dynamic-update-slice.53.loop_header.dim.1
  %invar.inc50 = add nuw nsw i64 %dynamic-update-slice.53.indvar.dim.0, 1
  store i64 %invar.inc50, i64* %dynamic-update-slice.53.invar_address.dim.0, align 8
  br label %dynamic-update-slice.53.loop_header.dim.0

dynamic-update-slice.53.loop_exit.dim.0:          ; preds = %dynamic-update-slice.53.loop_header.dim.0
  %679 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %fusion.10 = load i8*, i8** %679, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %680 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %681 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1462 = load double, double* bitcast ([8 x i8]* @71 to double*), align 8
  %compare.220 = fcmp reassoc nsz contract ogt double %681, %constant.1462
  %682 = zext i1 %compare.220 to i8
  %683 = load double, double* %sqrt.36, align 8, !alias.scope !165, !noalias !167
  %constant.1461 = load double, double* bitcast ([8 x i8]* @72 to double*), align 8
  %684 = trunc i8 %682 to i1
  %685 = select reassoc nsz contract i1 %684, double %683, double %constant.1461
  %constant.146257 = load double, double* bitcast ([8 x i8]* @73 to double*), align 8
  %multiply.30 = fmul reassoc nsz contract double %685, %constant.146257
  %686 = insertvalue %complex128 zeroinitializer, double %multiply.30, 0
  %687 = extractvalue %complex128 %686, 0
  %compare.219 = fcmp reassoc nsz contract ogt double %680, %687
  %688 = zext i1 %compare.219 to i8
  %689 = load double, double* %sqrt.37, align 8, !alias.scope !128, !noalias !173
  %constant.146158 = load double, double* bitcast ([8 x i8]* @74 to double*), align 8
  %690 = trunc i8 %688 to i1
  %691 = select reassoc nsz contract i1 %690, double %689, double %constant.146158
  %constant.146159 = load double, double* bitcast ([8 x i8]* @75 to double*), align 8
  %compare.218 = fcmp reassoc nsz contract oeq double %691, %constant.146159
  %692 = zext i1 %compare.218 to i8
  store i8 %692, i8* %fusion.10, align 1, !alias.scope !185, !noalias !186
  %693 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %694 = load i8*, i8** %693, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %add.190 = bitcast i8* %694 to i64*
  %695 = load i64, i64* %copy.33, align 8, !alias.scope !144, !noalias !146
  %696 = load i64, i64* bitcast ([8 x i8]* @2 to i64*), align 8, !alias.scope !187, !noalias !188
  %697 = add i64 %695, %696
  store i64 %697, i64* %add.190, align 8, !alias.scope !29, !noalias !189
  %698 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %699 = load i8*, i8** %698, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %700 = getelementptr inbounds i8, i8* %699, i64 912
  %tuple.304 = bitcast i8* %700 to [5 x i8*]*
  %701 = bitcast [3 x [3 x %complex128]]* %41 to i8*
  %702 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.304, i64 0, i64 0
  store i8* %701, i8** %702, align 8, !alias.scope !190, !noalias !191
  %703 = bitcast [3 x [3 x %complex128]]* %fusion.14 to i8*
  %704 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.304, i64 0, i64 1
  store i8* %703, i8** %704, align 8, !alias.scope !190, !noalias !191
  %705 = bitcast [2 x [3 x %complex128]]* %fusion.11 to i8*
  %706 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.304, i64 0, i64 2
  store i8* %705, i8** %706, align 8, !alias.scope !190, !noalias !191
  %707 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.304, i64 0, i64 3
  store i8* %fusion.10, i8** %707, align 8, !alias.scope !190, !noalias !191
  %708 = bitcast i64* %add.190 to i8*
  %709 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.304, i64 0, i64 4
  store i8* %708, i8** %709, align 8, !alias.scope !190, !noalias !191
  ret void
}

; Function Attrs: uwtable
define internal void @wide.cond_computation__11.515.clone.4(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 912
  %wide_param.46 = bitcast i8* %2 to [5 x i8*]*
  %3 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.46, i64 0, i64 3
  %4 = load i8*, i8** %3, align 8, !dereferenceable !34, !align !34
  %5 = getelementptr inbounds [5 x i8*], [5 x i8*]* %wide_param.46, i64 0, i64 4
  %6 = load i8*, i8** %5, align 8, !dereferenceable !50, !align !50
  %7 = bitcast i8* %6 to i64*
  %8 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %9 = load i8*, i8** %8, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.28 = getelementptr inbounds i8, i8* %9, i64 720
  %10 = load i64, i64* %7, align 8, !alias.scope !29, !noalias !192
  %constant.1501 = load i64, i64* bitcast ([8 x i8]* @76 to i64*), align 8
  %11 = icmp slt i64 %10, %constant.1501
  %12 = zext i1 %11 to i8
  %13 = load i8, i8* %4, align 1, !alias.scope !185, !noalias !193
  %14 = trunc i8 %13 to i1
  %15 = xor i1 %14, true
  %16 = zext i1 %15 to i8
  %17 = and i8 %12, %16
  store i8 %17, i8* %fusion.28, align 1, !alias.scope !182, !noalias !194
  ret void
}

; Function Attrs: uwtable
define internal void @wide.body_computation__10.636.clone.clone.clone.clone.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %fusion.30.invar_address.dim.0 = alloca i64, align 8
  %dot_acc35 = alloca double, align 8
  %dot.140.inner.invar_address = alloca i64, align 8
  %imag.100.invar_address.dim.0 = alloca i64, align 8
  %subtract.15.invar_address.dim.0 = alloca i64, align 8
  %accum_address31 = alloca %complex128, align 8
  %dot.106.invar_address.reduction = alloca i64, align 8
  %dot.106.invar_address.lhs.0 = alloca i64, align 8
  %add.160.invar_address.dim.0 = alloca i64, align 8
  %dot_acc = alloca %complex128, align 8
  %dot.141.inner.invar_address = alloca i64, align 8
  %fusion.33.invar_address.dim.0 = alloca i64, align 8
  %cc_operands_alloca25 = alloca i8*, i32 10, align 8
  %cc_operands_alloca = alloca i8*, i32 10, align 8
  %accum_address = alloca %complex128, align 8
  %dot.103.invar_address.reduction = alloca i64, align 8
  %dot.103.invar_address.lhs.0 = alloca i64, align 8
  %pad_result_addr19 = alloca %complex128, align 8
  %fusion.34.invar_address.dim.0 = alloca i64, align 8
  %fusion.35.invar_address.dim.0 = alloca i64, align 8
  %fusion.35.invar_address.dim.1 = alloca i64, align 8
  %broadcast.357.invar_address.dim.1 = alloca i64, align 8
  %broadcast.357.invar_address.dim.0 = alloca i64, align 8
  %fusion.36.invar_address.dim.1 = alloca i64, align 8
  %fusion.36.invar_address.dim.0 = alloca i64, align 8
  %fusion.37.invar_address.dim.1 = alloca i64, align 8
  %fusion.37.invar_address.dim.0 = alloca i64, align 8
  %pad_result_addr = alloca %complex128, align 8
  %fusion.38.invar_address.dim.1 = alloca i64, align 8
  %fusion.38.invar_address.dim.0 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 1008
  %wide_param.43 = bitcast i8* %2 to [9 x i8*]*
  %3 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 0
  %4 = load i8*, i8** %3, align 8, !dereferenceable !69, !align !2
  %5 = bitcast i8* %4 to [3 x [3 x %complex128]]*
  %6 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 6
  %7 = load i8*, i8** %6, align 8, !dereferenceable !176, !align !2
  %8 = bitcast i8* %7 to [2 x [3 x %complex128]]*
  %9 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %10 = load i8*, i8** %9, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %11 = getelementptr inbounds i8, i8* %10, i64 384
  %copy.27 = bitcast i8* %11 to [2 x [3 x %complex128]]*
  %12 = bitcast [2 x [3 x %complex128]]* %copy.27 to i8*
  %13 = bitcast [2 x [3 x %complex128]]* %8 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %12, i8* align 1 %13, i64 96, i1 false)
  %14 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 4
  %15 = load i8*, i8** %14, align 8, !dereferenceable !25, !align !2
  %16 = bitcast i8* %15 to [3 x %complex128]*
  %17 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %18 = load i8*, i8** %17, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %19 = getelementptr inbounds i8, i8* %18, i64 144
  %fusion.38 = bitcast i8* %19 to [3 x [3 x %complex128]]*
  store i64 0, i64* %fusion.38.invar_address.dim.0, align 8
  br label %fusion.38.loop_header.dim.0

fusion.38.loop_header.dim.0:                      ; preds = %fusion.38.loop_exit.dim.1, %entry
  %fusion.38.indvar.dim.0 = load i64, i64* %fusion.38.invar_address.dim.0, align 8
  %20 = icmp uge i64 %fusion.38.indvar.dim.0, 3
  br i1 %20, label %fusion.38.loop_exit.dim.0, label %fusion.38.loop_body.dim.0

fusion.38.loop_body.dim.0:                        ; preds = %fusion.38.loop_header.dim.0
  store i64 0, i64* %fusion.38.invar_address.dim.1, align 8
  br label %fusion.38.loop_header.dim.1

fusion.38.loop_header.dim.1:                      ; preds = %in_bounds-after, %fusion.38.loop_body.dim.0
  %fusion.38.indvar.dim.1 = load i64, i64* %fusion.38.invar_address.dim.1, align 8
  %21 = icmp uge i64 %fusion.38.indvar.dim.1, 3
  br i1 %21, label %fusion.38.loop_exit.dim.1, label %fusion.38.loop_body.dim.1

fusion.38.loop_body.dim.1:                        ; preds = %fusion.38.loop_header.dim.1
  %22 = sub i64 %fusion.38.indvar.dim.0, 0
  %23 = icmp sge i64 %22, 0
  %in_bounds = and i1 true, %23
  %24 = urem i64 %22, 1
  %25 = icmp eq i64 0, %24
  %in_bounds2 = and i1 %in_bounds, %25
  %26 = sdiv i64 %22, 1
  %27 = icmp slt i64 %26, 3
  %in_bounds3 = and i1 %in_bounds2, %27
  %28 = sub i64 %fusion.38.indvar.dim.1, 0
  %29 = icmp sge i64 %28, 0
  %in_bounds4 = and i1 %in_bounds3, %29
  %30 = urem i64 %28, 1
  %31 = icmp eq i64 0, %30
  %in_bounds5 = and i1 %in_bounds4, %31
  %32 = sdiv i64 %28, 1
  %33 = icmp slt i64 %32, 1
  %in_bounds6 = and i1 %in_bounds5, %33
  br i1 %in_bounds6, label %in_bounds-true, label %in_bounds-false

in_bounds-after:                                  ; preds = %in_bounds-false, %in_bounds-true
  %34 = load %complex128, %complex128* %pad_result_addr, align 1
  %35 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %fusion.38, i64 0, i64 %fusion.38.indvar.dim.0, i64 %fusion.38.indvar.dim.1
  store %complex128 %34, %complex128* %35, align 1, !alias.scope !84, !noalias !195
  %invar.inc1 = add nuw nsw i64 %fusion.38.indvar.dim.1, 1
  store i64 %invar.inc1, i64* %fusion.38.invar_address.dim.1, align 8
  br label %fusion.38.loop_header.dim.1

fusion.38.loop_exit.dim.1:                        ; preds = %fusion.38.loop_header.dim.1
  %invar.inc = add nuw nsw i64 %fusion.38.indvar.dim.0, 1
  store i64 %invar.inc, i64* %fusion.38.invar_address.dim.0, align 8
  br label %fusion.38.loop_header.dim.0

fusion.38.loop_exit.dim.0:                        ; preds = %fusion.38.loop_header.dim.0
  %36 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %37 = load i8*, i8** %36, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %copy.64 = bitcast i8* %37 to i64*
  %38 = bitcast i64* %copy.64 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %38, i8* align 1 getelementptr inbounds ([8 x i8], [8 x i8]* @3, i32 0, i32 0), i64 8, i1 false)
  %39 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %copy.65 = load i8*, i8** %39, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %copy.65, i8* align 1 getelementptr inbounds ([1 x i8], [1 x i8]* @7, i32 0, i32 0), i64 1, i1 false)
  %40 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %41 = load i8*, i8** %40, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %42 = getelementptr inbounds i8, i8* %41, i64 912
  %tuple.302 = bitcast i8* %42 to [5 x i8*]*
  %43 = bitcast [3 x [3 x %complex128]]* %5 to i8*
  %44 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 0
  store i8* %43, i8** %44, align 8, !alias.scope !190, !noalias !191
  %45 = bitcast [3 x [3 x %complex128]]* %fusion.38 to i8*
  %46 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 1
  store i8* %45, i8** %46, align 8, !alias.scope !190, !noalias !191
  %47 = bitcast [2 x [3 x %complex128]]* %copy.27 to i8*
  %48 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 2
  store i8* %47, i8** %48, align 8, !alias.scope !190, !noalias !191
  %49 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 3
  store i8* %copy.65, i8** %49, align 8, !alias.scope !190, !noalias !191
  %50 = bitcast i64* %copy.64 to i8*
  %51 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 4
  store i8* %50, i8** %51, align 8, !alias.scope !190, !noalias !191
  br label %while.94.header

in_bounds-true:                                   ; preds = %fusion.38.loop_body.dim.1
  %52 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %16, i64 0, i64 %26
  %53 = load %complex128, %complex128* %52, align 1, !alias.scope !97, !noalias !84
  store %complex128 %53, %complex128* %pad_result_addr, align 1
  br label %in_bounds-after

in_bounds-false:                                  ; preds = %fusion.38.loop_body.dim.1
  %constant.1509 = load %complex128, %complex128* bitcast ([16 x i8]* @77 to %complex128*), align 1
  store %complex128 %constant.1509, %complex128* %pad_result_addr, align 1
  br label %in_bounds-after

while.94.header:                                  ; preds = %while.94.body, %fusion.38.loop_exit.dim.0
  call void @wide.cond_computation__11.515.clone.4(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %54 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %55 = load i8*, i8** %54, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %56 = getelementptr inbounds i8, i8* %55, i64 720
  %57 = load i8, i8* %56, align 1
  %58 = icmp ne i8 %57, 0
  br i1 %58, label %while.94.body, label %while.94.exit

while.94.body:                                    ; preds = %while.94.header
  call void @wide.body_computation__11.373.clone.4(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.94.header

while.94.exit:                                    ; preds = %while.94.header
  %59 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 2
  %60 = load i8*, i8** %59, align 8, !dereferenceable !176, !align !2
  %61 = bitcast i8* %60 to [2 x [3 x %complex128]]*
  %62 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %63 = load i8*, i8** %62, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %fusion.37 = bitcast i8* %63 to [2 x [3 x %complex128]]*
  store i64 0, i64* %fusion.37.invar_address.dim.0, align 8
  br label %fusion.37.loop_header.dim.0

fusion.37.loop_header.dim.0:                      ; preds = %fusion.37.loop_exit.dim.1, %while.94.exit
  %fusion.37.indvar.dim.0 = load i64, i64* %fusion.37.invar_address.dim.0, align 8
  %64 = icmp uge i64 %fusion.37.indvar.dim.0, 2
  br i1 %64, label %fusion.37.loop_exit.dim.0, label %fusion.37.loop_body.dim.0

fusion.37.loop_body.dim.0:                        ; preds = %fusion.37.loop_header.dim.0
  store i64 0, i64* %fusion.37.invar_address.dim.1, align 8
  br label %fusion.37.loop_header.dim.1

fusion.37.loop_header.dim.1:                      ; preds = %fusion.37.loop_body.dim.1, %fusion.37.loop_body.dim.0
  %fusion.37.indvar.dim.1 = load i64, i64* %fusion.37.invar_address.dim.1, align 8
  %65 = icmp uge i64 %fusion.37.indvar.dim.1, 3
  br i1 %65, label %fusion.37.loop_exit.dim.1, label %fusion.37.loop_body.dim.1

fusion.37.loop_body.dim.1:                        ; preds = %fusion.37.loop_header.dim.1
  %66 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %61, i64 0, i64 %fusion.37.indvar.dim.0, i64 %fusion.37.indvar.dim.1
  %67 = load %complex128, %complex128* %66, align 1, !alias.scope !177, !noalias !196
  %68 = extractvalue %complex128 %67, 0
  %69 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %61, i64 0, i64 %fusion.37.indvar.dim.0, i64 %fusion.37.indvar.dim.1
  %70 = load %complex128, %complex128* %69, align 1, !alias.scope !177, !noalias !196
  %71 = extractvalue %complex128 %70, 1
  %72 = fneg reassoc nsz contract double %71
  %73 = insertvalue %complex128 zeroinitializer, double %68, 0
  %74 = insertvalue %complex128 %73, double %72, 1
  %75 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %fusion.37, i64 0, i64 %fusion.37.indvar.dim.0, i64 %fusion.37.indvar.dim.1
  store %complex128 %74, %complex128* %75, align 1, !alias.scope !198, !noalias !199
  %invar.inc8 = add nuw nsw i64 %fusion.37.indvar.dim.1, 1
  store i64 %invar.inc8, i64* %fusion.37.invar_address.dim.1, align 8
  br label %fusion.37.loop_header.dim.1

fusion.37.loop_exit.dim.1:                        ; preds = %fusion.37.loop_header.dim.1
  %invar.inc7 = add nuw nsw i64 %fusion.37.indvar.dim.0, 1
  store i64 %invar.inc7, i64* %fusion.37.invar_address.dim.0, align 8
  br label %fusion.37.loop_header.dim.0

fusion.37.loop_exit.dim.0:                        ; preds = %fusion.37.loop_header.dim.0
  %76 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %77 = load i8*, i8** %76, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %78 = getelementptr inbounds i8, i8* %77, i64 576
  %dot.127 = bitcast i8* %78 to [2 x [2 x %complex128]]*
  %79 = bitcast [2 x [2 x %complex128]]* %dot.127 to %complex128*
  %80 = bitcast [2 x [3 x %complex128]]* %fusion.37 to %complex128*
  %81 = bitcast [2 x [3 x %complex128]]* %61 to %complex128*
  call void @__xla_cpu_runtime_EigenMatMulC128(i8* %run_options, %complex128* %79, %complex128* %80, %complex128* %81, i64 2, i64 2, i64 3, i32 1, i32 0)
  %82 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %83 = load i8*, i8** %82, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %84 = getelementptr inbounds i8, i8* %83, i64 576
  %fusion.36 = bitcast i8* %84 to [2 x [2 x %complex128]]*
  store i64 0, i64* %fusion.36.invar_address.dim.0, align 8
  br label %fusion.36.loop_header.dim.0

fusion.36.loop_header.dim.0:                      ; preds = %fusion.36.loop_exit.dim.1, %fusion.37.loop_exit.dim.0
  %fusion.36.indvar.dim.0 = load i64, i64* %fusion.36.invar_address.dim.0, align 8
  %85 = icmp uge i64 %fusion.36.indvar.dim.0, 2
  br i1 %85, label %fusion.36.loop_exit.dim.0, label %fusion.36.loop_body.dim.0

fusion.36.loop_body.dim.0:                        ; preds = %fusion.36.loop_header.dim.0
  store i64 0, i64* %fusion.36.invar_address.dim.1, align 8
  br label %fusion.36.loop_header.dim.1

fusion.36.loop_header.dim.1:                      ; preds = %fusion.36.loop_body.dim.1, %fusion.36.loop_body.dim.0
  %fusion.36.indvar.dim.1 = load i64, i64* %fusion.36.invar_address.dim.1, align 8
  %86 = icmp uge i64 %fusion.36.indvar.dim.1, 2
  br i1 %86, label %fusion.36.loop_exit.dim.1, label %fusion.36.loop_body.dim.1

fusion.36.loop_body.dim.1:                        ; preds = %fusion.36.loop_header.dim.1
  %87 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %dot.127, i64 0, i64 %fusion.36.indvar.dim.0, i64 %fusion.36.indvar.dim.1
  %88 = load %complex128, %complex128* %87, align 1, !alias.scope !15, !noalias !201
  %89 = extractvalue %complex128 %88, 0
  %90 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %dot.127, i64 0, i64 %fusion.36.indvar.dim.0, i64 %fusion.36.indvar.dim.1
  %91 = load %complex128, %complex128* %90, align 1, !alias.scope !15, !noalias !201
  %92 = extractvalue %complex128 %91, 1
  %93 = fneg reassoc nsz contract double %92
  %94 = insertvalue %complex128 zeroinitializer, double %89, 0
  %95 = insertvalue %complex128 %94, double %93, 1
  %96 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %fusion.36, i64 0, i64 %fusion.36.indvar.dim.0, i64 %fusion.36.indvar.dim.1
  store %complex128 %95, %complex128* %96, align 1, !alias.scope !15, !noalias !202
  %invar.inc10 = add nuw nsw i64 %fusion.36.indvar.dim.1, 1
  store i64 %invar.inc10, i64* %fusion.36.invar_address.dim.1, align 8
  br label %fusion.36.loop_header.dim.1

fusion.36.loop_exit.dim.1:                        ; preds = %fusion.36.loop_header.dim.1
  %invar.inc9 = add nuw nsw i64 %fusion.36.indvar.dim.0, 1
  store i64 %invar.inc9, i64* %fusion.36.invar_address.dim.0, align 8
  br label %fusion.36.loop_header.dim.0

fusion.36.loop_exit.dim.0:                        ; preds = %fusion.36.loop_header.dim.0
  %97 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 8
  %98 = load i8*, i8** %97, align 8, !dereferenceable !24, !align !24
  %99 = bitcast i8* %98 to [2 x [2 x i8]]*
  %100 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %101 = load i8*, i8** %100, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %102 = getelementptr inbounds i8, i8* %101, i64 512
  %broadcast.357 = bitcast i8* %102 to [2 x [2 x %complex128]]*
  store i64 0, i64* %broadcast.357.invar_address.dim.0, align 8
  br label %broadcast.357.loop_header.dim.0

broadcast.357.loop_header.dim.0:                  ; preds = %broadcast.357.loop_exit.dim.1, %fusion.36.loop_exit.dim.0
  %broadcast.357.indvar.dim.0 = load i64, i64* %broadcast.357.invar_address.dim.0, align 8
  %103 = icmp uge i64 %broadcast.357.indvar.dim.0, 2
  br i1 %103, label %broadcast.357.loop_exit.dim.0, label %broadcast.357.loop_body.dim.0

broadcast.357.loop_body.dim.0:                    ; preds = %broadcast.357.loop_header.dim.0
  store i64 0, i64* %broadcast.357.invar_address.dim.1, align 8
  br label %broadcast.357.loop_header.dim.1

broadcast.357.loop_header.dim.1:                  ; preds = %broadcast.357.loop_body.dim.1, %broadcast.357.loop_body.dim.0
  %broadcast.357.indvar.dim.1 = load i64, i64* %broadcast.357.invar_address.dim.1, align 8
  %104 = icmp uge i64 %broadcast.357.indvar.dim.1, 2
  br i1 %104, label %broadcast.357.loop_exit.dim.1, label %broadcast.357.loop_body.dim.1

broadcast.357.loop_body.dim.1:                    ; preds = %broadcast.357.loop_header.dim.1
  %105 = load %complex128, %complex128* bitcast ([16 x i8]* @1 to %complex128*), align 1, !alias.scope !203, !noalias !4
  %106 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %broadcast.357, i64 0, i64 %broadcast.357.indvar.dim.0, i64 %broadcast.357.indvar.dim.1
  store %complex128 %105, %complex128* %106, align 1, !alias.scope !4, !noalias !205
  %invar.inc12 = add nuw nsw i64 %broadcast.357.indvar.dim.1, 1
  store i64 %invar.inc12, i64* %broadcast.357.invar_address.dim.1, align 8
  br label %broadcast.357.loop_header.dim.1

broadcast.357.loop_exit.dim.1:                    ; preds = %broadcast.357.loop_header.dim.1
  %invar.inc11 = add nuw nsw i64 %broadcast.357.indvar.dim.0, 1
  store i64 %invar.inc11, i64* %broadcast.357.invar_address.dim.0, align 8
  br label %broadcast.357.loop_header.dim.0

broadcast.357.loop_exit.dim.0:                    ; preds = %broadcast.357.loop_header.dim.0
  %107 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %108 = load i8*, i8** %107, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %copy.38 = bitcast i8* %108 to i32*
  %109 = bitcast i32* %copy.38 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %109, i8* align 1 getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i64 4, i1 false)
  %110 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %111 = load i8*, i8** %110, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %112 = getelementptr inbounds i8, i8* %111, i64 112
  %copy.66 = bitcast i8* %112 to [1 x [1 x i8]]*
  %113 = bitcast [1 x [1 x i8]]* %copy.66 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %113, i8* align 1 getelementptr inbounds ([1 x i8], [1 x i8]* @8, i32 0, i32 0), i64 1, i1 false)
  %114 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %115 = load i8*, i8** %114, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %116 = getelementptr inbounds i8, i8* %115, i64 864
  %tuple.305 = bitcast i8* %116 to [5 x i8*]*
  %117 = bitcast i32* %copy.38 to i8*
  %118 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 0
  store i8* %117, i8** %118, align 8, !alias.scope !41, !noalias !42
  %119 = bitcast [2 x [2 x %complex128]]* %fusion.36 to i8*
  %120 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 1
  store i8* %119, i8** %120, align 8, !alias.scope !41, !noalias !42
  %121 = bitcast [2 x [2 x %complex128]]* %broadcast.357 to i8*
  %122 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 2
  store i8* %121, i8** %122, align 8, !alias.scope !41, !noalias !42
  %123 = bitcast [1 x [1 x i8]]* %copy.66 to i8*
  %124 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 3
  store i8* %123, i8** %124, align 8, !alias.scope !41, !noalias !42
  %125 = bitcast [2 x [2 x i8]]* %99 to i8*
  %126 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 4
  store i8* %125, i8** %126, align 8, !alias.scope !41, !noalias !42
  br label %while.84.header

while.84.header:                                  ; preds = %while.84.body, %broadcast.357.loop_exit.dim.0
  call void @wide.unblocked_condition.52.(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %127 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %128 = load i8*, i8** %127, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %129 = getelementptr inbounds i8, i8* %128, i64 96
  %130 = load i8, i8* %129, align 1
  %131 = icmp ne i8 %130, 0
  br i1 %131, label %while.84.body, label %while.84.exit

while.84.body:                                    ; preds = %while.84.header
  call void @wide.unblocked_body.14.(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.84.header

while.84.exit:                                    ; preds = %while.84.header
  %132 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 2
  %133 = load i8*, i8** %132, align 8, !dereferenceable !3, !align !2
  %134 = bitcast i8* %133 to [2 x [2 x %complex128]]*
  %135 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.305, i64 0, i64 3
  %136 = load i8*, i8** %135, align 8, !dereferenceable !34, !align !34
  %137 = bitcast i8* %136 to [1 x [1 x i8]]*
  %138 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 7
  %139 = load i8*, i8** %138, align 8, !dereferenceable !24, !align !24
  %140 = bitcast i8* %139 to [2 x [2 x i8]]*
  %141 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %142 = load i8*, i8** %141, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %143 = getelementptr inbounds i8, i8* %142, i64 384
  %fusion.35 = bitcast i8* %143 to [2 x [2 x %complex128]]*
  store i64 0, i64* %fusion.35.invar_address.dim.1, align 8
  br label %fusion.35.loop_header.dim.1

fusion.35.loop_header.dim.1:                      ; preds = %fusion.35.loop_exit.dim.0, %while.84.exit
  %fusion.35.indvar.dim.1 = load i64, i64* %fusion.35.invar_address.dim.1, align 8
  %144 = icmp uge i64 %fusion.35.indvar.dim.1, 2
  br i1 %144, label %fusion.35.loop_exit.dim.1, label %fusion.35.loop_body.dim.1

fusion.35.loop_body.dim.1:                        ; preds = %fusion.35.loop_header.dim.1
  store i64 0, i64* %fusion.35.invar_address.dim.0, align 8
  br label %fusion.35.loop_header.dim.0

fusion.35.loop_header.dim.0:                      ; preds = %fusion.35.loop_body.dim.0, %fusion.35.loop_body.dim.1
  %fusion.35.indvar.dim.0 = load i64, i64* %fusion.35.invar_address.dim.0, align 8
  %145 = icmp uge i64 %fusion.35.indvar.dim.0, 2
  br i1 %145, label %fusion.35.loop_exit.dim.0, label %fusion.35.loop_body.dim.0

fusion.35.loop_body.dim.0:                        ; preds = %fusion.35.loop_header.dim.0
  %146 = getelementptr inbounds [2 x [2 x i8]], [2 x [2 x i8]]* %140, i64 0, i64 %fusion.35.indvar.dim.1, i64 %fusion.35.indvar.dim.0
  %147 = load i8, i8* %146, align 1, !alias.scope !206, !noalias !208
  %148 = getelementptr inbounds [1 x [1 x i8]], [1 x [1 x i8]]* %137, i64 0, i64 0, i64 0
  %149 = load i8, i8* %148, align 1, !alias.scope !35, !noalias !215
  %constant.1507 = load %complex128, %complex128* bitcast ([16 x i8]* @78 to %complex128*), align 1
  %150 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %134, i64 0, i64 %fusion.35.indvar.dim.1, i64 %fusion.35.indvar.dim.0
  %151 = load %complex128, %complex128* %150, align 1, !alias.scope !4, !noalias !216
  %152 = trunc i8 %149 to i1
  %153 = select i1 %152, %complex128 %constant.1507, %complex128 %151
  %constant.1508 = load %complex128, %complex128* bitcast ([16 x i8]* @79 to %complex128*), align 1
  %154 = trunc i8 %147 to i1
  %155 = select i1 %154, %complex128 %153, %complex128 %constant.1508
  %156 = extractvalue %complex128 %155, 0
  %157 = extractvalue %complex128 %155, 1
  %158 = fneg reassoc nsz contract double %157
  %159 = insertvalue %complex128 zeroinitializer, double %156, 0
  %160 = insertvalue %complex128 %159, double %158, 1
  %161 = getelementptr inbounds [2 x [2 x %complex128]], [2 x [2 x %complex128]]* %fusion.35, i64 0, i64 %fusion.35.indvar.dim.1, i64 %fusion.35.indvar.dim.0
  store %complex128 %160, %complex128* %161, align 1, !alias.scope !21, !noalias !217
  %invar.inc14 = add nuw nsw i64 %fusion.35.indvar.dim.0, 1
  store i64 %invar.inc14, i64* %fusion.35.invar_address.dim.0, align 8
  br label %fusion.35.loop_header.dim.0

fusion.35.loop_exit.dim.0:                        ; preds = %fusion.35.loop_header.dim.0
  %invar.inc13 = add nuw nsw i64 %fusion.35.indvar.dim.1, 1
  store i64 %invar.inc13, i64* %fusion.35.invar_address.dim.1, align 8
  br label %fusion.35.loop_header.dim.1

fusion.35.loop_exit.dim.1:                        ; preds = %fusion.35.loop_header.dim.1
  %162 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 5
  %163 = load i8*, i8** %162, align 8, !dereferenceable !50, !align !50
  %164 = bitcast i8* %163 to double*
  %165 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %166 = load i8*, i8** %165, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.34 = bitcast i8* %166 to [3 x %complex128]*
  store i64 0, i64* %fusion.34.invar_address.dim.0, align 8
  br label %fusion.34.loop_header.dim.0

fusion.34.loop_header.dim.0:                      ; preds = %in_bounds-after22, %fusion.35.loop_exit.dim.1
  %fusion.34.indvar.dim.0 = load i64, i64* %fusion.34.invar_address.dim.0, align 8
  %167 = icmp uge i64 %fusion.34.indvar.dim.0, 3
  br i1 %167, label %fusion.34.loop_exit.dim.0, label %fusion.34.loop_body.dim.0

fusion.34.loop_body.dim.0:                        ; preds = %fusion.34.loop_header.dim.0
  %168 = sub i64 %fusion.34.indvar.dim.0, 0
  %169 = icmp sge i64 %168, 0
  %in_bounds16 = and i1 true, %169
  %170 = urem i64 %168, 1
  %171 = icmp eq i64 0, %170
  %in_bounds17 = and i1 %in_bounds16, %171
  %172 = sdiv i64 %168, 1
  %173 = icmp slt i64 %172, 1
  %in_bounds18 = and i1 %in_bounds17, %173
  br i1 %in_bounds18, label %in_bounds-true20, label %in_bounds-false21

in_bounds-after22:                                ; preds = %in_bounds-false21, %in_bounds-true20
  %174 = load %complex128, %complex128* %pad_result_addr19, align 1
  %175 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.34, i64 0, i64 %fusion.34.indvar.dim.0
  store %complex128 %174, %complex128* %175, align 1, !alias.scope !97, !noalias !224
  %invar.inc15 = add nuw nsw i64 %fusion.34.indvar.dim.0, 1
  store i64 %invar.inc15, i64* %fusion.34.invar_address.dim.0, align 8
  br label %fusion.34.loop_header.dim.0

fusion.34.loop_exit.dim.0:                        ; preds = %fusion.34.loop_header.dim.0
  %176 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %177 = load i8*, i8** %176, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %178 = getelementptr inbounds i8, i8* %177, i64 96
  %dot.103 = bitcast i8* %178 to [2 x %complex128]*
  store i64 0, i64* %dot.103.invar_address.lhs.0, align 8
  br label %dot.103.loop_header.lhs.0

in_bounds-true20:                                 ; preds = %fusion.34.loop_body.dim.0
  %179 = load double, double* %164, align 8, !alias.scope !225, !noalias !97
  %180 = insertvalue %complex128 zeroinitializer, double %179, 0
  store %complex128 %180, %complex128* %pad_result_addr19, align 1
  br label %in_bounds-after22

in_bounds-false21:                                ; preds = %fusion.34.loop_body.dim.0
  %constant.1506 = load %complex128, %complex128* bitcast ([16 x i8]* @80 to %complex128*), align 1
  store %complex128 %constant.1506, %complex128* %pad_result_addr19, align 1
  br label %in_bounds-after22

dot.103.loop_header.lhs.0:                        ; preds = %dot.103.loop_exit.reduction, %fusion.34.loop_exit.dim.0
  %dot.103.indvar.lhs.0 = load i64, i64* %dot.103.invar_address.lhs.0, align 8
  %181 = icmp uge i64 %dot.103.indvar.lhs.0, 2
  br i1 %181, label %dot.103.loop_exit.lhs.0, label %dot.103.loop_body.lhs.0

dot.103.loop_body.lhs.0:                          ; preds = %dot.103.loop_header.lhs.0
  store i64 0, i64* %dot.103.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address, align 1
  br label %dot.103.loop_header.reduction

dot.103.loop_header.reduction:                    ; preds = %dot.103.loop_body.reduction, %dot.103.loop_body.lhs.0
  %dot.103.indvar.reduction = load i64, i64* %dot.103.invar_address.reduction, align 8
  %182 = icmp uge i64 %dot.103.indvar.reduction, 3
  br i1 %182, label %dot.103.loop_exit.reduction, label %dot.103.loop_body.reduction

dot.103.loop_body.reduction:                      ; preds = %dot.103.loop_header.reduction
  %183 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %fusion.37, i64 0, i64 %dot.103.indvar.lhs.0, i64 %dot.103.indvar.reduction
  %184 = load %complex128, %complex128* %183, align 1, !alias.scope !198, !noalias !199
  %185 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.34, i64 0, i64 %dot.103.indvar.reduction
  %186 = load %complex128, %complex128* %185, align 1, !alias.scope !97, !noalias !224
  %187 = load %complex128, %complex128* %accum_address, align 1
  %188 = extractvalue %complex128 %184, 0
  %189 = extractvalue %complex128 %186, 0
  %190 = fmul reassoc nsz contract double %188, %189
  %191 = extractvalue %complex128 %184, 1
  %192 = extractvalue %complex128 %186, 1
  %193 = fmul reassoc nsz contract double %191, %192
  %194 = fsub reassoc nsz contract double %190, %193
  %195 = extractvalue %complex128 %184, 0
  %196 = extractvalue %complex128 %186, 1
  %197 = fmul reassoc nsz contract double %195, %196
  %198 = extractvalue %complex128 %184, 1
  %199 = extractvalue %complex128 %186, 0
  %200 = fmul reassoc nsz contract double %198, %199
  %201 = fadd reassoc nsz contract double %197, %200
  %202 = extractvalue %complex128 %187, 0
  %203 = fadd reassoc nsz contract double %202, %194
  %204 = insertvalue %complex128 %187, double %203, 0
  %205 = extractvalue %complex128 %187, 1
  %206 = fadd reassoc nsz contract double %205, %201
  %207 = insertvalue %complex128 %204, double %206, 1
  store %complex128 %207, %complex128* %accum_address, align 1
  %invar.inc24 = add nuw nsw i64 %dot.103.indvar.reduction, 1
  store i64 %invar.inc24, i64* %dot.103.invar_address.reduction, align 8
  br label %dot.103.loop_header.reduction, !llvm.loop !226

dot.103.loop_exit.reduction:                      ; preds = %dot.103.loop_header.reduction
  %208 = load %complex128, %complex128* %accum_address, align 1
  %209 = getelementptr inbounds [2 x %complex128], [2 x %complex128]* %dot.103, i64 0, i64 %dot.103.indvar.lhs.0
  store %complex128 %208, %complex128* %209, align 1, !alias.scope !227, !noalias !228
  %invar.inc23 = add nuw nsw i64 %dot.103.indvar.lhs.0, 1
  store i64 %invar.inc23, i64* %dot.103.invar_address.lhs.0, align 8
  br label %dot.103.loop_header.lhs.0

dot.103.loop_exit.lhs.0:                          ; preds = %dot.103.loop_header.lhs.0
  %bitcast = bitcast [2 x %complex128]* %dot.103 to [1 x [2 x %complex128]]*
  %210 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 0
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %210, align 8
  %211 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 1
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8** %211, align 8
  %212 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 2
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @6, i32 0, i32 0), i8** %212, align 8
  %213 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 3
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8** %213, align 8
  %214 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 4
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @6, i32 0, i32 0), i8** %214, align 8
  %215 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 5
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %215, align 8
  %216 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 6
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %216, align 8
  %217 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 7
  store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @0, i32 0, i32 0), i8** %217, align 8
  %218 = bitcast [2 x [2 x %complex128]]* %fusion.35 to i8*
  %219 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 8
  store i8* %218, i8** %219, align 8
  %220 = bitcast [1 x [2 x %complex128]]* %bitcast to i8*
  %221 = getelementptr inbounds i8*, i8** %cc_operands_alloca, i64 9
  store i8* %220, i8** %221, align 8
  %222 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %223 = load i8*, i8** %222, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %custom-call.14 = bitcast i8* %223 to [1 x [2 x %complex128]]*
  %224 = bitcast [1 x [2 x %complex128]]* %custom-call.14 to i8*
  call void @blas_ztrsm(i8* %224, i8** %cc_operands_alloca)
  %225 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 0
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %225, align 8
  %226 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 1
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8** %226, align 8
  %227 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 2
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8** %227, align 8
  %228 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 3
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @5, i32 0, i32 0), i8** %228, align 8
  %229 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 4
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @6, i32 0, i32 0), i8** %229, align 8
  %230 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 5
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %230, align 8
  %231 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 6
  store i8* getelementptr inbounds ([4 x i8], [4 x i8]* @4, i32 0, i32 0), i8** %231, align 8
  %232 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 7
  store i8* getelementptr inbounds ([16 x i8], [16 x i8]* @0, i32 0, i32 0), i8** %232, align 8
  %233 = bitcast [2 x [2 x %complex128]]* %fusion.35 to i8*
  %234 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 8
  store i8* %233, i8** %234, align 8
  %235 = bitcast [1 x [2 x %complex128]]* %custom-call.14 to i8*
  %236 = getelementptr inbounds i8*, i8** %cc_operands_alloca25, i64 9
  store i8* %235, i8** %236, align 8
  %237 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %238 = load i8*, i8** %237, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %custom-call.15 = bitcast i8* %238 to [1 x [2 x %complex128]]*
  %239 = bitcast [1 x [2 x %complex128]]* %custom-call.15 to i8*
  call void @blas_ztrsm(i8* %239, i8** %cc_operands_alloca25)
  %240 = getelementptr inbounds [5 x i8*], [5 x i8*]* %tuple.302, i64 0, i64 1
  %241 = load i8*, i8** %240, align 8, !dereferenceable !69, !align !2
  %242 = bitcast i8* %241 to [3 x [3 x %complex128]]*
  %243 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %244 = load i8*, i8** %243, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.33 = bitcast i8* %244 to [3 x %complex128]*
  store i64 0, i64* %fusion.33.invar_address.dim.0, align 8
  br label %fusion.33.loop_header.dim.0

fusion.33.loop_header.dim.0:                      ; preds = %dot.141.inner.loop_exit, %dot.103.loop_exit.lhs.0
  %fusion.33.indvar.dim.0 = load i64, i64* %fusion.33.invar_address.dim.0, align 8
  %245 = icmp uge i64 %fusion.33.indvar.dim.0, 3
  br i1 %245, label %fusion.33.loop_exit.dim.0, label %fusion.33.loop_body.dim.0

fusion.33.loop_body.dim.0:                        ; preds = %fusion.33.loop_header.dim.0
  store %complex128 zeroinitializer, %complex128* %dot_acc, align 1
  store i64 0, i64* %dot.141.inner.invar_address, align 8
  br label %dot.141.inner.loop_header

dot.141.inner.loop_header:                        ; preds = %dot.141.inner.loop_body, %fusion.33.loop_body.dim.0
  %dot.141.inner.indvar = load i64, i64* %dot.141.inner.invar_address, align 8
  %246 = icmp uge i64 %dot.141.inner.indvar, 2
  br i1 %246, label %dot.141.inner.loop_exit, label %dot.141.inner.loop_body

dot.141.inner.loop_body:                          ; preds = %dot.141.inner.loop_header
  %247 = load %complex128, %complex128* %dot_acc, align 1
  %248 = add i64 %fusion.33.indvar.dim.0, 0
  %249 = add i64 %dot.141.inner.indvar, 0
  %250 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %242, i64 0, i64 %248, i64 %249
  %251 = load %complex128, %complex128* %250, align 1, !alias.scope !84, !noalias !229
  %252 = getelementptr inbounds [1 x [2 x %complex128]], [1 x [2 x %complex128]]* %custom-call.15, i64 0, i64 0, i64 %dot.141.inner.indvar
  %253 = load %complex128, %complex128* %252, align 1, !alias.scope !230, !noalias !231
  %254 = extractvalue %complex128 %251, 0
  %255 = extractvalue %complex128 %253, 0
  %256 = fmul reassoc nsz contract double %254, %255
  %257 = extractvalue %complex128 %251, 1
  %258 = extractvalue %complex128 %253, 1
  %259 = fmul reassoc nsz contract double %257, %258
  %260 = fsub reassoc nsz contract double %256, %259
  %261 = extractvalue %complex128 %251, 0
  %262 = extractvalue %complex128 %253, 1
  %263 = fmul reassoc nsz contract double %261, %262
  %264 = extractvalue %complex128 %251, 1
  %265 = extractvalue %complex128 %253, 0
  %266 = fmul reassoc nsz contract double %264, %265
  %267 = fadd reassoc nsz contract double %263, %266
  %268 = extractvalue %complex128 %247, 0
  %269 = fadd reassoc nsz contract double %268, %260
  %270 = insertvalue %complex128 %247, double %269, 0
  %271 = extractvalue %complex128 %247, 1
  %272 = fadd reassoc nsz contract double %271, %267
  %273 = insertvalue %complex128 %270, double %272, 1
  store %complex128 %273, %complex128* %dot_acc, align 1
  %invar.inc27 = add nuw nsw i64 %dot.141.inner.indvar, 1
  store i64 %invar.inc27, i64* %dot.141.inner.invar_address, align 8
  br label %dot.141.inner.loop_header

dot.141.inner.loop_exit:                          ; preds = %dot.141.inner.loop_header
  %274 = load %complex128, %complex128* %dot_acc, align 1
  %275 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.33, i64 0, i64 %fusion.33.indvar.dim.0
  store %complex128 %274, %complex128* %275, align 1, !alias.scope !97, !noalias !232
  %invar.inc26 = add nuw nsw i64 %fusion.33.indvar.dim.0, 1
  store i64 %invar.inc26, i64* %fusion.33.invar_address.dim.0, align 8
  br label %fusion.33.loop_header.dim.0

fusion.33.loop_exit.dim.0:                        ; preds = %fusion.33.loop_header.dim.0
  %276 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 2
  %277 = load i8*, i8** %276, align 8, !dereferenceable !25, !align !2
  %278 = bitcast i8* %277 to [3 x %complex128]*
  %279 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %280 = load i8*, i8** %279, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %281 = getelementptr inbounds i8, i8* %280, i64 640
  %add.160 = bitcast i8* %281 to [3 x %complex128]*
  store i64 0, i64* %add.160.invar_address.dim.0, align 8
  br label %add.160.loop_header.dim.0

add.160.loop_header.dim.0:                        ; preds = %add.160.loop_body.dim.0, %fusion.33.loop_exit.dim.0
  %add.160.indvar.dim.0 = load i64, i64* %add.160.invar_address.dim.0, align 8
  %282 = icmp uge i64 %add.160.indvar.dim.0, 3
  br i1 %282, label %add.160.loop_exit.dim.0, label %add.160.loop_body.dim.0

add.160.loop_body.dim.0:                          ; preds = %add.160.loop_header.dim.0
  %283 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %278, i64 0, i64 %add.160.indvar.dim.0
  %284 = load %complex128, %complex128* %283, align 1, !alias.scope !233, !noalias !97
  %285 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.33, i64 0, i64 %add.160.indvar.dim.0
  %286 = load %complex128, %complex128* %285, align 1, !alias.scope !97, !noalias !232
  %287 = extractvalue %complex128 %284, 0
  %288 = extractvalue %complex128 %286, 0
  %289 = fadd reassoc nsz contract double %287, %288
  %290 = extractvalue %complex128 %284, 1
  %291 = extractvalue %complex128 %286, 1
  %292 = fadd reassoc nsz contract double %290, %291
  %293 = insertvalue %complex128 zeroinitializer, double %289, 0
  %294 = insertvalue %complex128 %293, double %292, 1
  %295 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %add.160, i64 0, i64 %add.160.indvar.dim.0
  store %complex128 %294, %complex128* %295, align 1, !alias.scope !233, !noalias !234
  %invar.inc28 = add nuw nsw i64 %add.160.indvar.dim.0, 1
  store i64 %invar.inc28, i64* %add.160.invar_address.dim.0, align 8
  br label %add.160.loop_header.dim.0

add.160.loop_exit.dim.0:                          ; preds = %add.160.loop_header.dim.0
  %296 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %297 = load i8*, i8** %296, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %dot.106 = bitcast i8* %297 to [3 x %complex128]*
  store i64 0, i64* %dot.106.invar_address.lhs.0, align 8
  br label %dot.106.loop_header.lhs.0

dot.106.loop_header.lhs.0:                        ; preds = %dot.106.loop_exit.reduction, %add.160.loop_exit.dim.0
  %dot.106.indvar.lhs.0 = load i64, i64* %dot.106.invar_address.lhs.0, align 8
  %298 = icmp uge i64 %dot.106.indvar.lhs.0, 3
  br i1 %298, label %dot.106.loop_exit.lhs.0, label %dot.106.loop_body.lhs.0

dot.106.loop_body.lhs.0:                          ; preds = %dot.106.loop_header.lhs.0
  store i64 0, i64* %dot.106.invar_address.reduction, align 8
  store %complex128 zeroinitializer, %complex128* %accum_address31, align 1
  br label %dot.106.loop_header.reduction

dot.106.loop_header.reduction:                    ; preds = %dot.106.loop_body.reduction, %dot.106.loop_body.lhs.0
  %dot.106.indvar.reduction = load i64, i64* %dot.106.invar_address.reduction, align 8
  %299 = icmp uge i64 %dot.106.indvar.reduction, 3
  br i1 %299, label %dot.106.loop_exit.reduction, label %dot.106.loop_body.reduction

dot.106.loop_body.reduction:                      ; preds = %dot.106.loop_header.reduction
  %300 = getelementptr inbounds [3 x [3 x %complex128]], [3 x [3 x %complex128]]* %5, i64 0, i64 %dot.106.indvar.lhs.0, i64 %dot.106.indvar.reduction
  %301 = load %complex128, %complex128* %300, align 1, !alias.scope !153, !noalias !235
  %302 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %add.160, i64 0, i64 %dot.106.indvar.reduction
  %303 = load %complex128, %complex128* %302, align 1, !alias.scope !233, !noalias !234
  %304 = load %complex128, %complex128* %accum_address31, align 1
  %305 = extractvalue %complex128 %301, 0
  %306 = extractvalue %complex128 %303, 0
  %307 = fmul reassoc nsz contract double %305, %306
  %308 = extractvalue %complex128 %301, 1
  %309 = extractvalue %complex128 %303, 1
  %310 = fmul reassoc nsz contract double %308, %309
  %311 = fsub reassoc nsz contract double %307, %310
  %312 = extractvalue %complex128 %301, 0
  %313 = extractvalue %complex128 %303, 1
  %314 = fmul reassoc nsz contract double %312, %313
  %315 = extractvalue %complex128 %301, 1
  %316 = extractvalue %complex128 %303, 0
  %317 = fmul reassoc nsz contract double %315, %316
  %318 = fadd reassoc nsz contract double %314, %317
  %319 = extractvalue %complex128 %304, 0
  %320 = fadd reassoc nsz contract double %319, %311
  %321 = insertvalue %complex128 %304, double %320, 0
  %322 = extractvalue %complex128 %304, 1
  %323 = fadd reassoc nsz contract double %322, %318
  %324 = insertvalue %complex128 %321, double %323, 1
  store %complex128 %324, %complex128* %accum_address31, align 1
  %invar.inc30 = add nuw nsw i64 %dot.106.indvar.reduction, 1
  store i64 %invar.inc30, i64* %dot.106.invar_address.reduction, align 8
  br label %dot.106.loop_header.reduction, !llvm.loop !236

dot.106.loop_exit.reduction:                      ; preds = %dot.106.loop_header.reduction
  %325 = load %complex128, %complex128* %accum_address31, align 1
  %326 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.106, i64 0, i64 %dot.106.indvar.lhs.0
  store %complex128 %325, %complex128* %326, align 1, !alias.scope !97, !noalias !237
  %invar.inc29 = add nuw nsw i64 %dot.106.indvar.lhs.0, 1
  store i64 %invar.inc29, i64* %dot.106.invar_address.lhs.0, align 8
  br label %dot.106.loop_header.lhs.0

dot.106.loop_exit.lhs.0:                          ; preds = %dot.106.loop_header.lhs.0
  %327 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 1
  %328 = load i8*, i8** %327, align 8, !dereferenceable !25, !align !2
  %329 = bitcast i8* %328 to [3 x %complex128]*
  %330 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %331 = load i8*, i8** %330, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %subtract.15 = bitcast i8* %331 to [3 x %complex128]*
  store i64 0, i64* %subtract.15.invar_address.dim.0, align 8
  br label %subtract.15.loop_header.dim.0

subtract.15.loop_header.dim.0:                    ; preds = %subtract.15.loop_body.dim.0, %dot.106.loop_exit.lhs.0
  %subtract.15.indvar.dim.0 = load i64, i64* %subtract.15.invar_address.dim.0, align 8
  %332 = icmp uge i64 %subtract.15.indvar.dim.0, 3
  br i1 %332, label %subtract.15.loop_exit.dim.0, label %subtract.15.loop_body.dim.0

subtract.15.loop_body.dim.0:                      ; preds = %subtract.15.loop_header.dim.0
  %333 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %329, i64 0, i64 %subtract.15.indvar.dim.0
  %334 = load %complex128, %complex128* %333, align 1, !alias.scope !238, !noalias !239
  %335 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %dot.106, i64 0, i64 %subtract.15.indvar.dim.0
  %336 = load %complex128, %complex128* %335, align 1, !alias.scope !97, !noalias !237
  %337 = extractvalue %complex128 %334, 0
  %338 = extractvalue %complex128 %336, 0
  %339 = fsub reassoc nsz contract double %337, %338
  %340 = extractvalue %complex128 %334, 1
  %341 = extractvalue %complex128 %336, 1
  %342 = fsub reassoc nsz contract double %340, %341
  %343 = insertvalue %complex128 zeroinitializer, double %339, 0
  %344 = insertvalue %complex128 %343, double %342, 1
  %345 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.15, i64 0, i64 %subtract.15.indvar.dim.0
  store %complex128 %344, %complex128* %345, align 1, !alias.scope !97, !noalias !240
  %invar.inc32 = add nuw nsw i64 %subtract.15.indvar.dim.0, 1
  store i64 %invar.inc32, i64* %subtract.15.invar_address.dim.0, align 8
  br label %subtract.15.loop_header.dim.0

subtract.15.loop_exit.dim.0:                      ; preds = %subtract.15.loop_header.dim.0
  %346 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %347 = load i8*, i8** %346, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %348 = getelementptr inbounds i8, i8* %347, i64 384
  %imag.100 = bitcast i8* %348 to [3 x double]*
  store i64 0, i64* %imag.100.invar_address.dim.0, align 8
  br label %imag.100.loop_header.dim.0

imag.100.loop_header.dim.0:                       ; preds = %imag.100.loop_body.dim.0, %subtract.15.loop_exit.dim.0
  %imag.100.indvar.dim.0 = load i64, i64* %imag.100.invar_address.dim.0, align 8
  %349 = icmp uge i64 %imag.100.indvar.dim.0, 3
  br i1 %349, label %imag.100.loop_exit.dim.0, label %imag.100.loop_body.dim.0

imag.100.loop_body.dim.0:                         ; preds = %imag.100.loop_header.dim.0
  %350 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.15, i64 0, i64 %imag.100.indvar.dim.0
  %351 = load %complex128, %complex128* %350, align 1, !alias.scope !97, !noalias !240
  %352 = extractvalue %complex128 %351, 1
  %353 = getelementptr inbounds [3 x double], [3 x double]* %imag.100, i64 0, i64 %imag.100.indvar.dim.0
  store double %352, double* %353, align 8, !alias.scope !242, !noalias !243
  %invar.inc33 = add nuw nsw i64 %imag.100.indvar.dim.0, 1
  store i64 %invar.inc33, i64* %imag.100.invar_address.dim.0, align 8
  br label %imag.100.loop_header.dim.0

imag.100.loop_exit.dim.0:                         ; preds = %imag.100.loop_header.dim.0
  store double 0.000000e+00, double* %dot_acc35, align 8
  %354 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %355 = load i8*, i8** %354, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %356 = getelementptr inbounds i8, i8* %355, i64 720
  %fusion.32 = bitcast i8* %356 to double*
  store i64 0, i64* %dot.140.inner.invar_address, align 8
  br label %dot.140.inner.loop_header

dot.140.inner.loop_header:                        ; preds = %dot.140.inner.loop_body, %imag.100.loop_exit.dim.0
  %dot.140.inner.indvar = load i64, i64* %dot.140.inner.invar_address, align 8
  %357 = icmp uge i64 %dot.140.inner.indvar, 3
  br i1 %357, label %dot.140.inner.loop_exit, label %dot.140.inner.loop_body

dot.140.inner.loop_body:                          ; preds = %dot.140.inner.loop_header
  %358 = load double, double* %dot_acc35, align 8
  %359 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.15, i64 0, i64 %dot.140.inner.indvar
  %360 = load %complex128, %complex128* %359, align 1, !alias.scope !97, !noalias !240
  %361 = extractvalue %complex128 %360, 0
  %362 = fmul reassoc nsz contract double %361, %361
  %363 = fadd reassoc nsz contract double %358, %362
  store double %363, double* %dot_acc35, align 8
  %invar.inc34 = add nuw nsw i64 %dot.140.inner.indvar, 1
  store i64 %invar.inc34, i64* %dot.140.inner.invar_address, align 8
  br label %dot.140.inner.loop_header

dot.140.inner.loop_exit:                          ; preds = %dot.140.inner.loop_header
  %364 = load double, double* %dot_acc35, align 8
  store double %364, double* %fusion.32, align 8, !alias.scope !103, !noalias !244
  %365 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %366 = load i8*, i8** %365, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %367 = getelementptr inbounds i8, i8* %366, i64 720
  %fusion.31 = bitcast i8* %367 to double*
  %368 = bitcast [3 x double]* %imag.100 to double*
  %369 = bitcast [3 x double]* %imag.100 to double*
  call void @col_major_gemv_F64_4_8_1_3_with_addend(double* %368, double* %369, double* %fusion.32, double* %fusion.31)
  %370 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %371 = load i8*, i8** %370, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %372 = getelementptr inbounds i8, i8* %371, i64 720
  %sqrt.31 = bitcast i8* %372 to double*
  %373 = load double, double* %fusion.31, align 8, !alias.scope !103, !noalias !242
  %374 = call reassoc nsz contract double @llvm.sqrt.f64(double %373)
  store double %374, double* %sqrt.31, align 8, !alias.scope !103, !noalias !245
  %375 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %376 = load i8*, i8** %375, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %fusion.30 = bitcast i8* %376 to [3 x %complex128]*
  store i64 0, i64* %fusion.30.invar_address.dim.0, align 8
  br label %fusion.30.loop_header.dim.0

fusion.30.loop_header.dim.0:                      ; preds = %fusion.30.loop_body.dim.0, %dot.140.inner.loop_exit
  %fusion.30.indvar.dim.0 = load i64, i64* %fusion.30.invar_address.dim.0, align 8
  %377 = icmp uge i64 %fusion.30.indvar.dim.0, 3
  br i1 %377, label %fusion.30.loop_exit.dim.0, label %fusion.30.loop_body.dim.0

fusion.30.loop_body.dim.0:                        ; preds = %fusion.30.loop_header.dim.0
  %378 = load double, double* %sqrt.31, align 8, !alias.scope !103, !noalias !245
  %constant.1504 = load double, double* bitcast ([8 x i8]* @81 to double*), align 8
  %compare.242 = fcmp reassoc nsz contract ogt double %378, %constant.1504
  %379 = zext i1 %compare.242 to i8
  %380 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %subtract.15, i64 0, i64 %fusion.30.indvar.dim.0
  %381 = load %complex128, %complex128* %380, align 1, !alias.scope !97, !noalias !240
  %382 = load double, double* %sqrt.31, align 8, !alias.scope !103, !noalias !245
  %383 = insertvalue %complex128 zeroinitializer, double %382, 0
  %384 = extractvalue %complex128 %381, 0
  %385 = extractvalue %complex128 %381, 1
  %386 = extractvalue %complex128 %383, 0
  %387 = extractvalue %complex128 %383, 1
  %388 = fdiv reassoc nsz contract double %386, %387
  %389 = fmul reassoc nsz contract double %388, %386
  %390 = fadd reassoc nsz contract double %387, %389
  %391 = fdiv reassoc nsz contract double %387, %386
  %392 = fmul reassoc nsz contract double %391, %387
  %393 = fadd reassoc nsz contract double %386, %392
  %394 = call reassoc nsz contract double @llvm.fabs.f64(double %386)
  %395 = call reassoc nsz contract double @llvm.fabs.f64(double %387)
  %396 = fcmp reassoc nsz contract olt double %394, %395
  %397 = fmul reassoc nsz contract double %388, %384
  %398 = fadd reassoc nsz contract double %397, %385
  %399 = fdiv reassoc nsz contract double %398, %390
  %400 = fmul reassoc nsz contract double %391, %385
  %401 = fadd reassoc nsz contract double %400, %384
  %402 = fdiv reassoc nsz contract double %401, %393
  %403 = select reassoc nsz contract i1 %396, double %399, double %402
  %404 = fmul reassoc nsz contract double %388, %385
  %405 = fsub reassoc nsz contract double %404, %384
  %406 = fdiv reassoc nsz contract double %405, %390
  %407 = fmul reassoc nsz contract double %391, %384
  %408 = fsub reassoc nsz contract double %385, %407
  %409 = fdiv reassoc nsz contract double %408, %393
  %410 = select reassoc nsz contract i1 %396, double %406, double %409
  %411 = insertvalue %complex128 zeroinitializer, double %403, 0
  %412 = insertvalue %complex128 %411, double %410, 1
  %413 = fcmp reassoc nsz contract oeq double %386, 0.000000e+00
  %414 = fcmp reassoc nsz contract oeq double %387, 0.000000e+00
  %415 = and i1 %413, %414
  %416 = fcmp reassoc nsz contract one double %384, 0.000000e+00
  %417 = sub i1 false, %416
  %418 = fcmp reassoc nsz contract one double %385, 0.000000e+00
  %419 = sub i1 false, %418
  %420 = or i1 %417, %419
  %421 = and i1 %415, %420
  %422 = call reassoc nsz contract double @llvm.copysign.f64(double 0x7FF0000000000000, double %384)
  %423 = fmul reassoc nsz contract double %422, %384
  %424 = fmul reassoc nsz contract double %422, %385
  %425 = insertvalue %complex128 zeroinitializer, double %423, 0
  %426 = insertvalue %complex128 %425, double %424, 1
  %427 = call reassoc nsz contract double @llvm.fabs.f64(double %386)
  %428 = fcmp reassoc nsz contract one double %427, 0x7FF0000000000000
  %429 = call reassoc nsz contract double @llvm.fabs.f64(double %387)
  %430 = fcmp reassoc nsz contract one double %429, 0x7FF0000000000000
  %431 = fcmp reassoc nsz contract oeq double %384, 0x7FF0000000000000
  %432 = fcmp reassoc nsz contract oeq double %385, 0x7FF0000000000000
  %433 = or i1 %431, %432
  %434 = and i1 %428, %430
  %435 = and i1 %433, %434
  %436 = fcmp reassoc nsz contract oeq double %384, 0x7FF0000000000000
  %437 = select reassoc nsz contract i1 %436, double 1.000000e+00, double 0.000000e+00
  %438 = call reassoc nsz contract double @llvm.copysign.f64(double %437, double %384)
  %439 = fcmp reassoc nsz contract oeq double %385, 0x7FF0000000000000
  %440 = select reassoc nsz contract i1 %439, double 1.000000e+00, double 0.000000e+00
  %441 = call reassoc nsz contract double @llvm.copysign.f64(double %440, double %385)
  %442 = fmul reassoc nsz contract double %438, %386
  %443 = fmul reassoc nsz contract double %441, %387
  %444 = fadd reassoc nsz contract double %442, %443
  %445 = fmul reassoc nsz contract double 0x7FF0000000000000, %444
  %446 = fmul reassoc nsz contract double %441, %386
  %447 = fmul reassoc nsz contract double %438, %387
  %448 = fsub reassoc nsz contract double %446, %447
  %449 = fmul reassoc nsz contract double 0x7FF0000000000000, %448
  %450 = insertvalue %complex128 zeroinitializer, double %445, 0
  %451 = insertvalue %complex128 %450, double %449, 1
  %452 = call reassoc nsz contract double @llvm.fabs.f64(double %384)
  %453 = fcmp reassoc nsz contract one double %452, 0x7FF0000000000000
  %454 = call reassoc nsz contract double @llvm.fabs.f64(double %385)
  %455 = fcmp reassoc nsz contract one double %454, 0x7FF0000000000000
  %456 = fcmp reassoc nsz contract oeq double %386, 0x7FF0000000000000
  %457 = fcmp reassoc nsz contract oeq double %387, 0x7FF0000000000000
  %458 = or i1 %456, %457
  %459 = and i1 %453, %455
  %460 = and i1 %458, %459
  %461 = fcmp reassoc nsz contract oeq double %386, 0x7FF0000000000000
  %462 = select reassoc nsz contract i1 %461, double 1.000000e+00, double 0.000000e+00
  %463 = call reassoc nsz contract double @llvm.copysign.f64(double %462, double %386)
  %464 = fcmp reassoc nsz contract oeq double %387, 0x7FF0000000000000
  %465 = select reassoc nsz contract i1 %464, double 1.000000e+00, double 0.000000e+00
  %466 = call reassoc nsz contract double @llvm.copysign.f64(double %465, double %387)
  %467 = fmul reassoc nsz contract double %384, %463
  %468 = fmul reassoc nsz contract double %385, %466
  %469 = fadd reassoc nsz contract double %467, %468
  %470 = fmul reassoc nsz contract double 0.000000e+00, %469
  %471 = fmul reassoc nsz contract double %385, %463
  %472 = fmul reassoc nsz contract double %384, %466
  %473 = fsub reassoc nsz contract double %471, %472
  %474 = fmul reassoc nsz contract double 0.000000e+00, %473
  %475 = insertvalue %complex128 zeroinitializer, double %470, 0
  %476 = insertvalue %complex128 %475, double %474, 1
  %477 = fcmp reassoc nsz contract uno double %403, 0.000000e+00
  %478 = fcmp reassoc nsz contract uno double %410, 0.000000e+00
  %479 = and i1 %477, %478
  %480 = select i1 %460, %complex128 %476, %complex128 %412
  %481 = select i1 %435, %complex128 %451, %complex128 %480
  %482 = select i1 %421, %complex128 %426, %complex128 %481
  %483 = select i1 %479, %complex128 %482, %complex128 %412
  %constant.1505 = load %complex128, %complex128* bitcast ([16 x i8]* @82 to %complex128*), align 1
  %484 = trunc i8 %379 to i1
  %485 = select i1 %484, %complex128 %483, %complex128 %constant.1505
  %486 = getelementptr inbounds [3 x %complex128], [3 x %complex128]* %fusion.30, i64 0, i64 %fusion.30.indvar.dim.0
  store %complex128 %485, %complex128* %486, align 1, !alias.scope !97, !noalias !246
  %invar.inc36 = add nuw nsw i64 %fusion.30.indvar.dim.0, 1
  store i64 %invar.inc36, i64* %fusion.30.invar_address.dim.0, align 8
  br label %fusion.30.loop_header.dim.0

fusion.30.loop_exit.dim.0:                        ; preds = %fusion.30.loop_header.dim.0
  %487 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %488 = load i8*, i8** %487, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %489 = getelementptr inbounds i8, i8* %488, i64 704
  %fusion.29 = bitcast i8* %489 to double*
  %490 = load double, double* %sqrt.31, align 8, !alias.scope !103, !noalias !245
  %constant.1503 = load double, double* bitcast ([8 x i8]* @83 to double*), align 8
  %compare.241 = fcmp reassoc nsz contract ogt double %490, %constant.1503
  %491 = zext i1 %compare.241 to i8
  %492 = load double, double* %sqrt.31, align 8, !alias.scope !103, !noalias !245
  %constant.1502 = load double, double* bitcast ([8 x i8]* @84 to double*), align 8
  %493 = trunc i8 %491 to i1
  %494 = select reassoc nsz contract i1 %493, double %492, double %constant.1502
  store double %494, double* %fusion.29, align 8, !alias.scope !225, !noalias !247
  %495 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.43, i64 0, i64 3
  %496 = load i8*, i8** %495, align 8, !dereferenceable !50, !align !50
  %497 = bitcast i8* %496 to i64*
  %498 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %499 = load i8*, i8** %498, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %500 = getelementptr inbounds i8, i8* %499, i64 688
  %add.163 = bitcast i8* %500 to i64*
  %501 = load i64, i64* %497, align 8, !alias.scope !248, !noalias !249
  %502 = load i64, i64* bitcast ([8 x i8]* @2 to i64*), align 8, !alias.scope !249, !noalias !248
  %503 = add i64 %501, %502
  store i64 %503, i64* %add.163, align 8, !alias.scope !248, !noalias !251
  %504 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %505 = load i8*, i8** %504, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %506 = getelementptr inbounds i8, i8* %505, i64 1008
  %tuple.311 = bitcast i8* %506 to [9 x i8*]*
  %507 = bitcast [3 x [3 x %complex128]]* %5 to i8*
  %508 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 0
  store i8* %507, i8** %508, align 8, !alias.scope !252, !noalias !253
  %509 = bitcast [3 x %complex128]* %329 to i8*
  %510 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 1
  store i8* %509, i8** %510, align 8, !alias.scope !252, !noalias !253
  %511 = bitcast [3 x %complex128]* %add.160 to i8*
  %512 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 2
  store i8* %511, i8** %512, align 8, !alias.scope !252, !noalias !253
  %513 = bitcast i64* %add.163 to i8*
  %514 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 3
  store i8* %513, i8** %514, align 8, !alias.scope !252, !noalias !253
  %515 = bitcast [3 x %complex128]* %fusion.30 to i8*
  %516 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 4
  store i8* %515, i8** %516, align 8, !alias.scope !252, !noalias !253
  %517 = bitcast double* %fusion.29 to i8*
  %518 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 5
  store i8* %517, i8** %518, align 8, !alias.scope !252, !noalias !253
  %519 = bitcast [2 x [3 x %complex128]]* %8 to i8*
  %520 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 6
  store i8* %519, i8** %520, align 8, !alias.scope !252, !noalias !253
  %521 = bitcast [2 x [2 x i8]]* %140 to i8*
  %522 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 7
  store i8* %521, i8** %522, align 8, !alias.scope !252, !noalias !253
  %523 = bitcast [2 x [2 x i8]]* %99 to i8*
  %524 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.311, i64 0, i64 8
  store i8* %523, i8** %524, align 8, !alias.scope !252, !noalias !253
  ret void
}

; Function Attrs: nounwind
declare void @blas_ztrsm(i8*, i8**) #4

; Function Attrs: uwtable
define internal void @wide.cond_computation__10.733.clone.clone.clone.clone.clone(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 1008
  %wide_param.42 = bitcast i8* %2 to [9 x i8*]*
  %3 = getelementptr inbounds [9 x i8*], [9 x i8*]* %wide_param.42, i64 0, i64 3
  %4 = load i8*, i8** %3, align 8, !dereferenceable !50, !align !50
  %5 = bitcast i8* %4 to i64*
  %6 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %7 = load i8*, i8** %6, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %compare.179 = getelementptr inbounds i8, i8* %7, i64 720
  %8 = load i64, i64* %5, align 8, !alias.scope !248, !noalias !254
  %9 = load i64, i64* bitcast ([8 x i8]* @2 to i64*), align 8, !alias.scope !256, !noalias !257
  %10 = icmp slt i64 %8, %9
  %11 = zext i1 %10 to i8
  store i8 %11, i8* %compare.179, align 1, !alias.scope !182, !noalias !258
  ret void
}

; Function Attrs: uwtable
define void @EntryModule(i8* %retval, i8* noalias %run_options, i8** noalias %params, i8** noalias %buffer_table, i64* noalias %prof_counters) #0 {
entry:
  %fusion.40.invar_address.dim.1 = alloca i64, align 8
  %fusion.40.invar_address.dim.0 = alloca i64, align 8
  %fusion.39.invar_address.dim.1 = alloca i64, align 8
  %fusion.39.invar_address.dim.0 = alloca i64, align 8
  %fusion.41.invar_address.dim.1 = alloca i64, align 8
  %fusion.41.invar_address.dim.0 = alloca i64, align 8
  %0 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %1 = load i8*, i8** %0, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %2 = getelementptr inbounds i8, i8* %1, i64 288
  %fusion.41 = bitcast i8* %2 to [2 x [3 x %complex128]]*
  store i64 0, i64* %fusion.41.invar_address.dim.0, align 8
  br label %fusion.41.loop_header.dim.0

fusion.41.loop_header.dim.0:                      ; preds = %fusion.41.loop_exit.dim.1, %entry
  %fusion.41.indvar.dim.0 = load i64, i64* %fusion.41.invar_address.dim.0, align 8
  %3 = icmp uge i64 %fusion.41.indvar.dim.0, 2
  br i1 %3, label %fusion.41.loop_exit.dim.0, label %fusion.41.loop_body.dim.0

fusion.41.loop_body.dim.0:                        ; preds = %fusion.41.loop_header.dim.0
  store i64 0, i64* %fusion.41.invar_address.dim.1, align 8
  br label %fusion.41.loop_header.dim.1

fusion.41.loop_header.dim.1:                      ; preds = %fusion.41.loop_body.dim.1, %fusion.41.loop_body.dim.0
  %fusion.41.indvar.dim.1 = load i64, i64* %fusion.41.invar_address.dim.1, align 8
  %4 = icmp uge i64 %fusion.41.indvar.dim.1, 3
  br i1 %4, label %fusion.41.loop_exit.dim.1, label %fusion.41.loop_body.dim.1

fusion.41.loop_body.dim.1:                        ; preds = %fusion.41.loop_header.dim.1
  %5 = mul nuw nsw i64 %fusion.41.indvar.dim.0, 1
  %6 = add nuw nsw i64 0, %5
  %7 = trunc i64 %6 to i32
  %8 = mul nuw nsw i64 %fusion.41.indvar.dim.1, 1
  %9 = add nuw nsw i64 0, %8
  %10 = trunc i64 %9 to i32
  %11 = icmp eq i32 %7, %10
  %12 = zext i1 %11 to i8
  %13 = uitofp i8 %12 to double
  %14 = insertvalue %complex128 zeroinitializer, double %13, 0
  %15 = getelementptr inbounds [2 x [3 x %complex128]], [2 x [3 x %complex128]]* %fusion.41, i64 0, i64 %fusion.41.indvar.dim.0, i64 %fusion.41.indvar.dim.1
  store %complex128 %14, %complex128* %15, align 1, !alias.scope !259, !noalias !260
  %invar.inc1 = add nuw nsw i64 %fusion.41.indvar.dim.1, 1
  store i64 %invar.inc1, i64* %fusion.41.invar_address.dim.1, align 8
  br label %fusion.41.loop_header.dim.1

fusion.41.loop_exit.dim.1:                        ; preds = %fusion.41.loop_header.dim.1
  %invar.inc = add nuw nsw i64 %fusion.41.indvar.dim.0, 1
  store i64 %invar.inc, i64* %fusion.41.invar_address.dim.0, align 8
  br label %fusion.41.loop_header.dim.0

fusion.41.loop_exit.dim.0:                        ; preds = %fusion.41.loop_header.dim.0
  %16 = getelementptr inbounds i8*, i8** %buffer_table, i64 4
  %17 = load i8*, i8** %16, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %parameter.3 = bitcast i8* %17 to [3 x %complex128]*
  %18 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %19 = load i8*, i8** %18, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %20 = getelementptr inbounds i8, i8* %19, i64 640
  %copy.59 = bitcast i8* %20 to [3 x %complex128]*
  %21 = bitcast [3 x %complex128]* %copy.59 to i8*
  %22 = bitcast [3 x %complex128]* %parameter.3 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %21, i8* align 1 %22, i64 48, i1 false)
  %23 = getelementptr inbounds i8*, i8** %buffer_table, i64 5
  %24 = load i8*, i8** %23, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %parameter.5 = bitcast i8* %24 to [3 x %complex128]*
  %25 = getelementptr inbounds i8*, i8** %buffer_table, i64 2
  %26 = load i8*, i8** %25, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %copy.61 = bitcast i8* %26 to [3 x %complex128]*
  %27 = bitcast [3 x %complex128]* %copy.61 to i8*
  %28 = bitcast [3 x %complex128]* %parameter.5 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %27, i8* align 1 %28, i64 48, i1 false)
  %29 = getelementptr inbounds i8*, i8** %buffer_table, i64 13
  %30 = load i8*, i8** %29, align 8, !invariant.load !0, !dereferenceable !50, !align !50
  %parameter.4 = bitcast i8* %30 to i64*
  %31 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %32 = load i8*, i8** %31, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %33 = getelementptr inbounds i8, i8* %32, i64 688
  %copy.60 = bitcast i8* %33 to i64*
  %34 = bitcast i64* %copy.60 to i8*
  %35 = bitcast i64* %parameter.4 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %34, i8* align 1 %35, i64 8, i1 false)
  %36 = getelementptr inbounds i8*, i8** %buffer_table, i64 14
  %37 = load i8*, i8** %36, align 8, !invariant.load !0, !dereferenceable !50, !align !50
  %parameter.6 = bitcast i8* %37 to double*
  %38 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %39 = load i8*, i8** %38, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %40 = getelementptr inbounds i8, i8* %39, i64 704
  %copy.62 = bitcast i8* %40 to double*
  %41 = bitcast double* %copy.62 to i8*
  %42 = bitcast double* %parameter.6 to i8*
  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %41, i8* align 1 %42, i64 8, i1 false)
  %43 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %44 = load i8*, i8** %43, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %45 = getelementptr inbounds i8, i8* %44, i64 768
  %fusion.39 = bitcast i8* %45 to [2 x [2 x i8]]*
  store i64 0, i64* %fusion.39.invar_address.dim.0, align 8
  br label %fusion.39.loop_header.dim.0

fusion.39.loop_header.dim.0:                      ; preds = %fusion.39.loop_exit.dim.1, %fusion.41.loop_exit.dim.0
  %fusion.39.indvar.dim.0 = load i64, i64* %fusion.39.invar_address.dim.0, align 8
  %46 = icmp uge i64 %fusion.39.indvar.dim.0, 2
  br i1 %46, label %fusion.39.loop_exit.dim.0, label %fusion.39.loop_body.dim.0

fusion.39.loop_body.dim.0:                        ; preds = %fusion.39.loop_header.dim.0
  store i64 0, i64* %fusion.39.invar_address.dim.1, align 8
  br label %fusion.39.loop_header.dim.1

fusion.39.loop_header.dim.1:                      ; preds = %fusion.39.loop_body.dim.1, %fusion.39.loop_body.dim.0
  %fusion.39.indvar.dim.1 = load i64, i64* %fusion.39.invar_address.dim.1, align 8
  %47 = icmp uge i64 %fusion.39.indvar.dim.1, 2
  br i1 %47, label %fusion.39.loop_exit.dim.1, label %fusion.39.loop_body.dim.1

fusion.39.loop_body.dim.1:                        ; preds = %fusion.39.loop_header.dim.1
  %48 = mul nuw nsw i64 %fusion.39.indvar.dim.0, 1
  %49 = add nuw nsw i64 0, %48
  %50 = trunc i64 %49 to i32
  %51 = mul nuw nsw i64 %fusion.39.indvar.dim.1, 1
  %52 = add nuw nsw i64 0, %51
  %53 = trunc i64 %52 to i32
  %54 = icmp sge i32 %50, %53
  %55 = zext i1 %54 to i8
  %56 = getelementptr inbounds [2 x [2 x i8]], [2 x [2 x i8]]* %fusion.39, i64 0, i64 %fusion.39.indvar.dim.0, i64 %fusion.39.indvar.dim.1
  store i8 %55, i8* %56, align 1, !alias.scope !31, !noalias !261
  %invar.inc3 = add nuw nsw i64 %fusion.39.indvar.dim.1, 1
  store i64 %invar.inc3, i64* %fusion.39.invar_address.dim.1, align 8
  br label %fusion.39.loop_header.dim.1

fusion.39.loop_exit.dim.1:                        ; preds = %fusion.39.loop_header.dim.1
  %invar.inc2 = add nuw nsw i64 %fusion.39.indvar.dim.0, 1
  store i64 %invar.inc2, i64* %fusion.39.invar_address.dim.0, align 8
  br label %fusion.39.loop_header.dim.0

fusion.39.loop_exit.dim.0:                        ; preds = %fusion.39.loop_header.dim.0
  %57 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %58 = load i8*, i8** %57, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %59 = getelementptr inbounds i8, i8* %58, i64 784
  %fusion.40 = bitcast i8* %59 to [2 x [2 x i8]]*
  store i64 0, i64* %fusion.40.invar_address.dim.0, align 8
  br label %fusion.40.loop_header.dim.0

fusion.40.loop_header.dim.0:                      ; preds = %fusion.40.loop_exit.dim.1, %fusion.39.loop_exit.dim.0
  %fusion.40.indvar.dim.0 = load i64, i64* %fusion.40.invar_address.dim.0, align 8
  %60 = icmp uge i64 %fusion.40.indvar.dim.0, 2
  br i1 %60, label %fusion.40.loop_exit.dim.0, label %fusion.40.loop_body.dim.0

fusion.40.loop_body.dim.0:                        ; preds = %fusion.40.loop_header.dim.0
  store i64 0, i64* %fusion.40.invar_address.dim.1, align 8
  br label %fusion.40.loop_header.dim.1

fusion.40.loop_header.dim.1:                      ; preds = %fusion.40.loop_body.dim.1, %fusion.40.loop_body.dim.0
  %fusion.40.indvar.dim.1 = load i64, i64* %fusion.40.invar_address.dim.1, align 8
  %61 = icmp uge i64 %fusion.40.indvar.dim.1, 2
  br i1 %61, label %fusion.40.loop_exit.dim.1, label %fusion.40.loop_body.dim.1

fusion.40.loop_body.dim.1:                        ; preds = %fusion.40.loop_header.dim.1
  %62 = mul nuw nsw i64 %fusion.40.indvar.dim.0, 1
  %63 = add nuw nsw i64 0, %62
  %64 = trunc i64 %63 to i32
  %65 = mul nuw nsw i64 %fusion.40.indvar.dim.1, 1
  %66 = add nuw nsw i64 0, %65
  %67 = trunc i64 %66 to i32
  %68 = icmp sge i32 %64, %67
  %69 = zext i1 %68 to i8
  %70 = getelementptr inbounds [2 x [2 x i8]], [2 x [2 x i8]]* %fusion.40, i64 0, i64 %fusion.40.indvar.dim.0, i64 %fusion.40.indvar.dim.1
  store i8 %69, i8* %70, align 1, !alias.scope !206, !noalias !262
  %invar.inc5 = add nuw nsw i64 %fusion.40.indvar.dim.1, 1
  store i64 %invar.inc5, i64* %fusion.40.invar_address.dim.1, align 8
  br label %fusion.40.loop_header.dim.1

fusion.40.loop_exit.dim.1:                        ; preds = %fusion.40.loop_header.dim.1
  %invar.inc4 = add nuw nsw i64 %fusion.40.indvar.dim.0, 1
  store i64 %invar.inc4, i64* %fusion.40.invar_address.dim.0, align 8
  br label %fusion.40.loop_header.dim.0

fusion.40.loop_exit.dim.0:                        ; preds = %fusion.40.loop_header.dim.0
  %71 = getelementptr inbounds i8*, i8** %buffer_table, i64 0
  %72 = load i8*, i8** %71, align 8, !invariant.load !0, !dereferenceable !69, !align !2
  %parameter.1 = bitcast i8* %72 to [3 x [3 x %complex128]]*
  %73 = getelementptr inbounds i8*, i8** %buffer_table, i64 3
  %74 = load i8*, i8** %73, align 8, !invariant.load !0, !dereferenceable !25, !align !2
  %parameter.2 = bitcast i8* %74 to [3 x %complex128]*
  %75 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %76 = load i8*, i8** %75, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %77 = getelementptr inbounds i8, i8* %76, i64 1008
  %tuple.309 = bitcast i8* %77 to [9 x i8*]*
  %78 = bitcast [3 x [3 x %complex128]]* %parameter.1 to i8*
  %79 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 0
  store i8* %78, i8** %79, align 8, !alias.scope !252, !noalias !253
  %80 = bitcast [3 x %complex128]* %parameter.2 to i8*
  %81 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 1
  store i8* %80, i8** %81, align 8, !alias.scope !252, !noalias !253
  %82 = bitcast [3 x %complex128]* %copy.59 to i8*
  %83 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 2
  store i8* %82, i8** %83, align 8, !alias.scope !252, !noalias !253
  %84 = bitcast i64* %copy.60 to i8*
  %85 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 3
  store i8* %84, i8** %85, align 8, !alias.scope !252, !noalias !253
  %86 = bitcast [3 x %complex128]* %copy.61 to i8*
  %87 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 4
  store i8* %86, i8** %87, align 8, !alias.scope !252, !noalias !253
  %88 = bitcast double* %copy.62 to i8*
  %89 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 5
  store i8* %88, i8** %89, align 8, !alias.scope !252, !noalias !253
  %90 = bitcast [2 x [3 x %complex128]]* %fusion.41 to i8*
  %91 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 6
  store i8* %90, i8** %91, align 8, !alias.scope !252, !noalias !253
  %92 = bitcast [2 x [2 x i8]]* %fusion.40 to i8*
  %93 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 7
  store i8* %92, i8** %93, align 8, !alias.scope !252, !noalias !253
  %94 = bitcast [2 x [2 x i8]]* %fusion.39 to i8*
  %95 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 8
  store i8* %94, i8** %95, align 8, !alias.scope !252, !noalias !253
  br label %while.88.header

while.88.header:                                  ; preds = %while.88.body, %fusion.40.loop_exit.dim.0
  call void @wide.cond_computation__10.733.clone.clone.clone.clone.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  %96 = getelementptr inbounds i8*, i8** %buffer_table, i64 30
  %97 = load i8*, i8** %96, align 8, !invariant.load !0, !dereferenceable !1, !align !2
  %98 = getelementptr inbounds i8, i8* %97, i64 720
  %99 = load i8, i8* %98, align 1
  %100 = icmp ne i8 %99, 0
  br i1 %100, label %while.88.body, label %while.88.exit

while.88.body:                                    ; preds = %while.88.header
  call void @wide.body_computation__10.636.clone.clone.clone.clone.clone(i8* null, i8* %run_options, i8** null, i8** %buffer_table, i64* %prof_counters)
  br label %while.88.header

while.88.exit:                                    ; preds = %while.88.header
  %101 = getelementptr inbounds [9 x i8*], [9 x i8*]* %tuple.309, i64 0, i64 4
  %102 = load i8*, i8** %101, align 8, !dereferenceable !25, !align !2
  %103 = bitcast i8* %102 to [3 x %complex128]*
  ret void
}

attributes #0 = { uwtable "denormal-fp-math"="preserve-sign" "no-frame-pointer-elim"="false" }
attributes #1 = { argmemonly nounwind }
attributes #2 = { argmemonly nofree nosync nounwind willreturn }
attributes #3 = { nofree nosync nounwind readnone speculatable willreturn }
attributes #4 = { nounwind }

!0 = !{}
!1 = !{i64 1080}
!2 = !{i64 16}
!3 = !{i64 64}
!4 = !{!5}
!5 = !{!"buffer: {index:30, offset:512, size:64}", !6}
!6 = !{!"XLA global AA domain"}
!7 = !{!8, !9, !10, !11, !12}
!8 = !{!"buffer: {index:2, offset:0, size:8}", !6}
!9 = !{!"buffer: {index:30, offset:96, size:4}", !6}
!10 = !{!"buffer: {index:30, offset:384, size:64}", !6}
!11 = !{!"buffer: {index:30, offset:448, size:64}", !6}
!12 = !{!"buffer: {index:30, offset:768, size:4}", !6}
!13 = !{!11}
!14 = !{!10, !5}
!15 = !{!16}
!16 = !{!"buffer: {index:30, offset:576, size:64}", !6}
!17 = !{!18, !19, !10, !5, !12, !20}
!18 = !{!"buffer: {index:2, offset:0, size:4}", !6}
!19 = !{!"buffer: {index:30, offset:112, size:1}", !6}
!20 = !{!"buffer: {index:30, offset:864, size:40}", !6}
!21 = !{!10}
!22 = !{!11, !5, !16}
!23 = !{!8, !9, !5, !16, !12}
!24 = !{i64 4}
!25 = !{i64 48}
!26 = !{!9}
!27 = !{!18, !8, !28, !10, !5, !12}
!28 = !{!"buffer: {index:25, offset:0, size:4}", !6}
!29 = !{!8}
!30 = !{!9, !19, !10, !5, !12}
!31 = !{!12}
!32 = !{!18, !8, !9, !19, !10, !5, !16, !20}
!33 = !{!18, !8, !9, !19, !10, !16, !12, !20}
!34 = !{i64 1}
!35 = !{!19}
!36 = !{!18, !8, !5, !16, !12, !20}
!37 = !{!28}
!38 = !{!18, !9}
!39 = !{!18}
!40 = !{!28, !9, !19, !5, !16, !12, !20}
!41 = !{!20}
!42 = !{!18, !19, !5, !16, !12}
!43 = !{!44, !45}
!44 = !{!"buffer: {index:24, offset:0, size:4}", !6}
!45 = !{!"buffer: {index:30, offset:96, size:1}", !6}
!46 = !{!44}
!47 = !{!18, !45}
!48 = !{!45}
!49 = !{!18, !44}
!50 = !{i64 8}
!51 = !{!52}
!52 = !{!"buffer: {index:30, offset:832, size:24}", !6}
!53 = !{!54, !55, !56}
!54 = !{!"buffer: {index:30, offset:608, size:8}", !6}
!55 = !{!"buffer: {index:30, offset:720, size:1}", !6}
!56 = !{!"buffer: {index:30, offset:736, size:8}", !6}
!57 = !{!58}
!58 = !{!"buffer: {index:30, offset:800, size:24}", !6}
!59 = !{!60, !54, !56}
!60 = !{!"buffer: {index:30, offset:576, size:8}", !6}
!61 = !{!60}
!62 = !{!63, !64}
!63 = !{!"buffer: {index:20, offset:0, size:8}", !6}
!64 = !{!"buffer: {index:30, offset:592, size:1}", !6}
!65 = !{!63}
!66 = !{!60, !64}
!67 = !{!64}
!68 = !{!63, !60}
!69 = !{i64 144}
!70 = !{!71}
!71 = !{!"buffer: {index:30, offset:0, size:144}", !6}
!72 = !{!73, !74, !75, !76, !77, !56, !78}
!73 = !{!"buffer: {index:2, offset:0, size:48}", !6}
!74 = !{!"buffer: {index:30, offset:144, size:144}", !6}
!75 = !{!"buffer: {index:30, offset:480, size:48}", !6}
!76 = !{!"buffer: {index:30, offset:528, size:48}", !6}
!77 = !{!"buffer: {index:30, offset:720, size:8}", !6}
!78 = !{!"buffer: {index:30, offset:960, size:48}", !6}
!79 = !{!75}
!80 = !{!71, !76, !81}
!81 = !{!"buffer: {index:30, offset:576, size:48}", !6}
!82 = !{!76}
!83 = !{!73, !71, !74, !75, !81}
!84 = !{!74}
!85 = !{!73, !71, !75, !76, !81, !77, !56, !78}
!86 = distinct !{!86, !87}
!87 = !{!"llvm.loop.unroll.disable"}
!88 = !{!81}
!89 = !{!74, !75, !76}
!90 = !{!73, !71, !74, !91, !81, !54, !77, !56, !78}
!91 = !{!"buffer: {index:30, offset:576, size:24}", !6}
!92 = !{!91}
!93 = !{!75, !54}
!94 = !{!54}
!95 = !{!75, !91}
!96 = !{!60, !56, !58}
!97 = !{!73}
!98 = !{!71, !74, !75, !76, !77, !56, !78}
!99 = !{!100, !54, !77, !56, !58}
!100 = !{!"buffer: {index:19, offset:0, size:8}", !6}
!101 = !{!100}
!102 = !{!60, !77}
!103 = !{!77}
!104 = !{!73, !100, !71, !74, !75, !60, !56, !78}
!105 = !{!78}
!106 = !{!73, !71, !74, !75, !77, !56}
!107 = distinct !{!107, !87, !108}
!108 = !{!"llvm.loop.vectorize.enable", i1 false}
!109 = distinct !{!109, !87, !108}
!110 = distinct !{!110, !87, !108}
!111 = distinct !{!111, !87, !108}
!112 = distinct !{!112, !87, !108}
!113 = distinct !{!113, !87, !108}
!114 = distinct !{!114, !87, !108}
!115 = distinct !{!115, !87, !108}
!116 = distinct !{!116, !87, !108}
!117 = distinct !{!117, !87, !108}
!118 = !{!119, !120}
!119 = !{!"buffer: {index:30, offset:528, size:24}", !6}
!120 = !{!"buffer: {index:30, offset:560, size:8}", !6}
!121 = !{!119}
!122 = !{!73, !120}
!123 = !{!120}
!124 = !{!73, !119}
!125 = !{!126, !120, !56}
!126 = !{!"buffer: {index:30, offset:528, size:1}", !6}
!127 = !{!126, !119, !77, !56}
!128 = !{!56}
!129 = !{!126, !120, !77}
!130 = !{!126}
!131 = !{!120, !77, !56}
!132 = !{!133}
!133 = !{!"buffer: {index:7, offset:0, size:1}", !6}
!134 = !{!135}
!135 = !{!"buffer: {index:1, offset:0, size:1}", !6}
!136 = !{!137}
!137 = !{!"buffer: {index:6, offset:0, size:1}", !6}
!138 = !{!139}
!139 = !{!"buffer: {index:10, offset:0, size:1}", !6}
!140 = !{!141}
!141 = !{!"buffer: {index:8, offset:0, size:1}", !6}
!142 = !{!143}
!143 = !{!"buffer: {index:9, offset:0, size:1}", !6}
!144 = !{!145}
!145 = !{!"buffer: {index:30, offset:624, size:8}", !6}
!146 = !{!8, !73, !147, !74, !148, !75, !126, !55, !77, !56, !149}
!147 = !{!"buffer: {index:18, offset:0, size:8}", !6}
!148 = !{!"buffer: {index:30, offset:384, size:96}", !6}
!149 = !{!"buffer: {index:30, offset:752, size:8}", !6}
!150 = !{!73, !71, !75, !81, !145, !55, !77, !56, !149, !78}
!151 = !{!152, !74, !76, !145}
!152 = !{!"buffer: {index:0, offset:0, size:144}", !6}
!153 = !{!152}
!154 = !{!8, !73, !155, !74, !148, !76, !156}
!155 = !{!"buffer: {index:30, offset:0, size:1}", !6}
!156 = !{!"buffer: {index:30, offset:912, size:40}", !6}
!157 = distinct !{!157, !87}
!158 = !{!152, !73, !71, !75, !91, !81, !149}
!159 = !{!71, !74, !76, !81}
!160 = distinct !{!160, !87}
!161 = !{!73, !74, !75, !76}
!162 = !{!73, !71, !74, !76, !91, !81, !54, !77, !56, !78}
!163 = !{!55, !56, !52}
!164 = !{!76, !149}
!165 = !{!149}
!166 = !{!76, !91}
!167 = !{!73, !155, !74, !148, !75, !126, !145, !55, !56}
!168 = !{!54, !55, !149, !52}
!169 = !{!71, !74, !75, !77, !56, !78}
!170 = !{!73, !71, !74, !119, !145, !55, !77, !56, !149, !78}
!171 = !{!75, !56}
!172 = !{!75, !119}
!173 = !{!73, !155, !74, !148, !75, !126, !145, !55, !149}
!174 = !{!126, !145}
!175 = !{!73, !148, !145, !77, !56, !149}
!176 = !{i64 96}
!177 = !{!148}
!178 = !{!73, !126, !145, !56, !149}
!179 = !{!152, !8, !73, !155, !74, !126, !145, !56, !149, !156}
!180 = !{!71, !74, !148, !75, !126, !145, !77, !56, !149, !78}
!181 = !{!145, !55}
!182 = !{!55}
!183 = !{!8, !74, !75, !145, !56, !149}
!184 = !{!152, !8, !155, !148, !75, !145, !55, !56, !149, !156}
!185 = !{!155}
!186 = !{!152, !8, !74, !148, !56, !149, !156}
!187 = !{!147}
!188 = !{!8, !145, !77}
!189 = !{!152, !147, !155, !74, !148, !145, !156}
!190 = !{!156}
!191 = !{!152, !8, !155, !74, !148}
!192 = !{!155, !55}
!193 = !{!8, !55}
!194 = !{!8, !155}
!195 = !{!152, !8, !73, !155, !148, !156}
!196 = !{!152, !8, !155, !197, !74, !16, !156}
!197 = !{!"buffer: {index:30, offset:0, size:96}", !6}
!198 = !{!197}
!199 = !{!73, !200, !148, !16}
!200 = !{!"buffer: {index:30, offset:96, size:32}", !6}
!201 = !{!197, !148}
!202 = !{!18, !19, !5, !12, !20}
!203 = !{!204}
!204 = !{!"buffer: {index:12, offset:0, size:16}", !6}
!205 = !{!18, !204, !19, !16, !12, !20}
!206 = !{!207}
!207 = !{!"buffer: {index:30, offset:784, size:4}", !6}
!208 = !{!152, !73, !209, !19, !210, !10, !5, !211, !212, !213, !12, !214}
!209 = !{!"buffer: {index:3, offset:0, size:48}", !6}
!210 = !{!"buffer: {index:30, offset:288, size:96}", !6}
!211 = !{!"buffer: {index:30, offset:640, size:48}", !6}
!212 = !{!"buffer: {index:30, offset:688, size:8}", !6}
!213 = !{!"buffer: {index:30, offset:704, size:8}", !6}
!214 = !{!"buffer: {index:30, offset:1008, size:72}", !6}
!215 = !{!18, !10, !5, !16, !12, !207, !20}
!216 = !{!18, !19, !10, !16, !12, !207, !20}
!217 = !{!218, !219, !220, !221, !222, !223, !200, !19, !5, !207}
!218 = !{!"buffer: {index:2, offset:0, size:32}", !6}
!219 = !{!"buffer: {index:11, offset:0, size:16}", !6}
!220 = !{!"buffer: {index:21, offset:0, size:4}", !6}
!221 = !{!"buffer: {index:22, offset:0, size:4}", !6}
!222 = !{!"buffer: {index:23, offset:0, size:4}", !6}
!223 = !{!"buffer: {index:30, offset:0, size:32}", !6}
!224 = !{!197, !200, !213}
!225 = !{!213}
!226 = distinct !{!226, !87}
!227 = !{!200}
!228 = !{!73, !197}
!229 = !{!152, !8, !73, !155, !223, !148, !156}
!230 = !{!223}
!231 = !{!218, !73, !219, !220, !221, !222, !74, !10}
!232 = !{!223, !74, !211}
!233 = !{!211}
!234 = !{!152, !73, !209, !210, !212, !213, !12, !207, !214}
!235 = !{!8, !73, !209, !155, !74, !210, !148, !211, !212, !213, !12, !207, !156, !214}
!236 = distinct !{!236, !87}
!237 = !{!152, !209, !211}
!238 = !{!209}
!239 = !{!152, !73, !210, !211, !212, !213, !12, !207, !214}
!240 = !{!209, !241, !77}
!241 = !{!"buffer: {index:30, offset:384, size:24}", !6}
!242 = !{!241}
!243 = !{!73, !77}
!244 = !{!73, !241}
!245 = !{!73, !213}
!246 = !{!152, !209, !210, !211, !212, !213, !77, !12, !207, !214}
!247 = !{!152, !73, !209, !210, !211, !212, !77, !12, !207, !214}
!248 = !{!212}
!249 = !{!250}
!250 = !{!"buffer: {index:17, offset:0, size:8}", !6}
!251 = !{!152, !73, !209, !250, !210, !211, !213, !12, !207, !214}
!252 = !{!214}
!253 = !{!152, !73, !209, !210, !211, !212, !213, !12, !207}
!254 = !{!255, !55}
!255 = !{!"buffer: {index:15, offset:0, size:8}", !6}
!256 = !{!255}
!257 = !{!212, !55}
!258 = !{!255, !212}
!259 = !{!210}
!260 = !{!152, !73, !209, !211, !212, !213, !12, !207, !214}
!261 = !{!152, !73, !209, !210, !211, !212, !213, !207, !214}
!262 = !{!152, !73, !209, !210, !211, !212, !213, !12, !214}