; ModuleID = 'sum_squares'
source_filename = "<string>"
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-pc-windows-msvc"

@"_ZN08NumbaEnv8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE" = common local_unnamed_addr global i8* null
@printf_format = internal constant [17 x i8] c"num_threads: %d\0A\00"
@.const.picklebuf.2282557571776 = internal constant { i8*, i32, i8* } { i8* getelementptr inbounds ([112 x i8], [112 x i8]* @.const.pickledata.2282557571776, i32 0, i32 0), i32 112, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.const.pickledata.2282557571776.sha1, i32 0, i32 0) }
@.const.pickledata.2282557571776 = internal constant [112 x i8] c"\80\04\95e\00\00\00\00\00\00\00\8C\08builtins\94\8C\0CRuntimeError\94\93\94\8C@Invalid number of threads. This likely indicates a bug in Numba.\94\85\94N\87\94."
@.const.pickledata.2282557571776.sha1 = internal constant [20 x i8] c"\9D\8B\D6\D5A\B3\E36\FDy\17\99I@x\1B\C6\8A:\8A"
@.const.sum_squares = internal constant [12 x i8] c"sum_squares\00"
@PyExc_RuntimeError = external global i8
@".const.missing Environment: _ZN08NumbaEnv8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE" = internal constant [94 x i8] c"missing Environment: _ZN08NumbaEnv8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE\00"
@PyExc_TypeError = external global i8
@".const.can't unbox array from PyObject into native value.  The object maybe of a different type" = internal constant [89 x i8] c"can't unbox array from PyObject into native value.  The object maybe of a different type\00"
@_Py_NoneStruct = external global i8
@PyExc_StopIteration = external global i8
@PyExc_SystemError = external global i8
@".const.unknown error when calling native function" = internal constant [43 x i8] c"unknown error when calling native function\00"
@".const.<numba.core.cpu.CPUContext object at 0x0000021372BB96A0>" = internal constant [57 x i8] c"<numba.core.cpu.CPUContext object at 0x0000021372BB96A0>\00"
@".const.unknown error when calling native function.1" = internal constant [43 x i8] c"unknown error when calling native function\00"
@"_ZN08NumbaEnv13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE" = common local_unnamed_addr global i8* null

define i32 @"_ZN8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE"(double* noalias nocapture %retptr, { i8*, i32, i8* }** noalias nocapture %excinfo, i8* %arg.a.0, i8* nocapture readnone %arg.a.1, i64 %arg.a.2, i64 %arg.a.3, double* %arg.a.4, i64 %arg.a.5.0, i64 %arg.a.5.1, i64 %arg.a.6.0, i64 %arg.a.6.1) local_unnamed_addr {
entry:
  %.7.i = alloca i32, align 4
  %dims1 = alloca [2 x i64], align 8
  %dims1.sub1 = bitcast [2 x i64]* %dims1 to i64*
  %dims.12 = alloca [2 x i64], align 8
  %dims.12.sub2 = bitcast [2 x i64]* %dims.12 to i64*
  %sched3 = alloca [64 x i64], align 8
  %sched3.sub3 = bitcast [64 x i64]* %sched3 to i64*
  store i64 0, i64* %sched3.sub3, align 8
  %pargs4 = alloca [3 x i8*], align 8
  %pargs4.sub4 = bitcast [3 x i8*]* %pargs4 to i8**
  store i8* null, i8** %pargs4.sub4, align 8
  %pshape5 = alloca [4 x i64], align 8
  %pshape5.sub5 = bitcast [4 x i64]* %pshape5 to i64*
  store i64 0, i64* %pshape5.sub5, align 8
  %psteps6 = alloca [6 x i64], align 8
  %psteps6.sub6 = bitcast [6 x i64]* %psteps6 to i64*
  store i64 0, i64* %psteps6.sub6, align 8
  tail call void @NRT_incref(i8* %arg.a.0)
  %.118 = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 128, i32 32)
  %.5.i = getelementptr i8, i8* %.118, i64 24
  %0 = bitcast i8* %.5.i to i8**
  %.6.i = load i8*, i8** %0, align 8
  %.665 = add i64 %arg.a.5.0, -1
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(128) %.6.i, i8 0, i64 128, i1 false)
  store i64 0, i64* %dims1.sub1, align 8
  store i64 %.665, i64* %dims.12.sub2, align 8
  %.670 = add i64 %arg.a.5.1, -1
  %.671 = getelementptr inbounds [2 x i64], [2 x i64]* %dims1, i64 0, i64 1
  store i64 0, i64* %.671, align 8
  %.673 = getelementptr inbounds [2 x i64], [2 x i64]* %dims.12, i64 0, i64 1
  store i64 %.670, i64* %.673, align 8
  %.676 = tail call i64 @get_num_threads()
  %.677 = icmp slt i64 %.676, 1
  br i1 %.677, label %B0.endif.endif.endif.if, label %B0.endif.endif.endif.endif, !prof !0

B0.endif.endif.endif.if:                          ; preds = %entry
  %.680 = tail call i32 (i8*, ...) @printf(i8* nonnull dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @printf_format, i64 0, i64 0), i64 %.676)
  store { i8*, i32, i8* }* @.const.picklebuf.2282557571776, { i8*, i32, i8* }** %excinfo, align 8
  ret i32 1

B0.endif.endif.endif.endif:                       ; preds = %entry
  %1 = bitcast [6 x i64]* %psteps6 to i64*
  %2 = bitcast [4 x i64]* %pshape5 to i64*
  %3 = bitcast [64 x i64]* %sched3 to i64*
  %4 = bitcast [2 x i64]* %dims.12 to i64*
  %5 = bitcast [2 x i64]* %dims1 to i64*
  %.122 = bitcast i8* %.6.i to double*
  %.659 = getelementptr i8, i8* %.6.i, i64 120
  %6 = bitcast i8* %.659 to double*
  %.627 = getelementptr i8, i8* %.6.i, i64 112
  %7 = bitcast i8* %.627 to double*
  %.595 = getelementptr i8, i8* %.6.i, i64 104
  %8 = bitcast i8* %.595 to double*
  %.563 = getelementptr i8, i8* %.6.i, i64 96
  %9 = bitcast i8* %.563 to double*
  %.531 = getelementptr i8, i8* %.6.i, i64 88
  %10 = bitcast i8* %.531 to double*
  %.499 = getelementptr i8, i8* %.6.i, i64 80
  %11 = bitcast i8* %.499 to double*
  %.467 = getelementptr i8, i8* %.6.i, i64 72
  %12 = bitcast i8* %.467 to double*
  %.435 = getelementptr i8, i8* %.6.i, i64 64
  %13 = bitcast i8* %.435 to double*
  %.403 = getelementptr i8, i8* %.6.i, i64 56
  %14 = bitcast i8* %.403 to double*
  %.371 = getelementptr i8, i8* %.6.i, i64 48
  %15 = bitcast i8* %.371 to double*
  %.339 = getelementptr i8, i8* %.6.i, i64 40
  %16 = bitcast i8* %.339 to double*
  %.307 = getelementptr i8, i8* %.6.i, i64 32
  %17 = bitcast i8* %.307 to double*
  %.275 = getelementptr i8, i8* %.6.i, i64 24
  %18 = bitcast i8* %.275 to double*
  %.243 = getelementptr i8, i8* %.6.i, i64 16
  %19 = bitcast i8* %.243 to double*
  %.211 = getelementptr i8, i8* %.6.i, i64 8
  %20 = bitcast i8* %.211 to double*
  %.686 = call i64* @do_scheduling_unsigned(i64 2, i64* nonnull %5, i64* nonnull %4, i64 %.676, i64* nonnull %3, i64 0)
  %21 = bitcast [3 x i8*]* %pargs4 to [64 x i64]**
  store [64 x i64]* %sched3, [64 x i64]** %21, align 8
  %.692 = getelementptr inbounds [3 x i8*], [3 x i8*]* %pargs4, i64 0, i64 1
  %22 = bitcast i8** %.692 to double**
  store double* %arg.a.4, double** %22, align 8
  %.705 = getelementptr inbounds [3 x i8*], [3 x i8*]* %pargs4, i64 0, i64 2
  store i8* %.6.i, i8** %.705, align 8
  store i64 %.676, i64* %2, align 8
  %.750 = getelementptr inbounds [4 x i64], [4 x i64]* %pshape5, i64 0, i64 1
  store i64 4, i64* %.750, align 8
  %.752 = getelementptr inbounds [4 x i64], [4 x i64]* %pshape5, i64 0, i64 2
  store i64 %arg.a.5.0, i64* %.752, align 8
  %.754 = getelementptr inbounds [4 x i64], [4 x i64]* %pshape5, i64 0, i64 3
  store i64 %arg.a.5.1, i64* %.754, align 8
  store i64 32, i64* %1, align 8
  %.758 = getelementptr inbounds [6 x i64], [6 x i64]* %psteps6, i64 0, i64 1
  store i64 0, i64* %.758, align 8
  %.760 = getelementptr inbounds [6 x i64], [6 x i64]* %psteps6, i64 0, i64 2
  store i64 8, i64* %.760, align 8
  %.762 = getelementptr inbounds [6 x i64], [6 x i64]* %psteps6, i64 0, i64 3
  store i64 8, i64* %.762, align 8
  %.764 = getelementptr inbounds [6 x i64], [6 x i64]* %psteps6, i64 0, i64 4
  store i64 %arg.a.6.0, i64* %.764, align 8
  %.766 = getelementptr inbounds [6 x i64], [6 x i64]* %psteps6, i64 0, i64 5
  store i64 %arg.a.6.1, i64* %.766, align 8
  %23 = bitcast i32* %.7.i to i8*
  call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %23)
  store i32 0, i32* %.7.i, align 4
  call void @numba_gil_ensure(i32* nonnull %.7.i)
  %.10.i = call i8* @PyEval_SaveThread()
  %.11.i = call i64 @get_num_threads()
  %.13.i = bitcast [3 x i8*]* %pargs4 to i8*
  %.14.i = bitcast [4 x i64]* %pshape5 to i8*
  %.15.i = bitcast [6 x i64]* %psteps6 to i8*
  call void @numba_parallel_for(i8* bitcast (void (i8**, i64*, i64*, i8*)* @"__gufunc__._ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE" to i8*), i8* nonnull %.13.i, i8* nonnull %.14.i, i8* nonnull %.15.i, i8* null, i64 3, i64 4, i64 %.11.i)
  call void @PyEval_RestoreThread(i8* %.10.i)
  call void @numba_gil_release(i32* nonnull %.7.i)
  call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %23)
  %.799 = load double, double* %.122, align 8
  %.809 = fadd double %.799, 0.000000e+00
  %.846 = load double, double* %20, align 8
  %.855 = fadd double %.809, %.846
  %.891 = load double, double* %19, align 8
  %.900 = fadd double %.855, %.891
  %.936 = load double, double* %18, align 8
  %.945 = fadd double %.900, %.936
  %.981 = load double, double* %17, align 8
  %.990 = fadd double %.945, %.981
  %.1026 = load double, double* %16, align 8
  %.1035 = fadd double %.990, %.1026
  %.1071 = load double, double* %15, align 8
  %.1080 = fadd double %.1035, %.1071
  %.1116 = load double, double* %14, align 8
  %.1125 = fadd double %.1080, %.1116
  %.1161 = load double, double* %13, align 8
  %.1170 = fadd double %.1125, %.1161
  %.1206 = load double, double* %12, align 8
  %.1215 = fadd double %.1170, %.1206
  %.1251 = load double, double* %11, align 8
  %.1260 = fadd double %.1215, %.1251
  %.1296 = load double, double* %10, align 8
  %.1305 = fadd double %.1260, %.1296
  %.1341 = load double, double* %9, align 8
  %.1350 = fadd double %.1305, %.1341
  %.1386 = load double, double* %8, align 8
  %.1395 = fadd double %.1350, %.1386
  %.1431 = load double, double* %7, align 8
  %.1440 = fadd double %.1395, %.1431
  %.1476 = load double, double* %6, align 8
  %.1485 = fadd double %.1440, %.1476
  call void @NRT_decref(i8* %.118)
  call void @NRT_decref(i8* %arg.a.0)
  store double %.1485, double* %retptr, align 8
  ret i32 0
}

declare noalias i8* @NRT_MemInfo_alloc_safe_aligned(i64, i32) local_unnamed_addr

declare i64 @get_num_threads() local_unnamed_addr

; Function Attrs: nofree nounwind
declare i32 @printf(i8* nocapture readonly, ...) local_unnamed_addr #0

declare i64* @do_scheduling_unsigned(i64, i64*, i64*, i64, i64*, i64) local_unnamed_addr

define i8* @"_ZN7cpython8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE"(i8* nocapture readnone %py_closure, i8* %py_args, i8* nocapture readnone %py_kws) local_unnamed_addr {
entry:
  %.5 = alloca i8*, align 8
  %.6 = call i32 (i8*, i8*, i64, i64, ...) @PyArg_UnpackTuple(i8* %py_args, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.const.sum_squares, i64 0, i64 0), i64 1, i64 1, i8** nonnull %.5)
  %.7 = icmp eq i32 %.6, 0
  %.21 = alloca { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }, align 8
  %.45 = alloca double, align 8
  %0 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(72) %0, i8 0, i64 72, i1 false)
  store double 0.000000e+00, double* %.45, align 8
  %excinfo = alloca { i8*, i32, i8* }*, align 8
  store { i8*, i32, i8* }* null, { i8*, i32, i8* }** %excinfo, align 8
  br i1 %.7, label %entry.if, label %entry.endif, !prof !0

entry.if:                                         ; preds = %entry.endif.endif.endif.endif.endif.endif.endif.endif, %entry.endif.endif.endif.endif.endif.endif.if, %entry.endif.endif.endif.endif.endif.if.if, %entry.endif.endif.endif.endif.endif.endif, %entry.endif.endif.endif.endif.endif.if, %entry.endif.endif.endif.thread, %entry
  ret i8* null

entry.endif:                                      ; preds = %entry
  %.11 = load i8*, i8** @"_ZN08NumbaEnv8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE", align 8
  %.16 = icmp eq i8* %.11, null
  br i1 %.16, label %entry.endif.if, label %entry.endif.endif, !prof !0

entry.endif.if:                                   ; preds = %entry.endif
  call void @PyErr_SetString(i8* nonnull @PyExc_RuntimeError, i8* getelementptr inbounds ([94 x i8], [94 x i8]* @".const.missing Environment: _ZN08NumbaEnv8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE", i64 0, i64 0))
  ret i8* null

entry.endif.endif:                                ; preds = %entry.endif
  %.20 = load i8*, i8** %.5, align 8
  %.24 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %1 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  call void @llvm.memset.p0i8.i64(i8* nonnull align 8 dereferenceable(72) %1, i8 0, i64 72, i1 false)
  %.25 = call i32 @NRT_adapt_ndarray_from_python(i8* %.20, i8* nonnull %.24)
  %2 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr = getelementptr inbounds i8, i8* %2, i64 24
  %3 = bitcast i8* %sunkaddr to i64*
  %.29 = load i64, i64* %3, align 8
  %.30 = icmp ne i64 %.29, 8
  %.31 = icmp ne i32 %.25, 0
  %.32 = or i1 %.31, %.30
  br i1 %.32, label %entry.endif.endif.endif.thread, label %entry.endif.endif.endif.endif, !prof !0

entry.endif.endif.endif.thread:                   ; preds = %entry.endif.endif
  call void @PyErr_SetString(i8* nonnull @PyExc_TypeError, i8* getelementptr inbounds ([89 x i8], [89 x i8]* @".const.can't unbox array from PyObject into native value.  The object maybe of a different type", i64 0, i64 0))
  br label %entry.if

entry.endif.endif.endif.endif:                    ; preds = %entry.endif.endif
  %4 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8**
  %.36.fca.0.load = load i8*, i8** %4, align 8
  %5 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr2 = getelementptr inbounds i8, i8* %5, i64 8
  %6 = bitcast i8* %sunkaddr2 to i8**
  %.36.fca.1.load = load i8*, i8** %6, align 8
  %7 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr3 = getelementptr inbounds i8, i8* %7, i64 16
  %8 = bitcast i8* %sunkaddr3 to i64*
  %.36.fca.2.load = load i64, i64* %8, align 8
  %9 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr4 = getelementptr inbounds i8, i8* %9, i64 32
  %10 = bitcast i8* %sunkaddr4 to double**
  %.36.fca.4.load = load double*, double** %10, align 8
  %11 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr5 = getelementptr inbounds i8, i8* %11, i64 40
  %12 = bitcast i8* %sunkaddr5 to i64*
  %.36.fca.5.0.load = load i64, i64* %12, align 8
  %13 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr6 = getelementptr inbounds i8, i8* %13, i64 48
  %14 = bitcast i8* %sunkaddr6 to i64*
  %.36.fca.5.1.load = load i64, i64* %14, align 8
  %15 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr7 = getelementptr inbounds i8, i8* %15, i64 56
  %16 = bitcast i8* %sunkaddr7 to i64*
  %.36.fca.6.0.load = load i64, i64* %16, align 8
  %17 = bitcast { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] }* %.21 to i8*
  %sunkaddr8 = getelementptr inbounds i8, i8* %17, i64 64
  %18 = bitcast i8* %sunkaddr8 to i64*
  %.36.fca.6.1.load = load i64, i64* %18, align 8
  store double 0.000000e+00, double* %.45, align 8
  %.53 = call i32 @"_ZN8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE"(double* nonnull %.45, { i8*, i32, i8* }** nonnull %excinfo, i8* %.36.fca.0.load, i8* %.36.fca.1.load, i64 %.36.fca.2.load, i64 8, double* %.36.fca.4.load, i64 %.36.fca.5.0.load, i64 %.36.fca.5.1.load, i64 %.36.fca.6.0.load, i64 %.36.fca.6.1.load)
  %.54 = load { i8*, i32, i8* }*, { i8*, i32, i8* }** %excinfo, align 8
  %.63 = load double, double* %.45, align 8
  call void @NRT_decref(i8* %.36.fca.0.load)
  switch i32 %.53, label %entry.endif.endif.endif.endif.endif [
    i32 -2, label %entry.endif.endif.endif.endif.if.if
    i32 0, label %entry.endif.endif.endif.endif.if.endif
  ]

entry.endif.endif.endif.endif.endif:              ; preds = %entry.endif.endif.endif.endif
  %.61 = icmp sgt i32 %.53, 0
  br i1 %.61, label %entry.endif.endif.endif.endif.endif.if, label %entry.endif.endif.endif.endif.endif.endif

entry.endif.endif.endif.endif.if.if:              ; preds = %entry.endif.endif.endif.endif
  call void @Py_IncRef(i8* nonnull @_Py_NoneStruct)
  ret i8* @_Py_NoneStruct

entry.endif.endif.endif.endif.if.endif:           ; preds = %entry.endif.endif.endif.endif
  %.73 = call i8* @PyFloat_FromDouble(double %.63)
  ret i8* %.73

entry.endif.endif.endif.endif.endif.if:           ; preds = %entry.endif.endif.endif.endif.endif
  call void @PyErr_Clear()
  %.78 = load { i8*, i32, i8* }, { i8*, i32, i8* }* %.54, align 8
  %.79 = extractvalue { i8*, i32, i8* } %.78, 0
  %.81 = extractvalue { i8*, i32, i8* } %.78, 1
  %.83 = extractvalue { i8*, i32, i8* } %.78, 2
  %.84 = call i8* @numba_unpickle(i8* %.79, i32 %.81, i8* %.83)
  %.85 = icmp eq i8* %.84, null
  br i1 %.85, label %entry.if, label %entry.endif.endif.endif.endif.endif.if.if, !prof !0

entry.endif.endif.endif.endif.endif.endif:        ; preds = %entry.endif.endif.endif.endif.endif
  switch i32 %.53, label %entry.endif.endif.endif.endif.endif.endif.endif.endif [
    i32 -3, label %entry.endif.endif.endif.endif.endif.endif.if
    i32 -1, label %entry.if
  ]

entry.endif.endif.endif.endif.endif.if.if:        ; preds = %entry.endif.endif.endif.endif.endif.if
  call void @numba_do_raise(i8* nonnull %.84)
  br label %entry.if

entry.endif.endif.endif.endif.endif.endif.if:     ; preds = %entry.endif.endif.endif.endif.endif.endif
  call void @PyErr_SetNone(i8* nonnull @PyExc_StopIteration)
  br label %entry.if

entry.endif.endif.endif.endif.endif.endif.endif.endif: ; preds = %entry.endif.endif.endif.endif.endif.endif
  call void @PyErr_SetString(i8* nonnull @PyExc_SystemError, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @".const.unknown error when calling native function", i64 0, i64 0))
  br label %entry.if
}

declare i32 @PyArg_UnpackTuple(i8*, i8*, i64, i64, ...) local_unnamed_addr

declare void @PyErr_SetString(i8*, i8*) local_unnamed_addr

declare i32 @NRT_adapt_ndarray_from_python(i8* nocapture, i8* nocapture) local_unnamed_addr

declare void @Py_IncRef(i8*) local_unnamed_addr

declare i8* @PyFloat_FromDouble(double) local_unnamed_addr

declare void @PyErr_Clear() local_unnamed_addr

declare i8* @numba_unpickle(i8*, i32, i8*) local_unnamed_addr

declare void @numba_do_raise(i8*) local_unnamed_addr

declare void @PyErr_SetNone(i8*) local_unnamed_addr

define double @"cfunc._ZN8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE"({ i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1) local_unnamed_addr {
entry:
  %.3 = alloca double, align 8
  store double 0.000000e+00, double* %.3, align 8
  %excinfo = alloca { i8*, i32, i8* }*, align 8
  store { i8*, i32, i8* }* null, { i8*, i32, i8* }** %excinfo, align 8
  %extracted.meminfo = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 0
  %extracted.parent = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 1
  %extracted.nitems = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 2
  %extracted.itemsize = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 3
  %extracted.data = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 4
  %extracted.shape = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 5
  %.7 = extractvalue [2 x i64] %extracted.shape, 0
  %.8 = extractvalue [2 x i64] %extracted.shape, 1
  %extracted.strides = extractvalue { i8*, i8*, i64, i64, double*, [2 x i64], [2 x i64] } %.1, 6
  %.9 = extractvalue [2 x i64] %extracted.strides, 0
  %.10 = extractvalue [2 x i64] %extracted.strides, 1
  %.11 = call i32 @"_ZN8__main__16sum_squares$2424E5ArrayIdLi2E1C7mutable7alignedE"(double* nonnull %.3, { i8*, i32, i8* }** nonnull %excinfo, i8* %extracted.meminfo, i8* %extracted.parent, i64 %extracted.nitems, i64 %extracted.itemsize, double* %extracted.data, i64 %.7, i64 %.8, i64 %.9, i64 %.10)
  %.12 = load { i8*, i32, i8* }*, { i8*, i32, i8* }** %excinfo, align 8
  %.21 = load double, double* %.3, align 8
  %.23 = alloca i32, align 4
  store i32 0, i32* %.23, align 4
  switch i32 %.11, label %entry.if [
    i32 -2, label %entry.endif
    i32 0, label %entry.endif
  ]

entry.if:                                         ; preds = %entry
  %.19 = icmp sgt i32 %.11, 0
  call void @numba_gil_ensure(i32* nonnull %.23)
  br i1 %.19, label %entry.if.if, label %entry.if.endif

entry.endif:                                      ; preds = %.26, %entry, %entry
  ret double %.21

.26:                                              ; preds = %entry.if.endif.endif.endif, %entry.if.endif.if, %entry.if.if.if, %entry.if.endif, %entry.if.if
  %.48 = call i8* @PyUnicode_FromString(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @".const.<numba.core.cpu.CPUContext object at 0x0000021372BB96A0>", i64 0, i64 0))
  call void @PyErr_WriteUnraisable(i8* %.48)
  call void @Py_DecRef(i8* %.48)
  call void @numba_gil_release(i32* nonnull %.23)
  br label %entry.endif

entry.if.if:                                      ; preds = %entry.if
  call void @PyErr_Clear()
  %.29 = load { i8*, i32, i8* }, { i8*, i32, i8* }* %.12, align 8
  %.30 = extractvalue { i8*, i32, i8* } %.29, 0
  %.32 = extractvalue { i8*, i32, i8* } %.29, 1
  %.34 = extractvalue { i8*, i32, i8* } %.29, 2
  %.35 = call i8* @numba_unpickle(i8* %.30, i32 %.32, i8* %.34)
  %.36 = icmp eq i8* %.35, null
  br i1 %.36, label %.26, label %entry.if.if.if, !prof !0

entry.if.endif:                                   ; preds = %entry.if
  switch i32 %.11, label %entry.if.endif.endif.endif [
    i32 -3, label %entry.if.endif.if
    i32 -1, label %.26
  ]

entry.if.if.if:                                   ; preds = %entry.if.if
  call void @numba_do_raise(i8* nonnull %.35)
  br label %.26

entry.if.endif.if:                                ; preds = %entry.if.endif
  call void @PyErr_SetNone(i8* nonnull @PyExc_StopIteration)
  br label %.26

entry.if.endif.endif.endif:                       ; preds = %entry.if.endif
  call void @PyErr_SetString(i8* nonnull @PyExc_SystemError, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @".const.unknown error when calling native function.1", i64 0, i64 0))
  br label %.26
}

declare void @numba_gil_ensure(i32*) local_unnamed_addr

declare i8* @PyUnicode_FromString(i8*) local_unnamed_addr

declare void @PyErr_WriteUnraisable(i8*) local_unnamed_addr

declare void @Py_DecRef(i8*) local_unnamed_addr

declare void @numba_gil_release(i32*) local_unnamed_addr

declare i8* @PyEval_SaveThread() local_unnamed_addr

define weak_odr void @"__gufunc__._ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE"(i8** %args, i64* %dims, i64* %steps, i8* %data) {
entry:
  %loopcount = load i64, i64* %dims, align 8
  %.10 = getelementptr i64, i64* %dims, i64 3
  %.11 = load i64, i64* %.10, align 8
  %0 = bitcast i8** %args to i64*
  %data.11 = load i64, i64* %0, align 8
  %.12 = load i64, i64* %steps, align 8
  %data.ptr.1 = getelementptr i8*, i8** %args, i64 1
  %1 = bitcast i8** %data.ptr.1 to i64*
  %data.22 = load i64, i64* %1, align 8
  %core.step.ptr.1 = getelementptr i64, i64* %steps, i64 1
  %.14 = load i64, i64* %core.step.ptr.1, align 8
  %data.ptr.2 = getelementptr i8*, i8** %args, i64 2
  %2 = bitcast i8** %data.ptr.2 to i64*
  %data.33 = load i64, i64* %2, align 8
  %core.step.ptr.2 = getelementptr i64, i64* %steps, i64 2
  %.17 = load i64, i64* %core.step.ptr.2, align 8
  %.204 = icmp sgt i64 %loopcount, 0
  br i1 %.204, label %for.body.preheader, label %.return

for.body.preheader:                               ; preds = %entry
  br label %for.body

.return:                                          ; preds = %.continue, %entry
  ret void

for.body:                                         ; preds = %.continue, %for.body.preheader
  %loop.index5 = phi i64 [ %.165, %.continue ], [ 0, %for.body.preheader ]
  %.25 = mul i64 %loop.index5, %.12
  %.27 = add i64 %.25, %data.11
  %.33 = inttoptr i64 %.27 to i64*
  %.54 = mul i64 %loop.index5, %.14
  %.56 = add i64 %.54, %data.22
  %.87 = mul i64 %loop.index5, %.17
  %.89 = add i64 %.87, %data.33
  %.95 = inttoptr i64 %.89 to double*
  %.99.i = load double, double* %.95, align 8, !alias.scope !1, !noalias !4
  %.147.i = load i64, i64* %.33, align 8, !alias.scope !8, !noalias !9
  %.185.i = getelementptr i64, i64* %.33, i64 2
  %.186.i = load i64, i64* %.185.i, align 8, !alias.scope !8, !noalias !9
  %.216.i = sub i64 1, %.147.i
  %.272.i = add i64 %.216.i, %.186.i
  %.273.inv.i = icmp sgt i64 %.272.i, 0
  br i1 %.273.inv.i, label %B40.lr.ph.i, label %.continue

B40.lr.ph.i:                                      ; preds = %for.body
  %sunkaddr = inttoptr i64 %data.11 to i64*
  %3 = bitcast i64* %sunkaddr to i8*
  %sunkaddr3 = getelementptr i8, i8* %3, i64 %.25
  %sunkaddr6 = getelementptr i8, i8* %sunkaddr3, i64 8
  %4 = bitcast i8* %sunkaddr6 to i64*
  %.409.i = load i64, i64* %4, align 8, !alias.scope !8, !noalias !9
  %sunkaddr7 = inttoptr i64 %data.11 to i64*
  %5 = bitcast i64* %sunkaddr7 to i8*
  %sunkaddr8 = getelementptr i8, i8* %5, i64 %.25
  %sunkaddr9 = getelementptr i8, i8* %sunkaddr8, i64 24
  %6 = bitcast i8* %sunkaddr9 to i64*
  %.448.i = load i64, i64* %6, align 8, !alias.scope !8, !noalias !9
  %.478.i = sub i64 1, %.409.i
  %.534.i = add i64 %.478.i, %.448.i
  %.535.inv.i = icmp sgt i64 %.534.i, 0
  br i1 %.535.inv.i, label %B40.us.preheader.i, label %.continue

B40.us.preheader.i:                               ; preds = %B40.lr.ph.i
  %7 = inttoptr i64 %.56 to double*
  %8 = add nuw i64 %.534.i, 1
  %9 = mul i64 %.147.i, %.11
  %10 = add i64 %.409.i, %9
  %scevgep.i = getelementptr double, double* %7, i64 %10
  br label %B40.us.i

B40.us.i:                                         ; preds = %B70.B38.loopexit_crit_edge.us.i, %B40.us.preheader.i
  %lsr.iv27.i = phi double* [ %scevgep.i, %B40.us.preheader.i ], [ %scevgep291.i, %B70.B38.loopexit_crit_edge.us.i ]
  %val_673.2.023.us.i = phi double [ %.99.i, %B40.us.preheader.i ], [ %.721.us.i, %B70.B38.loopexit_crit_edge.us.i ]
  %.262.022.us.i = phi i64 [ %.272.i, %B40.us.preheader.i ], [ %.328.us.i, %B70.B38.loopexit_crit_edge.us.i ]
  br label %B72.us.i

B72.us.i:                                         ; preds = %B72.us.i, %B40.us.i
  %lsr.iv30.i = phi double* [ %lsr.iv27.i, %B40.us.i ], [ %scevgep31.i, %B72.us.i ]
  %lsr.iv.i = phi i64 [ %8, %B40.us.i ], [ %lsr.iv.next.i, %B72.us.i ]
  %val_673.3.119.us.i = phi double [ %val_673.2.023.us.i, %B40.us.i ], [ %.721.us.i, %B72.us.i ]
  %.682.us.i = load double, double* %lsr.iv30.i, align 8, !alias.scope !10, !noalias !11
  %.707.le.us.i = fmul double %.682.us.i, %.682.us.i
  %.721.us.i = fadd double %val_673.3.119.us.i, %.707.le.us.i
  %lsr.iv.next.i = add i64 %lsr.iv.i, -1
  %scevgep31.i = getelementptr double, double* %lsr.iv30.i, i64 1
  %.579.us.i = icmp sgt i64 %lsr.iv.next.i, 1
  br i1 %.579.us.i, label %B72.us.i, label %B70.B38.loopexit_crit_edge.us.i

B70.B38.loopexit_crit_edge.us.i:                  ; preds = %B72.us.i
  %.328.us.i = add nsw i64 %.262.022.us.i, -1
  %scevgep291.i = getelementptr double, double* %lsr.iv27.i, i64 %.11
  %.319.us.i = icmp sgt i64 %.262.022.us.i, 1
  br i1 %.319.us.i, label %B40.us.i, label %.continue

.continue:                                        ; preds = %B70.B38.loopexit_crit_edge.us.i, %B40.lr.ph.i, %for.body
  %val_673.2.0.lcssa.i = phi double [ %.99.i, %for.body ], [ %.99.i, %B40.lr.ph.i ], [ %.721.us.i, %B70.B38.loopexit_crit_edge.us.i ]
  %11 = inttoptr i64 %data.33 to i8*
  %sunkaddr12 = getelementptr i8, i8* %11, i64 %.87
  %12 = bitcast i8* %sunkaddr12 to double*
  store double %val_673.2.0.lcssa.i, double* %12, align 8, !alias.scope !1, !noalias !4
  %.165 = add nuw nsw i64 %loop.index5, 1
  %exitcond = icmp eq i64 %.165, %loopcount
  br i1 %exitcond, label %.return, label %for.body
}

declare void @numba_parallel_for(i8*, i8*, i8*, i8*, i8*, i64, i64, i64) local_unnamed_addr

declare void @PyEval_RestoreThread(i8*) local_unnamed_addr

; Function Attrs: noinline
define linkonce_odr void @NRT_decref(i8* %.1) local_unnamed_addr #1 {
.3:
  %.4 = icmp eq i8* %.1, null
  br i1 %.4, label %.3.if, label %.3.endif, !prof !0

.3.if:                                            ; preds = %.3.endif, %.3
  ret void

.3.endif:                                         ; preds = %.3
  fence release
  %.8 = bitcast i8* %.1 to i64*
  %.4.i = atomicrmw sub i64* %.8, i64 1 monotonic
  %.10 = icmp eq i64 %.4.i, 1
  br i1 %.10, label %.3.endif.if, label %.3.if, !prof !0

.3.endif.if:                                      ; preds = %.3.endif
  fence acquire
  tail call void @NRT_MemInfo_call_dtor(i8* nonnull %.1)
  ret void
}

declare void @NRT_MemInfo_call_dtor(i8*) local_unnamed_addr

; Function Attrs: nofree noinline norecurse nounwind
define linkonce_odr void @NRT_incref(i8* %.1) local_unnamed_addr #2 {
.3:
  %.4 = icmp eq i8* %.1, null
  br i1 %.4, label %.3.if, label %.3.endif, !prof !0

.3.if:                                            ; preds = %.3
  ret void

.3.endif:                                         ; preds = %.3
  %.7 = bitcast i8* %.1 to i64*
  %.4.i = atomicrmw add i64* %.7, i64 1 monotonic
  ret void
}

; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #3

; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #3

; Function Attrs: argmemonly nounwind willreturn
declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #3

; Function Attrs: nounwind
declare void @llvm.stackprotector(i8*, i8**) #4

attributes #0 = { nofree nounwind }
attributes #1 = { noinline }
attributes #2 = { nofree noinline norecurse nounwind }
attributes #3 = { argmemonly nounwind willreturn }
attributes #4 = { nounwind }

!0 = !{!"branch_weights", i32 1, i32 99}
!1 = !{!2}
!2 = distinct !{!2, !3, !"_ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE: %arg.val_673__arr.4"}
!3 = distinct !{!3, !"_ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE"}
!4 = !{!5, !6, !7}
!5 = distinct !{!5, !3, !"_ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE: %retptr"}
!6 = distinct !{!6, !3, !"_ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE: %arg.sched.4"}
!7 = distinct !{!7, !3, !"_ZN13$3cdynamic$3e40__numba_parfor_gufunc_0x21372b6f670$2426E5ArrayIyLi1E1C7mutable7alignedE5ArrayIdLi2E1C7mutable7alignedE5ArrayIdLi1E1C7mutable7alignedE: %arg.a.4"}
!8 = !{!6}
!9 = !{!5, !7, !2}
!10 = !{!7}
!11 = !{!5, !6, !2}