|
CodeInfo( |
|
1 ─── %1 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2 = (%1)($(QuoteNode(Ptr{Nothing} @0x0000000004db7658)), CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared}, Tuple{})::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared} |
|
│ %3 = %new(CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, (5, 5), %2)::CuDeviceArray{Float32,2,CUDAnative.AS.Shared} |
|
│ %4 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %5 = (%4)($(QuoteNode(Ptr{Nothing} @0x0000000004d93bf8)), CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared}, Tuple{})::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared} |
|
│ %6 = %new(CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, (5, 5, 5), %5)::CuDeviceArray{Float32,3,CUDAnative.AS.Shared} |
|
│ %7 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %8 = (%7)($(QuoteNode(Ptr{Nothing} @0x0000000005051468)), CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared}, Tuple{})::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared} |
|
│ %9 = %new(CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, (5, 5, 5), %8)::CuDeviceArray{Float32,3,CUDAnative.AS.Shared} |
|
│ %10 = %new(MArray{Tuple{5},Float32,1,5})::MArray{Tuple{5},Float32,1,5} |
|
│ %11 = %new(MArray{Tuple{5},Float32,1,5})::MArray{Tuple{5},Float32,1,5} |
|
│ %12 = %new(MArray{Tuple{5},Float32,1,5})::MArray{Tuple{5},Float32,1,5} |
|
│ %13 = %new(MArray{Tuple{5},Float32,1,5})::MArray{Tuple{5},Float32,1,5} |
|
│ %14 = %new(MArray{Tuple{5},Float32,1,5})::MArray{Tuple{5},Float32,1,5} |
|
│ %15 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %16 = (%15)($(QuoteNode(Ptr{Nothing} @0x0000000005acfeb8)), UInt32, Tuple{})::UInt32 |
|
│ %17 = Core.zext_int(Core.Int64, %16)::Int64 |
|
│ %18 = Base.add_int(%17, 1)::Int64 |
|
│ %19 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%19)($(QuoteNode(Ptr{Nothing} @0x0000000002c50d08)), UInt32, Tuple{})::UInt32 |
|
│ %21 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%21)($(QuoteNode(Ptr{Nothing} @0x0000000005497708)), UInt32, Tuple{})::UInt32 |
|
│ %23 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%23)($(QuoteNode(Ptr{Nothing} @0x0000000005baae48)), UInt32, Tuple{})::UInt32 |
|
│ %25 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %26 = (%25)($(QuoteNode(Ptr{Nothing} @0x0000000004ecb628)), UInt32, Tuple{})::UInt32 |
|
│ %27 = Core.zext_int(Core.Int64, %26)::Int64 |
|
│ %28 = Base.add_int(%27, 1)::Int64 |
|
│ %29 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%29)($(QuoteNode(Ptr{Nothing} @0x0000000004923418)), UInt32, Tuple{})::UInt32 |
|
│ %31 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %32 = (%31)($(QuoteNode(Ptr{Nothing} @0x0000000005baae48)), UInt32, Tuple{})::UInt32 |
|
│ %33 = Core.zext_int(Core.Int64, %32)::Int64 |
|
│ %34 = Base.add_int(%33, 1)::Int64 |
|
│ %35 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%35)($(QuoteNode(Ptr{Nothing} @0x0000000004ecb628)), UInt32, Tuple{})::UInt32 |
|
│ %37 = Base.llvmcall::Core.IntrinsicFunction |
|
│ (%37)($(QuoteNode(Ptr{Nothing} @0x0000000004923418)), UInt32, Tuple{})::UInt32 |
|
└──── goto #6 if not true |
|
2 ─── %40 = Core.tuple(%34, %28)::Tuple{Int64,Int64} |
|
│ %41 = Base.getfield(D, :shape)::Tuple{Int64,Int64} |
|
│ %42 = Base.getfield(%41, 1, true)::Int64 |
|
│ %43 = Base.slt_int(%42, 0)::Bool |
|
│ %44 = Base.ifelse(%43, 0, %42)::Int64 |
|
│ %45 = Base.getfield(%41, 2, true)::Int64 |
|
│ %46 = Base.slt_int(%45, 0)::Bool |
|
│ %47 = Base.ifelse(%46, 0, %45)::Int64 |
|
│ %48 = Base.sle_int(1, %34)::Bool |
|
│ %49 = Base.sle_int(%34, %44)::Bool |
|
│ %50 = Base.and_int(%48, %49)::Bool |
|
│ %51 = Base.sle_int(1, %28)::Bool |
|
│ %52 = Base.sle_int(%28, %47)::Bool |
|
│ %53 = Base.and_int(%51, %52)::Bool |
|
│ %54 = Base.and_int(%53, true)::Bool |
|
│ %55 = Base.and_int(%50, %54)::Bool |
|
└──── goto #4 if not %55 |
|
3 ─── goto #5 |
|
4 ─── invoke Base.throw_boundserror(_7::CuDeviceArray{Float32,2,CUDAnative.AS.Global}, %40::Tuple{Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
5 ┄── nothing::Nothing |
|
6 ┄── %61 = Base.getfield(D, :shape)::Tuple{Int64,Int64} |
|
│ %62 = Base.getfield(%61, 1, true)::Int64 |
|
│ %63 = Base.slt_int(%62, 0)::Bool |
|
│ %64 = Base.ifelse(%63, 0, %62)::Int64 |
|
│ %65 = Base.sub_int(%64, 0)::Int64 |
|
│ %66 = Base.mul_int(1, %65)::Int64 |
|
│ %67 = Base.sub_int(%34, 1)::Int64 |
|
│ %68 = Base.mul_int(%67, 1)::Int64 |
|
│ %69 = Base.add_int(1, %68)::Int64 |
|
│ %70 = Base.sub_int(%28, 1)::Int64 |
|
│ %71 = Base.mul_int(%70, %66)::Int64 |
|
│ %72 = Base.add_int(%69, %71)::Int64 |
|
└──── goto #11 if not false |
|
7 ─── %74 = Core.tuple(%72)::Tuple{Int64} |
|
│ %75 = Base.getfield(D, :shape)::Tuple{Int64,Int64} |
|
│ %76 = (getfield)(%75, 1)::Int64 |
|
│ %77 = (getfield)(%75, 2)::Int64 |
|
│ %78 = Base.mul_int(%76, %77)::Int64 |
|
│ %79 = Base.slt_int(%78, 0)::Bool |
|
│ %80 = Base.ifelse(%79, 0, %78)::Int64 |
|
│ %81 = Base.sle_int(1, %72)::Bool |
|
│ %82 = Base.sle_int(%72, %80)::Bool |
|
│ %83 = Base.and_int(%81, %82)::Bool |
|
└──── goto #9 if not %83 |
|
8 ─── goto #10 |
|
9 ─── invoke Base.throw_boundserror(_7::CuDeviceArray{Float32,2,CUDAnative.AS.Global}, %74::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
10 ┄─ nothing::Nothing |
|
11 ┄─ %89 = Base.getfield(D, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %90 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %91 = Base.sub_int(%72, 1)::Int64 |
|
│ %92 = (%90)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %89, %91)::Float32 |
|
└──── goto #12 |
|
12 ── goto #13 |
|
13 ── goto #14 |
|
14 ── goto #19 if not true |
|
15 ── %97 = Core.tuple(%34, %28)::Tuple{Int64,Int64} |
|
│ %98 = Base.slt_int(5, 0)::Bool |
|
│ %99 = Base.ifelse(%98, 0, 5)::Int64 |
|
│ %100 = Base.slt_int(5, 0)::Bool |
|
│ %101 = Base.ifelse(%100, 0, 5)::Int64 |
|
│ %102 = Base.sle_int(1, %34)::Bool |
|
│ %103 = Base.sle_int(%34, %99)::Bool |
|
│ %104 = Base.and_int(%102, %103)::Bool |
|
│ %105 = Base.sle_int(1, %28)::Bool |
|
│ %106 = Base.sle_int(%28, %101)::Bool |
|
│ %107 = Base.and_int(%105, %106)::Bool |
|
│ %108 = Base.and_int(%107, true)::Bool |
|
│ %109 = Base.and_int(%104, %108)::Bool |
|
└──── goto #17 if not %109 |
|
16 ── goto #18 |
|
17 ── invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %97::Tuple{Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
18 ┄─ nothing::Nothing |
|
19 ┄─ %115 = Base.slt_int(5, 0)::Bool |
|
│ %116 = Base.ifelse(%115, 0, 5)::Int64 |
|
│ %117 = Base.sub_int(%116, 0)::Int64 |
|
│ %118 = Base.mul_int(1, %117)::Int64 |
|
│ %119 = Base.sub_int(%34, 1)::Int64 |
|
│ %120 = Base.mul_int(%119, 1)::Int64 |
|
│ %121 = Base.add_int(1, %120)::Int64 |
|
│ %122 = Base.sub_int(%28, 1)::Int64 |
|
│ %123 = Base.mul_int(%122, %118)::Int64 |
|
│ %124 = Base.add_int(%121, %123)::Int64 |
|
└──── goto #24 if not false |
|
20 ── %126 = Core.tuple(%124)::Tuple{Int64} |
|
│ %127 = Base.mul_int(5, 5)::Int64 |
|
│ %128 = Base.slt_int(%127, 0)::Bool |
|
│ %129 = Base.ifelse(%128, 0, %127)::Int64 |
|
│ %130 = Base.sle_int(1, %124)::Bool |
|
│ %131 = Base.sle_int(%124, %129)::Bool |
|
│ %132 = Base.and_int(%130, %131)::Bool |
|
└──── goto #22 if not %132 |
|
21 ── goto #23 |
|
22 ── invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %126::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
23 ┄─ nothing::Nothing |
|
24 ┄─ %138 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %139 = Base.sub_int(%124, 1)::Int64 |
|
│ (%138)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %2, %92, %139)::Nothing |
|
└──── goto #25 |
|
25 ── goto #26 |
|
26 ── goto #27 |
|
27 ── goto #63 if not true |
|
28 ┄─ %145 = φ (#27 => 1, #62 => %233)::Int64 |
|
│ %146 = φ (#27 => 1, #62 => %234)::Int64 |
|
└──── goto #33 if not false |
|
29 ── %148 = Core.tuple(%145)::Tuple{Int64} |
|
│ %149 = Base.sle_int(1, %145)::Bool |
|
│ %150 = Base.sle_int(%145, 5)::Bool |
|
│ %151 = Base.and_int(%149, %150)::Bool |
|
└──── goto #31 if not %151 |
|
30 ── goto #32 |
|
31 ── invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %148::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
32 ┄─ nothing::Nothing |
|
33 ┄─ %157 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %158 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %159 = Base.bitcast(Ptr{Float32}, %158)::Ptr{Float32} |
|
│ Base.pointerset(%159, 0.0f0, %145, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%157))) |
|
└──── goto #34 |
|
34 ── goto #39 if not false |
|
35 ── %164 = Core.tuple(%145)::Tuple{Int64} |
|
│ %165 = Base.sle_int(1, %145)::Bool |
|
│ %166 = Base.sle_int(%145, 5)::Bool |
|
│ %167 = Base.and_int(%165, %166)::Bool |
|
└──── goto #37 if not %167 |
|
36 ── goto #38 |
|
37 ── invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %164::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
38 ┄─ nothing::Nothing |
|
39 ┄─ %173 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %174 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %175 = Base.bitcast(Ptr{Float32}, %174)::Ptr{Float32} |
|
│ Base.pointerset(%175, 0.0f0, %145, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%173))) |
|
└──── goto #40 |
|
40 ── goto #45 if not false |
|
41 ── %180 = Core.tuple(%145)::Tuple{Int64} |
|
│ %181 = Base.sle_int(1, %145)::Bool |
|
│ %182 = Base.sle_int(%145, 5)::Bool |
|
│ %183 = Base.and_int(%181, %182)::Bool |
|
└──── goto #43 if not %183 |
|
42 ── goto #44 |
|
43 ── invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %180::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
44 ┄─ nothing::Nothing |
|
45 ┄─ %189 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %190 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %191 = Base.bitcast(Ptr{Float32}, %190)::Ptr{Float32} |
|
│ Base.pointerset(%191, 0.0f0, %145, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%189))) |
|
└──── goto #46 |
|
46 ── goto #51 if not false |
|
47 ── %196 = Core.tuple(%145)::Tuple{Int64} |
|
│ %197 = Base.sle_int(1, %145)::Bool |
|
│ %198 = Base.sle_int(%145, 5)::Bool |
|
│ %199 = Base.and_int(%197, %198)::Bool |
|
└──── goto #49 if not %199 |
|
48 ── goto #50 |
|
49 ── invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %196::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
50 ┄─ nothing::Nothing |
|
51 ┄─ %205 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %206 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %207 = Base.bitcast(Ptr{Float32}, %206)::Ptr{Float32} |
|
│ Base.pointerset(%207, 0.0f0, %145, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%205))) |
|
└──── goto #52 |
|
52 ── goto #57 if not false |
|
53 ── %212 = Core.tuple(%145)::Tuple{Int64} |
|
│ %213 = Base.sle_int(1, %145)::Bool |
|
│ %214 = Base.sle_int(%145, 5)::Bool |
|
│ %215 = Base.and_int(%213, %214)::Bool |
|
└──── goto #55 if not %215 |
|
54 ── goto #56 |
|
55 ── invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %212::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
56 ┄─ nothing::Nothing |
|
57 ┄─ %221 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %222 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %223 = Base.bitcast(Ptr{Float32}, %222)::Ptr{Float32} |
|
│ Base.pointerset(%223, 0.0f0, %145, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%221))) |
|
└──── goto #58 |
|
58 ── $(Expr(:loopinfo, (Symbol("llvm.loop.unroll.full"), 1)))::Any |
|
│ %228 = (%146 === 5)::Bool |
|
└──── goto #60 if not %228 |
|
59 ── goto #61 |
|
60 ── %231 = Base.add_int(%146, 1)::Int64 |
|
└──── goto #61 |
|
61 ┄─ %233 = φ (#60 => %231)::Int64 |
|
│ %234 = φ (#60 => %231)::Int64 |
|
│ %235 = φ (#59 => true, #60 => false)::Bool |
|
│ %236 = Base.not_int(%235)::Bool |
|
└──── goto #63 if not %236 |
|
62 ── goto #28 |
|
63 ┄─ goto #780 if not true |
|
64 ┄─ %240 = φ (#63 => 1, #779 => %3988)::Int64 |
|
│ %241 = φ (#63 => 1, #779 => %3989)::Int64 |
|
│ $(Expr(:foreigncall, "llvm.nvvm.barrier0", Nothing, svec(), :(:llvmcall), 0))::Nothing |
|
└──── goto #69 if not false |
|
65 ── %244 = Core.tuple(%34, %28, %240, 10, %18)::NTuple{5,Int64} |
|
│ %245 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %246 = Base.getfield(%245, 1, true)::Int64 |
|
│ %247 = Base.slt_int(%246, 0)::Bool |
|
│ %248 = Base.ifelse(%247, 0, %246)::Int64 |
|
│ %249 = (getfield)(%245, 2)::Int64 |
|
│ %250 = (getfield)(%245, 3)::Int64 |
|
│ %251 = (getfield)(%245, 4)::Int64 |
|
│ %252 = (getfield)(%245, 5)::Int64 |
|
│ %253 = Base.slt_int(%249, 0)::Bool |
|
│ %254 = Base.ifelse(%253, 0, %249)::Int64 |
|
│ %255 = Base.slt_int(%250, 0)::Bool |
|
│ %256 = Base.ifelse(%255, 0, %250)::Int64 |
|
│ %257 = Base.slt_int(%251, 0)::Bool |
|
│ %258 = Base.ifelse(%257, 0, %251)::Int64 |
|
│ %259 = Base.slt_int(%252, 0)::Bool |
|
│ %260 = Base.ifelse(%259, 0, %252)::Int64 |
|
│ %261 = Base.sle_int(1, %34)::Bool |
|
│ %262 = Base.sle_int(%34, %248)::Bool |
|
│ %263 = Base.and_int(%261, %262)::Bool |
|
│ %264 = Base.sle_int(1, %28)::Bool |
|
│ %265 = Base.sle_int(%28, %254)::Bool |
|
│ %266 = Base.and_int(%264, %265)::Bool |
|
│ %267 = Base.sle_int(1, %240)::Bool |
|
│ %268 = Base.sle_int(%240, %256)::Bool |
|
│ %269 = Base.and_int(%267, %268)::Bool |
|
│ %270 = Base.sle_int(1, 10)::Bool |
|
│ %271 = Base.sle_int(10, %258)::Bool |
|
│ %272 = Base.and_int(%270, %271)::Bool |
|
│ %273 = Base.sle_int(1, %18)::Bool |
|
│ %274 = Base.sle_int(%18, %260)::Bool |
|
│ %275 = Base.and_int(%273, %274)::Bool |
|
│ %276 = Base.and_int(%275, true)::Bool |
|
│ %277 = Base.and_int(%272, %276)::Bool |
|
│ %278 = Base.and_int(%269, %277)::Bool |
|
│ %279 = Base.and_int(%266, %278)::Bool |
|
│ %280 = Base.and_int(%263, %279)::Bool |
|
└──── goto #67 if not %280 |
|
66 ── goto #68 |
|
67 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %244::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
68 ┄─ nothing::Nothing |
|
69 ┄─ %286 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %287 = Base.getfield(%286, 1, true)::Int64 |
|
│ %288 = Base.slt_int(%287, 0)::Bool |
|
│ %289 = Base.ifelse(%288, 0, %287)::Int64 |
|
│ %290 = (getfield)(%286, 2)::Int64 |
|
│ %291 = (getfield)(%286, 3)::Int64 |
|
│ %292 = (getfield)(%286, 4)::Int64 |
|
│ %293 = Base.slt_int(%290, 0)::Bool |
|
│ %294 = Base.ifelse(%293, 0, %290)::Int64 |
|
│ %295 = Base.slt_int(%291, 0)::Bool |
|
│ %296 = Base.ifelse(%295, 0, %291)::Int64 |
|
│ %297 = Base.slt_int(%292, 0)::Bool |
|
│ %298 = Base.ifelse(%297, 0, %292)::Int64 |
|
│ %299 = Base.sub_int(%289, 0)::Int64 |
|
│ %300 = Base.mul_int(1, %299)::Int64 |
|
│ %301 = Base.sub_int(%34, 1)::Int64 |
|
│ %302 = Base.mul_int(%301, 1)::Int64 |
|
│ %303 = Base.add_int(1, %302)::Int64 |
|
│ %304 = Base.sub_int(%294, 0)::Int64 |
|
│ %305 = Base.mul_int(%300, %304)::Int64 |
|
│ %306 = Base.sub_int(%28, 1)::Int64 |
|
│ %307 = Base.mul_int(%306, %300)::Int64 |
|
│ %308 = Base.add_int(%303, %307)::Int64 |
|
│ %309 = Base.sub_int(%296, 0)::Int64 |
|
│ %310 = Base.mul_int(%305, %309)::Int64 |
|
│ %311 = Base.sub_int(%240, 1)::Int64 |
|
│ %312 = Base.mul_int(%311, %305)::Int64 |
|
│ %313 = Base.add_int(%308, %312)::Int64 |
|
│ %314 = Base.sub_int(%298, 0)::Int64 |
|
│ %315 = Base.mul_int(%310, %314)::Int64 |
|
│ %316 = Base.sub_int(10, 1)::Int64 |
|
│ %317 = Base.mul_int(%316, %310)::Int64 |
|
│ %318 = Base.add_int(%313, %317)::Int64 |
|
│ %319 = Base.sub_int(%18, 1)::Int64 |
|
│ %320 = Base.mul_int(%319, %315)::Int64 |
|
│ %321 = Base.add_int(%318, %320)::Int64 |
|
└──── goto #74 if not false |
|
70 ── %323 = Core.tuple(%321)::Tuple{Int64} |
|
│ %324 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %325 = (getfield)(%324, 1)::Int64 |
|
│ %326 = (getfield)(%324, 2)::Int64 |
|
│ %327 = (getfield)(%324, 3)::Int64 |
|
│ %328 = (getfield)(%324, 4)::Int64 |
|
│ %329 = (getfield)(%324, 5)::Int64 |
|
│ %330 = Base.mul_int(%325, %326)::Int64 |
|
│ %331 = Base.mul_int(%330, %327)::Int64 |
|
│ %332 = Base.mul_int(%331, %328)::Int64 |
|
│ %333 = Base.mul_int(%332, %329)::Int64 |
|
│ %334 = Base.slt_int(%333, 0)::Bool |
|
│ %335 = Base.ifelse(%334, 0, %333)::Int64 |
|
│ %336 = Base.sle_int(1, %321)::Bool |
|
│ %337 = Base.sle_int(%321, %335)::Bool |
|
│ %338 = Base.and_int(%336, %337)::Bool |
|
└──── goto #72 if not %338 |
|
71 ── goto #73 |
|
72 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %323::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
73 ┄─ nothing::Nothing |
|
74 ┄─ %344 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %345 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %346 = Base.sub_int(%321, 1)::Int64 |
|
│ %347 = (%345)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %344, %346)::Float32 |
|
└──── goto #75 |
|
75 ── goto #76 |
|
76 ── goto #77 |
|
77 ── goto #82 if not false |
|
78 ── %352 = Core.tuple(%34, %28, %240, 1, %18)::NTuple{5,Int64} |
|
│ %353 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %354 = Base.getfield(%353, 1, true)::Int64 |
|
│ %355 = Base.slt_int(%354, 0)::Bool |
|
│ %356 = Base.ifelse(%355, 0, %354)::Int64 |
|
│ %357 = (getfield)(%353, 2)::Int64 |
|
│ %358 = (getfield)(%353, 3)::Int64 |
|
│ %359 = (getfield)(%353, 4)::Int64 |
|
│ %360 = (getfield)(%353, 5)::Int64 |
|
│ %361 = Base.slt_int(%357, 0)::Bool |
|
│ %362 = Base.ifelse(%361, 0, %357)::Int64 |
|
│ %363 = Base.slt_int(%358, 0)::Bool |
|
│ %364 = Base.ifelse(%363, 0, %358)::Int64 |
|
│ %365 = Base.slt_int(%359, 0)::Bool |
|
│ %366 = Base.ifelse(%365, 0, %359)::Int64 |
|
│ %367 = Base.slt_int(%360, 0)::Bool |
|
│ %368 = Base.ifelse(%367, 0, %360)::Int64 |
|
│ %369 = Base.sle_int(1, %34)::Bool |
|
│ %370 = Base.sle_int(%34, %356)::Bool |
|
│ %371 = Base.and_int(%369, %370)::Bool |
|
│ %372 = Base.sle_int(1, %28)::Bool |
|
│ %373 = Base.sle_int(%28, %362)::Bool |
|
│ %374 = Base.and_int(%372, %373)::Bool |
|
│ %375 = Base.sle_int(1, %240)::Bool |
|
│ %376 = Base.sle_int(%240, %364)::Bool |
|
│ %377 = Base.and_int(%375, %376)::Bool |
|
│ %378 = Base.sle_int(1, 1)::Bool |
|
│ %379 = Base.sle_int(1, %366)::Bool |
|
│ %380 = Base.and_int(%378, %379)::Bool |
|
│ %381 = Base.sle_int(1, %18)::Bool |
|
│ %382 = Base.sle_int(%18, %368)::Bool |
|
│ %383 = Base.and_int(%381, %382)::Bool |
|
│ %384 = Base.and_int(%383, true)::Bool |
|
│ %385 = Base.and_int(%380, %384)::Bool |
|
│ %386 = Base.and_int(%377, %385)::Bool |
|
│ %387 = Base.and_int(%374, %386)::Bool |
|
│ %388 = Base.and_int(%371, %387)::Bool |
|
└──── goto #80 if not %388 |
|
79 ── goto #81 |
|
80 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %352::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
81 ┄─ nothing::Nothing |
|
82 ┄─ %394 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %395 = Base.getfield(%394, 1, true)::Int64 |
|
│ %396 = Base.slt_int(%395, 0)::Bool |
|
│ %397 = Base.ifelse(%396, 0, %395)::Int64 |
|
│ %398 = (getfield)(%394, 2)::Int64 |
|
│ %399 = (getfield)(%394, 3)::Int64 |
|
│ %400 = (getfield)(%394, 4)::Int64 |
|
│ %401 = Base.slt_int(%398, 0)::Bool |
|
│ %402 = Base.ifelse(%401, 0, %398)::Int64 |
|
│ %403 = Base.slt_int(%399, 0)::Bool |
|
│ %404 = Base.ifelse(%403, 0, %399)::Int64 |
|
│ %405 = Base.slt_int(%400, 0)::Bool |
|
│ %406 = Base.ifelse(%405, 0, %400)::Int64 |
|
│ %407 = Base.sub_int(%397, 0)::Int64 |
|
│ %408 = Base.mul_int(1, %407)::Int64 |
|
│ %409 = Base.sub_int(%34, 1)::Int64 |
|
│ %410 = Base.mul_int(%409, 1)::Int64 |
|
│ %411 = Base.add_int(1, %410)::Int64 |
|
│ %412 = Base.sub_int(%402, 0)::Int64 |
|
│ %413 = Base.mul_int(%408, %412)::Int64 |
|
│ %414 = Base.sub_int(%28, 1)::Int64 |
|
│ %415 = Base.mul_int(%414, %408)::Int64 |
|
│ %416 = Base.add_int(%411, %415)::Int64 |
|
│ %417 = Base.sub_int(%404, 0)::Int64 |
|
│ %418 = Base.mul_int(%413, %417)::Int64 |
|
│ %419 = Base.sub_int(%240, 1)::Int64 |
|
│ %420 = Base.mul_int(%419, %413)::Int64 |
|
│ %421 = Base.add_int(%416, %420)::Int64 |
|
│ %422 = Base.sub_int(%406, 0)::Int64 |
|
│ %423 = Base.mul_int(%418, %422)::Int64 |
|
│ %424 = Base.sub_int(1, 1)::Int64 |
|
│ %425 = Base.mul_int(%424, %418)::Int64 |
|
│ %426 = Base.add_int(%421, %425)::Int64 |
|
│ %427 = Base.sub_int(%18, 1)::Int64 |
|
│ %428 = Base.mul_int(%427, %423)::Int64 |
|
│ %429 = Base.add_int(%426, %428)::Int64 |
|
└──── goto #87 if not false |
|
83 ── %431 = Core.tuple(%429)::Tuple{Int64} |
|
│ %432 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %433 = (getfield)(%432, 1)::Int64 |
|
│ %434 = (getfield)(%432, 2)::Int64 |
|
│ %435 = (getfield)(%432, 3)::Int64 |
|
│ %436 = (getfield)(%432, 4)::Int64 |
|
│ %437 = (getfield)(%432, 5)::Int64 |
|
│ %438 = Base.mul_int(%433, %434)::Int64 |
|
│ %439 = Base.mul_int(%438, %435)::Int64 |
|
│ %440 = Base.mul_int(%439, %436)::Int64 |
|
│ %441 = Base.mul_int(%440, %437)::Int64 |
|
│ %442 = Base.slt_int(%441, 0)::Bool |
|
│ %443 = Base.ifelse(%442, 0, %441)::Int64 |
|
│ %444 = Base.sle_int(1, %429)::Bool |
|
│ %445 = Base.sle_int(%429, %443)::Bool |
|
│ %446 = Base.and_int(%444, %445)::Bool |
|
└──── goto #85 if not %446 |
|
84 ── goto #86 |
|
85 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %431::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
86 ┄─ nothing::Nothing |
|
87 ┄─ %452 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %453 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %454 = Base.sub_int(%429, 1)::Int64 |
|
│ %455 = (%453)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %452, %454)::Float32 |
|
└──── goto #88 |
|
88 ── goto #89 |
|
89 ── goto #90 |
|
90 ── goto #95 if not false |
|
91 ── %460 = Core.tuple(%34, %28, %240, 4, %18)::NTuple{5,Int64} |
|
│ %461 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %462 = Base.getfield(%461, 1, true)::Int64 |
|
│ %463 = Base.slt_int(%462, 0)::Bool |
|
│ %464 = Base.ifelse(%463, 0, %462)::Int64 |
|
│ %465 = (getfield)(%461, 2)::Int64 |
|
│ %466 = (getfield)(%461, 3)::Int64 |
|
│ %467 = (getfield)(%461, 4)::Int64 |
|
│ %468 = (getfield)(%461, 5)::Int64 |
|
│ %469 = Base.slt_int(%465, 0)::Bool |
|
│ %470 = Base.ifelse(%469, 0, %465)::Int64 |
|
│ %471 = Base.slt_int(%466, 0)::Bool |
|
│ %472 = Base.ifelse(%471, 0, %466)::Int64 |
|
│ %473 = Base.slt_int(%467, 0)::Bool |
|
│ %474 = Base.ifelse(%473, 0, %467)::Int64 |
|
│ %475 = Base.slt_int(%468, 0)::Bool |
|
│ %476 = Base.ifelse(%475, 0, %468)::Int64 |
|
│ %477 = Base.sle_int(1, %34)::Bool |
|
│ %478 = Base.sle_int(%34, %464)::Bool |
|
│ %479 = Base.and_int(%477, %478)::Bool |
|
│ %480 = Base.sle_int(1, %28)::Bool |
|
│ %481 = Base.sle_int(%28, %470)::Bool |
|
│ %482 = Base.and_int(%480, %481)::Bool |
|
│ %483 = Base.sle_int(1, %240)::Bool |
|
│ %484 = Base.sle_int(%240, %472)::Bool |
|
│ %485 = Base.and_int(%483, %484)::Bool |
|
│ %486 = Base.sle_int(1, 4)::Bool |
|
│ %487 = Base.sle_int(4, %474)::Bool |
|
│ %488 = Base.and_int(%486, %487)::Bool |
|
│ %489 = Base.sle_int(1, %18)::Bool |
|
│ %490 = Base.sle_int(%18, %476)::Bool |
|
│ %491 = Base.and_int(%489, %490)::Bool |
|
│ %492 = Base.and_int(%491, true)::Bool |
|
│ %493 = Base.and_int(%488, %492)::Bool |
|
│ %494 = Base.and_int(%485, %493)::Bool |
|
│ %495 = Base.and_int(%482, %494)::Bool |
|
│ %496 = Base.and_int(%479, %495)::Bool |
|
└──── goto #93 if not %496 |
|
92 ── goto #94 |
|
93 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %460::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
94 ┄─ nothing::Nothing |
|
95 ┄─ %502 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %503 = Base.getfield(%502, 1, true)::Int64 |
|
│ %504 = Base.slt_int(%503, 0)::Bool |
|
│ %505 = Base.ifelse(%504, 0, %503)::Int64 |
|
│ %506 = (getfield)(%502, 2)::Int64 |
|
│ %507 = (getfield)(%502, 3)::Int64 |
|
│ %508 = (getfield)(%502, 4)::Int64 |
|
│ %509 = Base.slt_int(%506, 0)::Bool |
|
│ %510 = Base.ifelse(%509, 0, %506)::Int64 |
|
│ %511 = Base.slt_int(%507, 0)::Bool |
|
│ %512 = Base.ifelse(%511, 0, %507)::Int64 |
|
│ %513 = Base.slt_int(%508, 0)::Bool |
|
│ %514 = Base.ifelse(%513, 0, %508)::Int64 |
|
│ %515 = Base.sub_int(%505, 0)::Int64 |
|
│ %516 = Base.mul_int(1, %515)::Int64 |
|
│ %517 = Base.sub_int(%34, 1)::Int64 |
|
│ %518 = Base.mul_int(%517, 1)::Int64 |
|
│ %519 = Base.add_int(1, %518)::Int64 |
|
│ %520 = Base.sub_int(%510, 0)::Int64 |
|
│ %521 = Base.mul_int(%516, %520)::Int64 |
|
│ %522 = Base.sub_int(%28, 1)::Int64 |
|
│ %523 = Base.mul_int(%522, %516)::Int64 |
|
│ %524 = Base.add_int(%519, %523)::Int64 |
|
│ %525 = Base.sub_int(%512, 0)::Int64 |
|
│ %526 = Base.mul_int(%521, %525)::Int64 |
|
│ %527 = Base.sub_int(%240, 1)::Int64 |
|
│ %528 = Base.mul_int(%527, %521)::Int64 |
|
│ %529 = Base.add_int(%524, %528)::Int64 |
|
│ %530 = Base.sub_int(%514, 0)::Int64 |
|
│ %531 = Base.mul_int(%526, %530)::Int64 |
|
│ %532 = Base.sub_int(4, 1)::Int64 |
|
│ %533 = Base.mul_int(%532, %526)::Int64 |
|
│ %534 = Base.add_int(%529, %533)::Int64 |
|
│ %535 = Base.sub_int(%18, 1)::Int64 |
|
│ %536 = Base.mul_int(%535, %531)::Int64 |
|
│ %537 = Base.add_int(%534, %536)::Int64 |
|
└──── goto #100 if not false |
|
96 ── %539 = Core.tuple(%537)::Tuple{Int64} |
|
│ %540 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %541 = (getfield)(%540, 1)::Int64 |
|
│ %542 = (getfield)(%540, 2)::Int64 |
|
│ %543 = (getfield)(%540, 3)::Int64 |
|
│ %544 = (getfield)(%540, 4)::Int64 |
|
│ %545 = (getfield)(%540, 5)::Int64 |
|
│ %546 = Base.mul_int(%541, %542)::Int64 |
|
│ %547 = Base.mul_int(%546, %543)::Int64 |
|
│ %548 = Base.mul_int(%547, %544)::Int64 |
|
│ %549 = Base.mul_int(%548, %545)::Int64 |
|
│ %550 = Base.slt_int(%549, 0)::Bool |
|
│ %551 = Base.ifelse(%550, 0, %549)::Int64 |
|
│ %552 = Base.sle_int(1, %537)::Bool |
|
│ %553 = Base.sle_int(%537, %551)::Bool |
|
│ %554 = Base.and_int(%552, %553)::Bool |
|
└──── goto #98 if not %554 |
|
97 ── goto #99 |
|
98 ── invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %539::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
99 ┄─ nothing::Nothing |
|
100 ┄ %560 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %561 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %562 = Base.sub_int(%537, 1)::Int64 |
|
│ %563 = (%561)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %560, %562)::Float32 |
|
└──── goto #101 |
|
101 ─ goto #102 |
|
102 ─ goto #103 |
|
103 ─ goto #108 if not false |
|
104 ─ %568 = Core.tuple(%34, %28, %240, 7, %18)::NTuple{5,Int64} |
|
│ %569 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %570 = Base.getfield(%569, 1, true)::Int64 |
|
│ %571 = Base.slt_int(%570, 0)::Bool |
|
│ %572 = Base.ifelse(%571, 0, %570)::Int64 |
|
│ %573 = (getfield)(%569, 2)::Int64 |
|
│ %574 = (getfield)(%569, 3)::Int64 |
|
│ %575 = (getfield)(%569, 4)::Int64 |
|
│ %576 = (getfield)(%569, 5)::Int64 |
|
│ %577 = Base.slt_int(%573, 0)::Bool |
|
│ %578 = Base.ifelse(%577, 0, %573)::Int64 |
|
│ %579 = Base.slt_int(%574, 0)::Bool |
|
│ %580 = Base.ifelse(%579, 0, %574)::Int64 |
|
│ %581 = Base.slt_int(%575, 0)::Bool |
|
│ %582 = Base.ifelse(%581, 0, %575)::Int64 |
|
│ %583 = Base.slt_int(%576, 0)::Bool |
|
│ %584 = Base.ifelse(%583, 0, %576)::Int64 |
|
│ %585 = Base.sle_int(1, %34)::Bool |
|
│ %586 = Base.sle_int(%34, %572)::Bool |
|
│ %587 = Base.and_int(%585, %586)::Bool |
|
│ %588 = Base.sle_int(1, %28)::Bool |
|
│ %589 = Base.sle_int(%28, %578)::Bool |
|
│ %590 = Base.and_int(%588, %589)::Bool |
|
│ %591 = Base.sle_int(1, %240)::Bool |
|
│ %592 = Base.sle_int(%240, %580)::Bool |
|
│ %593 = Base.and_int(%591, %592)::Bool |
|
│ %594 = Base.sle_int(1, 7)::Bool |
|
│ %595 = Base.sle_int(7, %582)::Bool |
|
│ %596 = Base.and_int(%594, %595)::Bool |
|
│ %597 = Base.sle_int(1, %18)::Bool |
|
│ %598 = Base.sle_int(%18, %584)::Bool |
|
│ %599 = Base.and_int(%597, %598)::Bool |
|
│ %600 = Base.and_int(%599, true)::Bool |
|
│ %601 = Base.and_int(%596, %600)::Bool |
|
│ %602 = Base.and_int(%593, %601)::Bool |
|
│ %603 = Base.and_int(%590, %602)::Bool |
|
│ %604 = Base.and_int(%587, %603)::Bool |
|
└──── goto #106 if not %604 |
|
105 ─ goto #107 |
|
106 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %568::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
107 ┄ nothing::Nothing |
|
108 ┄ %610 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %611 = Base.getfield(%610, 1, true)::Int64 |
|
│ %612 = Base.slt_int(%611, 0)::Bool |
|
│ %613 = Base.ifelse(%612, 0, %611)::Int64 |
|
│ %614 = (getfield)(%610, 2)::Int64 |
|
│ %615 = (getfield)(%610, 3)::Int64 |
|
│ %616 = (getfield)(%610, 4)::Int64 |
|
│ %617 = Base.slt_int(%614, 0)::Bool |
|
│ %618 = Base.ifelse(%617, 0, %614)::Int64 |
|
│ %619 = Base.slt_int(%615, 0)::Bool |
|
│ %620 = Base.ifelse(%619, 0, %615)::Int64 |
|
│ %621 = Base.slt_int(%616, 0)::Bool |
|
│ %622 = Base.ifelse(%621, 0, %616)::Int64 |
|
│ %623 = Base.sub_int(%613, 0)::Int64 |
|
│ %624 = Base.mul_int(1, %623)::Int64 |
|
│ %625 = Base.sub_int(%34, 1)::Int64 |
|
│ %626 = Base.mul_int(%625, 1)::Int64 |
|
│ %627 = Base.add_int(1, %626)::Int64 |
|
│ %628 = Base.sub_int(%618, 0)::Int64 |
|
│ %629 = Base.mul_int(%624, %628)::Int64 |
|
│ %630 = Base.sub_int(%28, 1)::Int64 |
|
│ %631 = Base.mul_int(%630, %624)::Int64 |
|
│ %632 = Base.add_int(%627, %631)::Int64 |
|
│ %633 = Base.sub_int(%620, 0)::Int64 |
|
│ %634 = Base.mul_int(%629, %633)::Int64 |
|
│ %635 = Base.sub_int(%240, 1)::Int64 |
|
│ %636 = Base.mul_int(%635, %629)::Int64 |
|
│ %637 = Base.add_int(%632, %636)::Int64 |
|
│ %638 = Base.sub_int(%622, 0)::Int64 |
|
│ %639 = Base.mul_int(%634, %638)::Int64 |
|
│ %640 = Base.sub_int(7, 1)::Int64 |
|
│ %641 = Base.mul_int(%640, %634)::Int64 |
|
│ %642 = Base.add_int(%637, %641)::Int64 |
|
│ %643 = Base.sub_int(%18, 1)::Int64 |
|
│ %644 = Base.mul_int(%643, %639)::Int64 |
|
│ %645 = Base.add_int(%642, %644)::Int64 |
|
└──── goto #113 if not false |
|
109 ─ %647 = Core.tuple(%645)::Tuple{Int64} |
|
│ %648 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %649 = (getfield)(%648, 1)::Int64 |
|
│ %650 = (getfield)(%648, 2)::Int64 |
|
│ %651 = (getfield)(%648, 3)::Int64 |
|
│ %652 = (getfield)(%648, 4)::Int64 |
|
│ %653 = (getfield)(%648, 5)::Int64 |
|
│ %654 = Base.mul_int(%649, %650)::Int64 |
|
│ %655 = Base.mul_int(%654, %651)::Int64 |
|
│ %656 = Base.mul_int(%655, %652)::Int64 |
|
│ %657 = Base.mul_int(%656, %653)::Int64 |
|
│ %658 = Base.slt_int(%657, 0)::Bool |
|
│ %659 = Base.ifelse(%658, 0, %657)::Int64 |
|
│ %660 = Base.sle_int(1, %645)::Bool |
|
│ %661 = Base.sle_int(%645, %659)::Bool |
|
│ %662 = Base.and_int(%660, %661)::Bool |
|
└──── goto #111 if not %662 |
|
110 ─ goto #112 |
|
111 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %647::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
112 ┄ nothing::Nothing |
|
113 ┄ %668 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %669 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %670 = Base.sub_int(%645, 1)::Int64 |
|
│ %671 = (%669)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %668, %670)::Float32 |
|
└──── goto #114 |
|
114 ─ goto #115 |
|
115 ─ goto #116 |
|
116 ─ goto #121 if not false |
|
117 ─ %676 = Core.tuple(%34, %28, %240, 2, %18)::NTuple{5,Int64} |
|
│ %677 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %678 = Base.getfield(%677, 1, true)::Int64 |
|
│ %679 = Base.slt_int(%678, 0)::Bool |
|
│ %680 = Base.ifelse(%679, 0, %678)::Int64 |
|
│ %681 = (getfield)(%677, 2)::Int64 |
|
│ %682 = (getfield)(%677, 3)::Int64 |
|
│ %683 = (getfield)(%677, 4)::Int64 |
|
│ %684 = (getfield)(%677, 5)::Int64 |
|
│ %685 = Base.slt_int(%681, 0)::Bool |
|
│ %686 = Base.ifelse(%685, 0, %681)::Int64 |
|
│ %687 = Base.slt_int(%682, 0)::Bool |
|
│ %688 = Base.ifelse(%687, 0, %682)::Int64 |
|
│ %689 = Base.slt_int(%683, 0)::Bool |
|
│ %690 = Base.ifelse(%689, 0, %683)::Int64 |
|
│ %691 = Base.slt_int(%684, 0)::Bool |
|
│ %692 = Base.ifelse(%691, 0, %684)::Int64 |
|
│ %693 = Base.sle_int(1, %34)::Bool |
|
│ %694 = Base.sle_int(%34, %680)::Bool |
|
│ %695 = Base.and_int(%693, %694)::Bool |
|
│ %696 = Base.sle_int(1, %28)::Bool |
|
│ %697 = Base.sle_int(%28, %686)::Bool |
|
│ %698 = Base.and_int(%696, %697)::Bool |
|
│ %699 = Base.sle_int(1, %240)::Bool |
|
│ %700 = Base.sle_int(%240, %688)::Bool |
|
│ %701 = Base.and_int(%699, %700)::Bool |
|
│ %702 = Base.sle_int(1, 2)::Bool |
|
│ %703 = Base.sle_int(2, %690)::Bool |
|
│ %704 = Base.and_int(%702, %703)::Bool |
|
│ %705 = Base.sle_int(1, %18)::Bool |
|
│ %706 = Base.sle_int(%18, %692)::Bool |
|
│ %707 = Base.and_int(%705, %706)::Bool |
|
│ %708 = Base.and_int(%707, true)::Bool |
|
│ %709 = Base.and_int(%704, %708)::Bool |
|
│ %710 = Base.and_int(%701, %709)::Bool |
|
│ %711 = Base.and_int(%698, %710)::Bool |
|
│ %712 = Base.and_int(%695, %711)::Bool |
|
└──── goto #119 if not %712 |
|
118 ─ goto #120 |
|
119 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %676::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
120 ┄ nothing::Nothing |
|
121 ┄ %718 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %719 = Base.getfield(%718, 1, true)::Int64 |
|
│ %720 = Base.slt_int(%719, 0)::Bool |
|
│ %721 = Base.ifelse(%720, 0, %719)::Int64 |
|
│ %722 = (getfield)(%718, 2)::Int64 |
|
│ %723 = (getfield)(%718, 3)::Int64 |
|
│ %724 = (getfield)(%718, 4)::Int64 |
|
│ %725 = Base.slt_int(%722, 0)::Bool |
|
│ %726 = Base.ifelse(%725, 0, %722)::Int64 |
|
│ %727 = Base.slt_int(%723, 0)::Bool |
|
│ %728 = Base.ifelse(%727, 0, %723)::Int64 |
|
│ %729 = Base.slt_int(%724, 0)::Bool |
|
│ %730 = Base.ifelse(%729, 0, %724)::Int64 |
|
│ %731 = Base.sub_int(%721, 0)::Int64 |
|
│ %732 = Base.mul_int(1, %731)::Int64 |
|
│ %733 = Base.sub_int(%34, 1)::Int64 |
|
│ %734 = Base.mul_int(%733, 1)::Int64 |
|
│ %735 = Base.add_int(1, %734)::Int64 |
|
│ %736 = Base.sub_int(%726, 0)::Int64 |
|
│ %737 = Base.mul_int(%732, %736)::Int64 |
|
│ %738 = Base.sub_int(%28, 1)::Int64 |
|
│ %739 = Base.mul_int(%738, %732)::Int64 |
|
│ %740 = Base.add_int(%735, %739)::Int64 |
|
│ %741 = Base.sub_int(%728, 0)::Int64 |
|
│ %742 = Base.mul_int(%737, %741)::Int64 |
|
│ %743 = Base.sub_int(%240, 1)::Int64 |
|
│ %744 = Base.mul_int(%743, %737)::Int64 |
|
│ %745 = Base.add_int(%740, %744)::Int64 |
|
│ %746 = Base.sub_int(%730, 0)::Int64 |
|
│ %747 = Base.mul_int(%742, %746)::Int64 |
|
│ %748 = Base.sub_int(2, 1)::Int64 |
|
│ %749 = Base.mul_int(%748, %742)::Int64 |
|
│ %750 = Base.add_int(%745, %749)::Int64 |
|
│ %751 = Base.sub_int(%18, 1)::Int64 |
|
│ %752 = Base.mul_int(%751, %747)::Int64 |
|
│ %753 = Base.add_int(%750, %752)::Int64 |
|
└──── goto #126 if not false |
|
122 ─ %755 = Core.tuple(%753)::Tuple{Int64} |
|
│ %756 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %757 = (getfield)(%756, 1)::Int64 |
|
│ %758 = (getfield)(%756, 2)::Int64 |
|
│ %759 = (getfield)(%756, 3)::Int64 |
|
│ %760 = (getfield)(%756, 4)::Int64 |
|
│ %761 = (getfield)(%756, 5)::Int64 |
|
│ %762 = Base.mul_int(%757, %758)::Int64 |
|
│ %763 = Base.mul_int(%762, %759)::Int64 |
|
│ %764 = Base.mul_int(%763, %760)::Int64 |
|
│ %765 = Base.mul_int(%764, %761)::Int64 |
|
│ %766 = Base.slt_int(%765, 0)::Bool |
|
│ %767 = Base.ifelse(%766, 0, %765)::Int64 |
|
│ %768 = Base.sle_int(1, %753)::Bool |
|
│ %769 = Base.sle_int(%753, %767)::Bool |
|
│ %770 = Base.and_int(%768, %769)::Bool |
|
└──── goto #124 if not %770 |
|
123 ─ goto #125 |
|
124 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %755::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
125 ┄ nothing::Nothing |
|
126 ┄ %776 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %777 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %778 = Base.sub_int(%753, 1)::Int64 |
|
│ %779 = (%777)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %776, %778)::Float32 |
|
└──── goto #127 |
|
127 ─ goto #128 |
|
128 ─ goto #129 |
|
129 ─ goto #134 if not false |
|
130 ─ %784 = Core.tuple(%34, %28, %240, 5, %18)::NTuple{5,Int64} |
|
│ %785 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %786 = Base.getfield(%785, 1, true)::Int64 |
|
│ %787 = Base.slt_int(%786, 0)::Bool |
|
│ %788 = Base.ifelse(%787, 0, %786)::Int64 |
|
│ %789 = (getfield)(%785, 2)::Int64 |
|
│ %790 = (getfield)(%785, 3)::Int64 |
|
│ %791 = (getfield)(%785, 4)::Int64 |
|
│ %792 = (getfield)(%785, 5)::Int64 |
|
│ %793 = Base.slt_int(%789, 0)::Bool |
|
│ %794 = Base.ifelse(%793, 0, %789)::Int64 |
|
│ %795 = Base.slt_int(%790, 0)::Bool |
|
│ %796 = Base.ifelse(%795, 0, %790)::Int64 |
|
│ %797 = Base.slt_int(%791, 0)::Bool |
|
│ %798 = Base.ifelse(%797, 0, %791)::Int64 |
|
│ %799 = Base.slt_int(%792, 0)::Bool |
|
│ %800 = Base.ifelse(%799, 0, %792)::Int64 |
|
│ %801 = Base.sle_int(1, %34)::Bool |
|
│ %802 = Base.sle_int(%34, %788)::Bool |
|
│ %803 = Base.and_int(%801, %802)::Bool |
|
│ %804 = Base.sle_int(1, %28)::Bool |
|
│ %805 = Base.sle_int(%28, %794)::Bool |
|
│ %806 = Base.and_int(%804, %805)::Bool |
|
│ %807 = Base.sle_int(1, %240)::Bool |
|
│ %808 = Base.sle_int(%240, %796)::Bool |
|
│ %809 = Base.and_int(%807, %808)::Bool |
|
│ %810 = Base.sle_int(1, 5)::Bool |
|
│ %811 = Base.sle_int(5, %798)::Bool |
|
│ %812 = Base.and_int(%810, %811)::Bool |
|
│ %813 = Base.sle_int(1, %18)::Bool |
|
│ %814 = Base.sle_int(%18, %800)::Bool |
|
│ %815 = Base.and_int(%813, %814)::Bool |
|
│ %816 = Base.and_int(%815, true)::Bool |
|
│ %817 = Base.and_int(%812, %816)::Bool |
|
│ %818 = Base.and_int(%809, %817)::Bool |
|
│ %819 = Base.and_int(%806, %818)::Bool |
|
│ %820 = Base.and_int(%803, %819)::Bool |
|
└──── goto #132 if not %820 |
|
131 ─ goto #133 |
|
132 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %784::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
133 ┄ nothing::Nothing |
|
134 ┄ %826 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %827 = Base.getfield(%826, 1, true)::Int64 |
|
│ %828 = Base.slt_int(%827, 0)::Bool |
|
│ %829 = Base.ifelse(%828, 0, %827)::Int64 |
|
│ %830 = (getfield)(%826, 2)::Int64 |
|
│ %831 = (getfield)(%826, 3)::Int64 |
|
│ %832 = (getfield)(%826, 4)::Int64 |
|
│ %833 = Base.slt_int(%830, 0)::Bool |
|
│ %834 = Base.ifelse(%833, 0, %830)::Int64 |
|
│ %835 = Base.slt_int(%831, 0)::Bool |
|
│ %836 = Base.ifelse(%835, 0, %831)::Int64 |
|
│ %837 = Base.slt_int(%832, 0)::Bool |
|
│ %838 = Base.ifelse(%837, 0, %832)::Int64 |
|
│ %839 = Base.sub_int(%829, 0)::Int64 |
|
│ %840 = Base.mul_int(1, %839)::Int64 |
|
│ %841 = Base.sub_int(%34, 1)::Int64 |
|
│ %842 = Base.mul_int(%841, 1)::Int64 |
|
│ %843 = Base.add_int(1, %842)::Int64 |
|
│ %844 = Base.sub_int(%834, 0)::Int64 |
|
│ %845 = Base.mul_int(%840, %844)::Int64 |
|
│ %846 = Base.sub_int(%28, 1)::Int64 |
|
│ %847 = Base.mul_int(%846, %840)::Int64 |
|
│ %848 = Base.add_int(%843, %847)::Int64 |
|
│ %849 = Base.sub_int(%836, 0)::Int64 |
|
│ %850 = Base.mul_int(%845, %849)::Int64 |
|
│ %851 = Base.sub_int(%240, 1)::Int64 |
|
│ %852 = Base.mul_int(%851, %845)::Int64 |
|
│ %853 = Base.add_int(%848, %852)::Int64 |
|
│ %854 = Base.sub_int(%838, 0)::Int64 |
|
│ %855 = Base.mul_int(%850, %854)::Int64 |
|
│ %856 = Base.sub_int(5, 1)::Int64 |
|
│ %857 = Base.mul_int(%856, %850)::Int64 |
|
│ %858 = Base.add_int(%853, %857)::Int64 |
|
│ %859 = Base.sub_int(%18, 1)::Int64 |
|
│ %860 = Base.mul_int(%859, %855)::Int64 |
|
│ %861 = Base.add_int(%858, %860)::Int64 |
|
└──── goto #139 if not false |
|
135 ─ %863 = Core.tuple(%861)::Tuple{Int64} |
|
│ %864 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %865 = (getfield)(%864, 1)::Int64 |
|
│ %866 = (getfield)(%864, 2)::Int64 |
|
│ %867 = (getfield)(%864, 3)::Int64 |
|
│ %868 = (getfield)(%864, 4)::Int64 |
|
│ %869 = (getfield)(%864, 5)::Int64 |
|
│ %870 = Base.mul_int(%865, %866)::Int64 |
|
│ %871 = Base.mul_int(%870, %867)::Int64 |
|
│ %872 = Base.mul_int(%871, %868)::Int64 |
|
│ %873 = Base.mul_int(%872, %869)::Int64 |
|
│ %874 = Base.slt_int(%873, 0)::Bool |
|
│ %875 = Base.ifelse(%874, 0, %873)::Int64 |
|
│ %876 = Base.sle_int(1, %861)::Bool |
|
│ %877 = Base.sle_int(%861, %875)::Bool |
|
│ %878 = Base.and_int(%876, %877)::Bool |
|
└──── goto #137 if not %878 |
|
136 ─ goto #138 |
|
137 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %863::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
138 ┄ nothing::Nothing |
|
139 ┄ %884 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %885 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %886 = Base.sub_int(%861, 1)::Int64 |
|
│ %887 = (%885)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %884, %886)::Float32 |
|
└──── goto #140 |
|
140 ─ goto #141 |
|
141 ─ goto #142 |
|
142 ─ goto #147 if not false |
|
143 ─ %892 = Core.tuple(%34, %28, %240, 8, %18)::NTuple{5,Int64} |
|
│ %893 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %894 = Base.getfield(%893, 1, true)::Int64 |
|
│ %895 = Base.slt_int(%894, 0)::Bool |
|
│ %896 = Base.ifelse(%895, 0, %894)::Int64 |
|
│ %897 = (getfield)(%893, 2)::Int64 |
|
│ %898 = (getfield)(%893, 3)::Int64 |
|
│ %899 = (getfield)(%893, 4)::Int64 |
|
│ %900 = (getfield)(%893, 5)::Int64 |
|
│ %901 = Base.slt_int(%897, 0)::Bool |
|
│ %902 = Base.ifelse(%901, 0, %897)::Int64 |
|
│ %903 = Base.slt_int(%898, 0)::Bool |
|
│ %904 = Base.ifelse(%903, 0, %898)::Int64 |
|
│ %905 = Base.slt_int(%899, 0)::Bool |
|
│ %906 = Base.ifelse(%905, 0, %899)::Int64 |
|
│ %907 = Base.slt_int(%900, 0)::Bool |
|
│ %908 = Base.ifelse(%907, 0, %900)::Int64 |
|
│ %909 = Base.sle_int(1, %34)::Bool |
|
│ %910 = Base.sle_int(%34, %896)::Bool |
|
│ %911 = Base.and_int(%909, %910)::Bool |
|
│ %912 = Base.sle_int(1, %28)::Bool |
|
│ %913 = Base.sle_int(%28, %902)::Bool |
|
│ %914 = Base.and_int(%912, %913)::Bool |
|
│ %915 = Base.sle_int(1, %240)::Bool |
|
│ %916 = Base.sle_int(%240, %904)::Bool |
|
│ %917 = Base.and_int(%915, %916)::Bool |
|
│ %918 = Base.sle_int(1, 8)::Bool |
|
│ %919 = Base.sle_int(8, %906)::Bool |
|
│ %920 = Base.and_int(%918, %919)::Bool |
|
│ %921 = Base.sle_int(1, %18)::Bool |
|
│ %922 = Base.sle_int(%18, %908)::Bool |
|
│ %923 = Base.and_int(%921, %922)::Bool |
|
│ %924 = Base.and_int(%923, true)::Bool |
|
│ %925 = Base.and_int(%920, %924)::Bool |
|
│ %926 = Base.and_int(%917, %925)::Bool |
|
│ %927 = Base.and_int(%914, %926)::Bool |
|
│ %928 = Base.and_int(%911, %927)::Bool |
|
└──── goto #145 if not %928 |
|
144 ─ goto #146 |
|
145 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %892::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
146 ┄ nothing::Nothing |
|
147 ┄ %934 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %935 = Base.getfield(%934, 1, true)::Int64 |
|
│ %936 = Base.slt_int(%935, 0)::Bool |
|
│ %937 = Base.ifelse(%936, 0, %935)::Int64 |
|
│ %938 = (getfield)(%934, 2)::Int64 |
|
│ %939 = (getfield)(%934, 3)::Int64 |
|
│ %940 = (getfield)(%934, 4)::Int64 |
|
│ %941 = Base.slt_int(%938, 0)::Bool |
|
│ %942 = Base.ifelse(%941, 0, %938)::Int64 |
|
│ %943 = Base.slt_int(%939, 0)::Bool |
|
│ %944 = Base.ifelse(%943, 0, %939)::Int64 |
|
│ %945 = Base.slt_int(%940, 0)::Bool |
|
│ %946 = Base.ifelse(%945, 0, %940)::Int64 |
|
│ %947 = Base.sub_int(%937, 0)::Int64 |
|
│ %948 = Base.mul_int(1, %947)::Int64 |
|
│ %949 = Base.sub_int(%34, 1)::Int64 |
|
│ %950 = Base.mul_int(%949, 1)::Int64 |
|
│ %951 = Base.add_int(1, %950)::Int64 |
|
│ %952 = Base.sub_int(%942, 0)::Int64 |
|
│ %953 = Base.mul_int(%948, %952)::Int64 |
|
│ %954 = Base.sub_int(%28, 1)::Int64 |
|
│ %955 = Base.mul_int(%954, %948)::Int64 |
|
│ %956 = Base.add_int(%951, %955)::Int64 |
|
│ %957 = Base.sub_int(%944, 0)::Int64 |
|
│ %958 = Base.mul_int(%953, %957)::Int64 |
|
│ %959 = Base.sub_int(%240, 1)::Int64 |
|
│ %960 = Base.mul_int(%959, %953)::Int64 |
|
│ %961 = Base.add_int(%956, %960)::Int64 |
|
│ %962 = Base.sub_int(%946, 0)::Int64 |
|
│ %963 = Base.mul_int(%958, %962)::Int64 |
|
│ %964 = Base.sub_int(8, 1)::Int64 |
|
│ %965 = Base.mul_int(%964, %958)::Int64 |
|
│ %966 = Base.add_int(%961, %965)::Int64 |
|
│ %967 = Base.sub_int(%18, 1)::Int64 |
|
│ %968 = Base.mul_int(%967, %963)::Int64 |
|
│ %969 = Base.add_int(%966, %968)::Int64 |
|
└──── goto #152 if not false |
|
148 ─ %971 = Core.tuple(%969)::Tuple{Int64} |
|
│ %972 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %973 = (getfield)(%972, 1)::Int64 |
|
│ %974 = (getfield)(%972, 2)::Int64 |
|
│ %975 = (getfield)(%972, 3)::Int64 |
|
│ %976 = (getfield)(%972, 4)::Int64 |
|
│ %977 = (getfield)(%972, 5)::Int64 |
|
│ %978 = Base.mul_int(%973, %974)::Int64 |
|
│ %979 = Base.mul_int(%978, %975)::Int64 |
|
│ %980 = Base.mul_int(%979, %976)::Int64 |
|
│ %981 = Base.mul_int(%980, %977)::Int64 |
|
│ %982 = Base.slt_int(%981, 0)::Bool |
|
│ %983 = Base.ifelse(%982, 0, %981)::Int64 |
|
│ %984 = Base.sle_int(1, %969)::Bool |
|
│ %985 = Base.sle_int(%969, %983)::Bool |
|
│ %986 = Base.and_int(%984, %985)::Bool |
|
└──── goto #150 if not %986 |
|
149 ─ goto #151 |
|
150 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %971::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
151 ┄ nothing::Nothing |
|
152 ┄ %992 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %993 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %994 = Base.sub_int(%969, 1)::Int64 |
|
│ %995 = (%993)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %992, %994)::Float32 |
|
└──── goto #153 |
|
153 ─ goto #154 |
|
154 ─ goto #155 |
|
155 ─ goto #160 if not false |
|
156 ─ %1000 = Core.tuple(%34, %28, %240, 3, %18)::NTuple{5,Int64} |
|
│ %1001 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1002 = Base.getfield(%1001, 1, true)::Int64 |
|
│ %1003 = Base.slt_int(%1002, 0)::Bool |
|
│ %1004 = Base.ifelse(%1003, 0, %1002)::Int64 |
|
│ %1005 = (getfield)(%1001, 2)::Int64 |
|
│ %1006 = (getfield)(%1001, 3)::Int64 |
|
│ %1007 = (getfield)(%1001, 4)::Int64 |
|
│ %1008 = (getfield)(%1001, 5)::Int64 |
|
│ %1009 = Base.slt_int(%1005, 0)::Bool |
|
│ %1010 = Base.ifelse(%1009, 0, %1005)::Int64 |
|
│ %1011 = Base.slt_int(%1006, 0)::Bool |
|
│ %1012 = Base.ifelse(%1011, 0, %1006)::Int64 |
|
│ %1013 = Base.slt_int(%1007, 0)::Bool |
|
│ %1014 = Base.ifelse(%1013, 0, %1007)::Int64 |
|
│ %1015 = Base.slt_int(%1008, 0)::Bool |
|
│ %1016 = Base.ifelse(%1015, 0, %1008)::Int64 |
|
│ %1017 = Base.sle_int(1, %34)::Bool |
|
│ %1018 = Base.sle_int(%34, %1004)::Bool |
|
│ %1019 = Base.and_int(%1017, %1018)::Bool |
|
│ %1020 = Base.sle_int(1, %28)::Bool |
|
│ %1021 = Base.sle_int(%28, %1010)::Bool |
|
│ %1022 = Base.and_int(%1020, %1021)::Bool |
|
│ %1023 = Base.sle_int(1, %240)::Bool |
|
│ %1024 = Base.sle_int(%240, %1012)::Bool |
|
│ %1025 = Base.and_int(%1023, %1024)::Bool |
|
│ %1026 = Base.sle_int(1, 3)::Bool |
|
│ %1027 = Base.sle_int(3, %1014)::Bool |
|
│ %1028 = Base.and_int(%1026, %1027)::Bool |
|
│ %1029 = Base.sle_int(1, %18)::Bool |
|
│ %1030 = Base.sle_int(%18, %1016)::Bool |
|
│ %1031 = Base.and_int(%1029, %1030)::Bool |
|
│ %1032 = Base.and_int(%1031, true)::Bool |
|
│ %1033 = Base.and_int(%1028, %1032)::Bool |
|
│ %1034 = Base.and_int(%1025, %1033)::Bool |
|
│ %1035 = Base.and_int(%1022, %1034)::Bool |
|
│ %1036 = Base.and_int(%1019, %1035)::Bool |
|
└──── goto #158 if not %1036 |
|
157 ─ goto #159 |
|
158 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1000::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
159 ┄ nothing::Nothing |
|
160 ┄ %1042 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1043 = Base.getfield(%1042, 1, true)::Int64 |
|
│ %1044 = Base.slt_int(%1043, 0)::Bool |
|
│ %1045 = Base.ifelse(%1044, 0, %1043)::Int64 |
|
│ %1046 = (getfield)(%1042, 2)::Int64 |
|
│ %1047 = (getfield)(%1042, 3)::Int64 |
|
│ %1048 = (getfield)(%1042, 4)::Int64 |
|
│ %1049 = Base.slt_int(%1046, 0)::Bool |
|
│ %1050 = Base.ifelse(%1049, 0, %1046)::Int64 |
|
│ %1051 = Base.slt_int(%1047, 0)::Bool |
|
│ %1052 = Base.ifelse(%1051, 0, %1047)::Int64 |
|
│ %1053 = Base.slt_int(%1048, 0)::Bool |
|
│ %1054 = Base.ifelse(%1053, 0, %1048)::Int64 |
|
│ %1055 = Base.sub_int(%1045, 0)::Int64 |
|
│ %1056 = Base.mul_int(1, %1055)::Int64 |
|
│ %1057 = Base.sub_int(%34, 1)::Int64 |
|
│ %1058 = Base.mul_int(%1057, 1)::Int64 |
|
│ %1059 = Base.add_int(1, %1058)::Int64 |
|
│ %1060 = Base.sub_int(%1050, 0)::Int64 |
|
│ %1061 = Base.mul_int(%1056, %1060)::Int64 |
|
│ %1062 = Base.sub_int(%28, 1)::Int64 |
|
│ %1063 = Base.mul_int(%1062, %1056)::Int64 |
|
│ %1064 = Base.add_int(%1059, %1063)::Int64 |
|
│ %1065 = Base.sub_int(%1052, 0)::Int64 |
|
│ %1066 = Base.mul_int(%1061, %1065)::Int64 |
|
│ %1067 = Base.sub_int(%240, 1)::Int64 |
|
│ %1068 = Base.mul_int(%1067, %1061)::Int64 |
|
│ %1069 = Base.add_int(%1064, %1068)::Int64 |
|
│ %1070 = Base.sub_int(%1054, 0)::Int64 |
|
│ %1071 = Base.mul_int(%1066, %1070)::Int64 |
|
│ %1072 = Base.sub_int(3, 1)::Int64 |
|
│ %1073 = Base.mul_int(%1072, %1066)::Int64 |
|
│ %1074 = Base.add_int(%1069, %1073)::Int64 |
|
│ %1075 = Base.sub_int(%18, 1)::Int64 |
|
│ %1076 = Base.mul_int(%1075, %1071)::Int64 |
|
│ %1077 = Base.add_int(%1074, %1076)::Int64 |
|
└──── goto #165 if not false |
|
161 ─ %1079 = Core.tuple(%1077)::Tuple{Int64} |
|
│ %1080 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1081 = (getfield)(%1080, 1)::Int64 |
|
│ %1082 = (getfield)(%1080, 2)::Int64 |
|
│ %1083 = (getfield)(%1080, 3)::Int64 |
|
│ %1084 = (getfield)(%1080, 4)::Int64 |
|
│ %1085 = (getfield)(%1080, 5)::Int64 |
|
│ %1086 = Base.mul_int(%1081, %1082)::Int64 |
|
│ %1087 = Base.mul_int(%1086, %1083)::Int64 |
|
│ %1088 = Base.mul_int(%1087, %1084)::Int64 |
|
│ %1089 = Base.mul_int(%1088, %1085)::Int64 |
|
│ %1090 = Base.slt_int(%1089, 0)::Bool |
|
│ %1091 = Base.ifelse(%1090, 0, %1089)::Int64 |
|
│ %1092 = Base.sle_int(1, %1077)::Bool |
|
│ %1093 = Base.sle_int(%1077, %1091)::Bool |
|
│ %1094 = Base.and_int(%1092, %1093)::Bool |
|
└──── goto #163 if not %1094 |
|
162 ─ goto #164 |
|
163 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1079::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
164 ┄ nothing::Nothing |
|
165 ┄ %1100 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1101 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1102 = Base.sub_int(%1077, 1)::Int64 |
|
│ %1103 = (%1101)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1100, %1102)::Float32 |
|
└──── goto #166 |
|
166 ─ goto #167 |
|
167 ─ goto #168 |
|
168 ─ goto #173 if not false |
|
169 ─ %1108 = Core.tuple(%34, %28, %240, 6, %18)::NTuple{5,Int64} |
|
│ %1109 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1110 = Base.getfield(%1109, 1, true)::Int64 |
|
│ %1111 = Base.slt_int(%1110, 0)::Bool |
|
│ %1112 = Base.ifelse(%1111, 0, %1110)::Int64 |
|
│ %1113 = (getfield)(%1109, 2)::Int64 |
|
│ %1114 = (getfield)(%1109, 3)::Int64 |
|
│ %1115 = (getfield)(%1109, 4)::Int64 |
|
│ %1116 = (getfield)(%1109, 5)::Int64 |
|
│ %1117 = Base.slt_int(%1113, 0)::Bool |
|
│ %1118 = Base.ifelse(%1117, 0, %1113)::Int64 |
|
│ %1119 = Base.slt_int(%1114, 0)::Bool |
|
│ %1120 = Base.ifelse(%1119, 0, %1114)::Int64 |
|
│ %1121 = Base.slt_int(%1115, 0)::Bool |
|
│ %1122 = Base.ifelse(%1121, 0, %1115)::Int64 |
|
│ %1123 = Base.slt_int(%1116, 0)::Bool |
|
│ %1124 = Base.ifelse(%1123, 0, %1116)::Int64 |
|
│ %1125 = Base.sle_int(1, %34)::Bool |
|
│ %1126 = Base.sle_int(%34, %1112)::Bool |
|
│ %1127 = Base.and_int(%1125, %1126)::Bool |
|
│ %1128 = Base.sle_int(1, %28)::Bool |
|
│ %1129 = Base.sle_int(%28, %1118)::Bool |
|
│ %1130 = Base.and_int(%1128, %1129)::Bool |
|
│ %1131 = Base.sle_int(1, %240)::Bool |
|
│ %1132 = Base.sle_int(%240, %1120)::Bool |
|
│ %1133 = Base.and_int(%1131, %1132)::Bool |
|
│ %1134 = Base.sle_int(1, 6)::Bool |
|
│ %1135 = Base.sle_int(6, %1122)::Bool |
|
│ %1136 = Base.and_int(%1134, %1135)::Bool |
|
│ %1137 = Base.sle_int(1, %18)::Bool |
|
│ %1138 = Base.sle_int(%18, %1124)::Bool |
|
│ %1139 = Base.and_int(%1137, %1138)::Bool |
|
│ %1140 = Base.and_int(%1139, true)::Bool |
|
│ %1141 = Base.and_int(%1136, %1140)::Bool |
|
│ %1142 = Base.and_int(%1133, %1141)::Bool |
|
│ %1143 = Base.and_int(%1130, %1142)::Bool |
|
│ %1144 = Base.and_int(%1127, %1143)::Bool |
|
└──── goto #171 if not %1144 |
|
170 ─ goto #172 |
|
171 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1108::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
172 ┄ nothing::Nothing |
|
173 ┄ %1150 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1151 = Base.getfield(%1150, 1, true)::Int64 |
|
│ %1152 = Base.slt_int(%1151, 0)::Bool |
|
│ %1153 = Base.ifelse(%1152, 0, %1151)::Int64 |
|
│ %1154 = (getfield)(%1150, 2)::Int64 |
|
│ %1155 = (getfield)(%1150, 3)::Int64 |
|
│ %1156 = (getfield)(%1150, 4)::Int64 |
|
│ %1157 = Base.slt_int(%1154, 0)::Bool |
|
│ %1158 = Base.ifelse(%1157, 0, %1154)::Int64 |
|
│ %1159 = Base.slt_int(%1155, 0)::Bool |
|
│ %1160 = Base.ifelse(%1159, 0, %1155)::Int64 |
|
│ %1161 = Base.slt_int(%1156, 0)::Bool |
|
│ %1162 = Base.ifelse(%1161, 0, %1156)::Int64 |
|
│ %1163 = Base.sub_int(%1153, 0)::Int64 |
|
│ %1164 = Base.mul_int(1, %1163)::Int64 |
|
│ %1165 = Base.sub_int(%34, 1)::Int64 |
|
│ %1166 = Base.mul_int(%1165, 1)::Int64 |
|
│ %1167 = Base.add_int(1, %1166)::Int64 |
|
│ %1168 = Base.sub_int(%1158, 0)::Int64 |
|
│ %1169 = Base.mul_int(%1164, %1168)::Int64 |
|
│ %1170 = Base.sub_int(%28, 1)::Int64 |
|
│ %1171 = Base.mul_int(%1170, %1164)::Int64 |
|
│ %1172 = Base.add_int(%1167, %1171)::Int64 |
|
│ %1173 = Base.sub_int(%1160, 0)::Int64 |
|
│ %1174 = Base.mul_int(%1169, %1173)::Int64 |
|
│ %1175 = Base.sub_int(%240, 1)::Int64 |
|
│ %1176 = Base.mul_int(%1175, %1169)::Int64 |
|
│ %1177 = Base.add_int(%1172, %1176)::Int64 |
|
│ %1178 = Base.sub_int(%1162, 0)::Int64 |
|
│ %1179 = Base.mul_int(%1174, %1178)::Int64 |
|
│ %1180 = Base.sub_int(6, 1)::Int64 |
|
│ %1181 = Base.mul_int(%1180, %1174)::Int64 |
|
│ %1182 = Base.add_int(%1177, %1181)::Int64 |
|
│ %1183 = Base.sub_int(%18, 1)::Int64 |
|
│ %1184 = Base.mul_int(%1183, %1179)::Int64 |
|
│ %1185 = Base.add_int(%1182, %1184)::Int64 |
|
└──── goto #178 if not false |
|
174 ─ %1187 = Core.tuple(%1185)::Tuple{Int64} |
|
│ %1188 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1189 = (getfield)(%1188, 1)::Int64 |
|
│ %1190 = (getfield)(%1188, 2)::Int64 |
|
│ %1191 = (getfield)(%1188, 3)::Int64 |
|
│ %1192 = (getfield)(%1188, 4)::Int64 |
|
│ %1193 = (getfield)(%1188, 5)::Int64 |
|
│ %1194 = Base.mul_int(%1189, %1190)::Int64 |
|
│ %1195 = Base.mul_int(%1194, %1191)::Int64 |
|
│ %1196 = Base.mul_int(%1195, %1192)::Int64 |
|
│ %1197 = Base.mul_int(%1196, %1193)::Int64 |
|
│ %1198 = Base.slt_int(%1197, 0)::Bool |
|
│ %1199 = Base.ifelse(%1198, 0, %1197)::Int64 |
|
│ %1200 = Base.sle_int(1, %1185)::Bool |
|
│ %1201 = Base.sle_int(%1185, %1199)::Bool |
|
│ %1202 = Base.and_int(%1200, %1201)::Bool |
|
└──── goto #176 if not %1202 |
|
175 ─ goto #177 |
|
176 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1187::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
177 ┄ nothing::Nothing |
|
178 ┄ %1208 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1209 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1210 = Base.sub_int(%1185, 1)::Int64 |
|
│ %1211 = (%1209)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1208, %1210)::Float32 |
|
└──── goto #179 |
|
179 ─ goto #180 |
|
180 ─ goto #181 |
|
181 ─ goto #186 if not false |
|
182 ─ %1216 = Core.tuple(%34, %28, %240, 9, %18)::NTuple{5,Int64} |
|
│ %1217 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1218 = Base.getfield(%1217, 1, true)::Int64 |
|
│ %1219 = Base.slt_int(%1218, 0)::Bool |
|
│ %1220 = Base.ifelse(%1219, 0, %1218)::Int64 |
|
│ %1221 = (getfield)(%1217, 2)::Int64 |
|
│ %1222 = (getfield)(%1217, 3)::Int64 |
|
│ %1223 = (getfield)(%1217, 4)::Int64 |
|
│ %1224 = (getfield)(%1217, 5)::Int64 |
|
│ %1225 = Base.slt_int(%1221, 0)::Bool |
|
│ %1226 = Base.ifelse(%1225, 0, %1221)::Int64 |
|
│ %1227 = Base.slt_int(%1222, 0)::Bool |
|
│ %1228 = Base.ifelse(%1227, 0, %1222)::Int64 |
|
│ %1229 = Base.slt_int(%1223, 0)::Bool |
|
│ %1230 = Base.ifelse(%1229, 0, %1223)::Int64 |
|
│ %1231 = Base.slt_int(%1224, 0)::Bool |
|
│ %1232 = Base.ifelse(%1231, 0, %1224)::Int64 |
|
│ %1233 = Base.sle_int(1, %34)::Bool |
|
│ %1234 = Base.sle_int(%34, %1220)::Bool |
|
│ %1235 = Base.and_int(%1233, %1234)::Bool |
|
│ %1236 = Base.sle_int(1, %28)::Bool |
|
│ %1237 = Base.sle_int(%28, %1226)::Bool |
|
│ %1238 = Base.and_int(%1236, %1237)::Bool |
|
│ %1239 = Base.sle_int(1, %240)::Bool |
|
│ %1240 = Base.sle_int(%240, %1228)::Bool |
|
│ %1241 = Base.and_int(%1239, %1240)::Bool |
|
│ %1242 = Base.sle_int(1, 9)::Bool |
|
│ %1243 = Base.sle_int(9, %1230)::Bool |
|
│ %1244 = Base.and_int(%1242, %1243)::Bool |
|
│ %1245 = Base.sle_int(1, %18)::Bool |
|
│ %1246 = Base.sle_int(%18, %1232)::Bool |
|
│ %1247 = Base.and_int(%1245, %1246)::Bool |
|
│ %1248 = Base.and_int(%1247, true)::Bool |
|
│ %1249 = Base.and_int(%1244, %1248)::Bool |
|
│ %1250 = Base.and_int(%1241, %1249)::Bool |
|
│ %1251 = Base.and_int(%1238, %1250)::Bool |
|
│ %1252 = Base.and_int(%1235, %1251)::Bool |
|
└──── goto #184 if not %1252 |
|
183 ─ goto #185 |
|
184 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1216::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
185 ┄ nothing::Nothing |
|
186 ┄ %1258 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1259 = Base.getfield(%1258, 1, true)::Int64 |
|
│ %1260 = Base.slt_int(%1259, 0)::Bool |
|
│ %1261 = Base.ifelse(%1260, 0, %1259)::Int64 |
|
│ %1262 = (getfield)(%1258, 2)::Int64 |
|
│ %1263 = (getfield)(%1258, 3)::Int64 |
|
│ %1264 = (getfield)(%1258, 4)::Int64 |
|
│ %1265 = Base.slt_int(%1262, 0)::Bool |
|
│ %1266 = Base.ifelse(%1265, 0, %1262)::Int64 |
|
│ %1267 = Base.slt_int(%1263, 0)::Bool |
|
│ %1268 = Base.ifelse(%1267, 0, %1263)::Int64 |
|
│ %1269 = Base.slt_int(%1264, 0)::Bool |
|
│ %1270 = Base.ifelse(%1269, 0, %1264)::Int64 |
|
│ %1271 = Base.sub_int(%1261, 0)::Int64 |
|
│ %1272 = Base.mul_int(1, %1271)::Int64 |
|
│ %1273 = Base.sub_int(%34, 1)::Int64 |
|
│ %1274 = Base.mul_int(%1273, 1)::Int64 |
|
│ %1275 = Base.add_int(1, %1274)::Int64 |
|
│ %1276 = Base.sub_int(%1266, 0)::Int64 |
|
│ %1277 = Base.mul_int(%1272, %1276)::Int64 |
|
│ %1278 = Base.sub_int(%28, 1)::Int64 |
|
│ %1279 = Base.mul_int(%1278, %1272)::Int64 |
|
│ %1280 = Base.add_int(%1275, %1279)::Int64 |
|
│ %1281 = Base.sub_int(%1268, 0)::Int64 |
|
│ %1282 = Base.mul_int(%1277, %1281)::Int64 |
|
│ %1283 = Base.sub_int(%240, 1)::Int64 |
|
│ %1284 = Base.mul_int(%1283, %1277)::Int64 |
|
│ %1285 = Base.add_int(%1280, %1284)::Int64 |
|
│ %1286 = Base.sub_int(%1270, 0)::Int64 |
|
│ %1287 = Base.mul_int(%1282, %1286)::Int64 |
|
│ %1288 = Base.sub_int(9, 1)::Int64 |
|
│ %1289 = Base.mul_int(%1288, %1282)::Int64 |
|
│ %1290 = Base.add_int(%1285, %1289)::Int64 |
|
│ %1291 = Base.sub_int(%18, 1)::Int64 |
|
│ %1292 = Base.mul_int(%1291, %1287)::Int64 |
|
│ %1293 = Base.add_int(%1290, %1292)::Int64 |
|
└──── goto #191 if not false |
|
187 ─ %1295 = Core.tuple(%1293)::Tuple{Int64} |
|
│ %1296 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1297 = (getfield)(%1296, 1)::Int64 |
|
│ %1298 = (getfield)(%1296, 2)::Int64 |
|
│ %1299 = (getfield)(%1296, 3)::Int64 |
|
│ %1300 = (getfield)(%1296, 4)::Int64 |
|
│ %1301 = (getfield)(%1296, 5)::Int64 |
|
│ %1302 = Base.mul_int(%1297, %1298)::Int64 |
|
│ %1303 = Base.mul_int(%1302, %1299)::Int64 |
|
│ %1304 = Base.mul_int(%1303, %1300)::Int64 |
|
│ %1305 = Base.mul_int(%1304, %1301)::Int64 |
|
│ %1306 = Base.slt_int(%1305, 0)::Bool |
|
│ %1307 = Base.ifelse(%1306, 0, %1305)::Int64 |
|
│ %1308 = Base.sle_int(1, %1293)::Bool |
|
│ %1309 = Base.sle_int(%1293, %1307)::Bool |
|
│ %1310 = Base.and_int(%1308, %1309)::Bool |
|
└──── goto #189 if not %1310 |
|
188 ─ goto #190 |
|
189 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1295::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
190 ┄ nothing::Nothing |
|
191 ┄ %1316 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1317 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1318 = Base.sub_int(%1293, 1)::Int64 |
|
│ %1319 = (%1317)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1316, %1318)::Float32 |
|
└──── goto #192 |
|
192 ─ goto #193 |
|
193 ─ goto #194 |
|
194 ─ goto #199 if not false |
|
195 ─ %1324 = Core.tuple(%34, %28, %240, 14, %18)::NTuple{5,Int64} |
|
│ %1325 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1326 = Base.getfield(%1325, 1, true)::Int64 |
|
│ %1327 = Base.slt_int(%1326, 0)::Bool |
|
│ %1328 = Base.ifelse(%1327, 0, %1326)::Int64 |
|
│ %1329 = (getfield)(%1325, 2)::Int64 |
|
│ %1330 = (getfield)(%1325, 3)::Int64 |
|
│ %1331 = (getfield)(%1325, 4)::Int64 |
|
│ %1332 = (getfield)(%1325, 5)::Int64 |
|
│ %1333 = Base.slt_int(%1329, 0)::Bool |
|
│ %1334 = Base.ifelse(%1333, 0, %1329)::Int64 |
|
│ %1335 = Base.slt_int(%1330, 0)::Bool |
|
│ %1336 = Base.ifelse(%1335, 0, %1330)::Int64 |
|
│ %1337 = Base.slt_int(%1331, 0)::Bool |
|
│ %1338 = Base.ifelse(%1337, 0, %1331)::Int64 |
|
│ %1339 = Base.slt_int(%1332, 0)::Bool |
|
│ %1340 = Base.ifelse(%1339, 0, %1332)::Int64 |
|
│ %1341 = Base.sle_int(1, %34)::Bool |
|
│ %1342 = Base.sle_int(%34, %1328)::Bool |
|
│ %1343 = Base.and_int(%1341, %1342)::Bool |
|
│ %1344 = Base.sle_int(1, %28)::Bool |
|
│ %1345 = Base.sle_int(%28, %1334)::Bool |
|
│ %1346 = Base.and_int(%1344, %1345)::Bool |
|
│ %1347 = Base.sle_int(1, %240)::Bool |
|
│ %1348 = Base.sle_int(%240, %1336)::Bool |
|
│ %1349 = Base.and_int(%1347, %1348)::Bool |
|
│ %1350 = Base.sle_int(1, 14)::Bool |
|
│ %1351 = Base.sle_int(14, %1338)::Bool |
|
│ %1352 = Base.and_int(%1350, %1351)::Bool |
|
│ %1353 = Base.sle_int(1, %18)::Bool |
|
│ %1354 = Base.sle_int(%18, %1340)::Bool |
|
│ %1355 = Base.and_int(%1353, %1354)::Bool |
|
│ %1356 = Base.and_int(%1355, true)::Bool |
|
│ %1357 = Base.and_int(%1352, %1356)::Bool |
|
│ %1358 = Base.and_int(%1349, %1357)::Bool |
|
│ %1359 = Base.and_int(%1346, %1358)::Bool |
|
│ %1360 = Base.and_int(%1343, %1359)::Bool |
|
└──── goto #197 if not %1360 |
|
196 ─ goto #198 |
|
197 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1324::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
198 ┄ nothing::Nothing |
|
199 ┄ %1366 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1367 = Base.getfield(%1366, 1, true)::Int64 |
|
│ %1368 = Base.slt_int(%1367, 0)::Bool |
|
│ %1369 = Base.ifelse(%1368, 0, %1367)::Int64 |
|
│ %1370 = (getfield)(%1366, 2)::Int64 |
|
│ %1371 = (getfield)(%1366, 3)::Int64 |
|
│ %1372 = (getfield)(%1366, 4)::Int64 |
|
│ %1373 = Base.slt_int(%1370, 0)::Bool |
|
│ %1374 = Base.ifelse(%1373, 0, %1370)::Int64 |
|
│ %1375 = Base.slt_int(%1371, 0)::Bool |
|
│ %1376 = Base.ifelse(%1375, 0, %1371)::Int64 |
|
│ %1377 = Base.slt_int(%1372, 0)::Bool |
|
│ %1378 = Base.ifelse(%1377, 0, %1372)::Int64 |
|
│ %1379 = Base.sub_int(%1369, 0)::Int64 |
|
│ %1380 = Base.mul_int(1, %1379)::Int64 |
|
│ %1381 = Base.sub_int(%34, 1)::Int64 |
|
│ %1382 = Base.mul_int(%1381, 1)::Int64 |
|
│ %1383 = Base.add_int(1, %1382)::Int64 |
|
│ %1384 = Base.sub_int(%1374, 0)::Int64 |
|
│ %1385 = Base.mul_int(%1380, %1384)::Int64 |
|
│ %1386 = Base.sub_int(%28, 1)::Int64 |
|
│ %1387 = Base.mul_int(%1386, %1380)::Int64 |
|
│ %1388 = Base.add_int(%1383, %1387)::Int64 |
|
│ %1389 = Base.sub_int(%1376, 0)::Int64 |
|
│ %1390 = Base.mul_int(%1385, %1389)::Int64 |
|
│ %1391 = Base.sub_int(%240, 1)::Int64 |
|
│ %1392 = Base.mul_int(%1391, %1385)::Int64 |
|
│ %1393 = Base.add_int(%1388, %1392)::Int64 |
|
│ %1394 = Base.sub_int(%1378, 0)::Int64 |
|
│ %1395 = Base.mul_int(%1390, %1394)::Int64 |
|
│ %1396 = Base.sub_int(14, 1)::Int64 |
|
│ %1397 = Base.mul_int(%1396, %1390)::Int64 |
|
│ %1398 = Base.add_int(%1393, %1397)::Int64 |
|
│ %1399 = Base.sub_int(%18, 1)::Int64 |
|
│ %1400 = Base.mul_int(%1399, %1395)::Int64 |
|
│ %1401 = Base.add_int(%1398, %1400)::Int64 |
|
└──── goto #204 if not false |
|
200 ─ %1403 = Core.tuple(%1401)::Tuple{Int64} |
|
│ %1404 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %1405 = (getfield)(%1404, 1)::Int64 |
|
│ %1406 = (getfield)(%1404, 2)::Int64 |
|
│ %1407 = (getfield)(%1404, 3)::Int64 |
|
│ %1408 = (getfield)(%1404, 4)::Int64 |
|
│ %1409 = (getfield)(%1404, 5)::Int64 |
|
│ %1410 = Base.mul_int(%1405, %1406)::Int64 |
|
│ %1411 = Base.mul_int(%1410, %1407)::Int64 |
|
│ %1412 = Base.mul_int(%1411, %1408)::Int64 |
|
│ %1413 = Base.mul_int(%1412, %1409)::Int64 |
|
│ %1414 = Base.slt_int(%1413, 0)::Bool |
|
│ %1415 = Base.ifelse(%1414, 0, %1413)::Int64 |
|
│ %1416 = Base.sle_int(1, %1401)::Bool |
|
│ %1417 = Base.sle_int(%1401, %1415)::Bool |
|
│ %1418 = Base.and_int(%1416, %1417)::Bool |
|
└──── goto #202 if not %1418 |
|
201 ─ goto #203 |
|
202 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1403::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
203 ┄ nothing::Nothing |
|
204 ┄ %1424 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1425 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1426 = Base.sub_int(%1401, 1)::Int64 |
|
│ %1427 = (%1425)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1424, %1426)::Float32 |
|
└──── goto #205 |
|
205 ─ goto #206 |
|
206 ─ goto #207 |
|
207 ─ goto #212 if not false |
|
208 ─ %1432 = Core.tuple(%34, %28, %240, 2, %18)::NTuple{5,Int64} |
|
│ %1433 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1434 = Base.getfield(%1433, 1, true)::Int64 |
|
│ %1435 = Base.slt_int(%1434, 0)::Bool |
|
│ %1436 = Base.ifelse(%1435, 0, %1434)::Int64 |
|
│ %1437 = (getfield)(%1433, 2)::Int64 |
|
│ %1438 = (getfield)(%1433, 3)::Int64 |
|
│ %1439 = (getfield)(%1433, 4)::Int64 |
|
│ %1440 = (getfield)(%1433, 5)::Int64 |
|
│ %1441 = Base.slt_int(%1437, 0)::Bool |
|
│ %1442 = Base.ifelse(%1441, 0, %1437)::Int64 |
|
│ %1443 = Base.slt_int(%1438, 0)::Bool |
|
│ %1444 = Base.ifelse(%1443, 0, %1438)::Int64 |
|
│ %1445 = Base.slt_int(%1439, 0)::Bool |
|
│ %1446 = Base.ifelse(%1445, 0, %1439)::Int64 |
|
│ %1447 = Base.slt_int(%1440, 0)::Bool |
|
│ %1448 = Base.ifelse(%1447, 0, %1440)::Int64 |
|
│ %1449 = Base.sle_int(1, %34)::Bool |
|
│ %1450 = Base.sle_int(%34, %1436)::Bool |
|
│ %1451 = Base.and_int(%1449, %1450)::Bool |
|
│ %1452 = Base.sle_int(1, %28)::Bool |
|
│ %1453 = Base.sle_int(%28, %1442)::Bool |
|
│ %1454 = Base.and_int(%1452, %1453)::Bool |
|
│ %1455 = Base.sle_int(1, %240)::Bool |
|
│ %1456 = Base.sle_int(%240, %1444)::Bool |
|
│ %1457 = Base.and_int(%1455, %1456)::Bool |
|
│ %1458 = Base.sle_int(1, 2)::Bool |
|
│ %1459 = Base.sle_int(2, %1446)::Bool |
|
│ %1460 = Base.and_int(%1458, %1459)::Bool |
|
│ %1461 = Base.sle_int(1, %18)::Bool |
|
│ %1462 = Base.sle_int(%18, %1448)::Bool |
|
│ %1463 = Base.and_int(%1461, %1462)::Bool |
|
│ %1464 = Base.and_int(%1463, true)::Bool |
|
│ %1465 = Base.and_int(%1460, %1464)::Bool |
|
│ %1466 = Base.and_int(%1457, %1465)::Bool |
|
│ %1467 = Base.and_int(%1454, %1466)::Bool |
|
│ %1468 = Base.and_int(%1451, %1467)::Bool |
|
└──── goto #210 if not %1468 |
|
209 ─ goto #211 |
|
210 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1432::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
211 ┄ nothing::Nothing |
|
212 ┄ %1474 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1475 = Base.getfield(%1474, 1, true)::Int64 |
|
│ %1476 = Base.slt_int(%1475, 0)::Bool |
|
│ %1477 = Base.ifelse(%1476, 0, %1475)::Int64 |
|
│ %1478 = (getfield)(%1474, 2)::Int64 |
|
│ %1479 = (getfield)(%1474, 3)::Int64 |
|
│ %1480 = (getfield)(%1474, 4)::Int64 |
|
│ %1481 = Base.slt_int(%1478, 0)::Bool |
|
│ %1482 = Base.ifelse(%1481, 0, %1478)::Int64 |
|
│ %1483 = Base.slt_int(%1479, 0)::Bool |
|
│ %1484 = Base.ifelse(%1483, 0, %1479)::Int64 |
|
│ %1485 = Base.slt_int(%1480, 0)::Bool |
|
│ %1486 = Base.ifelse(%1485, 0, %1480)::Int64 |
|
│ %1487 = Base.sub_int(%1477, 0)::Int64 |
|
│ %1488 = Base.mul_int(1, %1487)::Int64 |
|
│ %1489 = Base.sub_int(%34, 1)::Int64 |
|
│ %1490 = Base.mul_int(%1489, 1)::Int64 |
|
│ %1491 = Base.add_int(1, %1490)::Int64 |
|
│ %1492 = Base.sub_int(%1482, 0)::Int64 |
|
│ %1493 = Base.mul_int(%1488, %1492)::Int64 |
|
│ %1494 = Base.sub_int(%28, 1)::Int64 |
|
│ %1495 = Base.mul_int(%1494, %1488)::Int64 |
|
│ %1496 = Base.add_int(%1491, %1495)::Int64 |
|
│ %1497 = Base.sub_int(%1484, 0)::Int64 |
|
│ %1498 = Base.mul_int(%1493, %1497)::Int64 |
|
│ %1499 = Base.sub_int(%240, 1)::Int64 |
|
│ %1500 = Base.mul_int(%1499, %1493)::Int64 |
|
│ %1501 = Base.add_int(%1496, %1500)::Int64 |
|
│ %1502 = Base.sub_int(%1486, 0)::Int64 |
|
│ %1503 = Base.mul_int(%1498, %1502)::Int64 |
|
│ %1504 = Base.sub_int(2, 1)::Int64 |
|
│ %1505 = Base.mul_int(%1504, %1498)::Int64 |
|
│ %1506 = Base.add_int(%1501, %1505)::Int64 |
|
│ %1507 = Base.sub_int(%18, 1)::Int64 |
|
│ %1508 = Base.mul_int(%1507, %1503)::Int64 |
|
│ %1509 = Base.add_int(%1506, %1508)::Int64 |
|
└──── goto #217 if not false |
|
213 ─ %1511 = Core.tuple(%1509)::Tuple{Int64} |
|
│ %1512 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1513 = (getfield)(%1512, 1)::Int64 |
|
│ %1514 = (getfield)(%1512, 2)::Int64 |
|
│ %1515 = (getfield)(%1512, 3)::Int64 |
|
│ %1516 = (getfield)(%1512, 4)::Int64 |
|
│ %1517 = (getfield)(%1512, 5)::Int64 |
|
│ %1518 = Base.mul_int(%1513, %1514)::Int64 |
|
│ %1519 = Base.mul_int(%1518, %1515)::Int64 |
|
│ %1520 = Base.mul_int(%1519, %1516)::Int64 |
|
│ %1521 = Base.mul_int(%1520, %1517)::Int64 |
|
│ %1522 = Base.slt_int(%1521, 0)::Bool |
|
│ %1523 = Base.ifelse(%1522, 0, %1521)::Int64 |
|
│ %1524 = Base.sle_int(1, %1509)::Bool |
|
│ %1525 = Base.sle_int(%1509, %1523)::Bool |
|
│ %1526 = Base.and_int(%1524, %1525)::Bool |
|
└──── goto #215 if not %1526 |
|
214 ─ goto #216 |
|
215 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1511::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
216 ┄ nothing::Nothing |
|
217 ┄ %1532 = Base.getfield(Q, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1533 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1534 = Base.sub_int(%1509, 1)::Int64 |
|
│ %1535 = (%1533)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1532, %1534)::Float32 |
|
└──── goto #218 |
|
218 ─ goto #219 |
|
219 ─ goto #220 |
|
220 ─ goto #225 if not false |
|
221 ─ %1540 = Core.tuple(%34, %28, %240, 3, %18)::NTuple{5,Int64} |
|
│ %1541 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1542 = Base.getfield(%1541, 1, true)::Int64 |
|
│ %1543 = Base.slt_int(%1542, 0)::Bool |
|
│ %1544 = Base.ifelse(%1543, 0, %1542)::Int64 |
|
│ %1545 = (getfield)(%1541, 2)::Int64 |
|
│ %1546 = (getfield)(%1541, 3)::Int64 |
|
│ %1547 = (getfield)(%1541, 4)::Int64 |
|
│ %1548 = (getfield)(%1541, 5)::Int64 |
|
│ %1549 = Base.slt_int(%1545, 0)::Bool |
|
│ %1550 = Base.ifelse(%1549, 0, %1545)::Int64 |
|
│ %1551 = Base.slt_int(%1546, 0)::Bool |
|
│ %1552 = Base.ifelse(%1551, 0, %1546)::Int64 |
|
│ %1553 = Base.slt_int(%1547, 0)::Bool |
|
│ %1554 = Base.ifelse(%1553, 0, %1547)::Int64 |
|
│ %1555 = Base.slt_int(%1548, 0)::Bool |
|
│ %1556 = Base.ifelse(%1555, 0, %1548)::Int64 |
|
│ %1557 = Base.sle_int(1, %34)::Bool |
|
│ %1558 = Base.sle_int(%34, %1544)::Bool |
|
│ %1559 = Base.and_int(%1557, %1558)::Bool |
|
│ %1560 = Base.sle_int(1, %28)::Bool |
|
│ %1561 = Base.sle_int(%28, %1550)::Bool |
|
│ %1562 = Base.and_int(%1560, %1561)::Bool |
|
│ %1563 = Base.sle_int(1, %240)::Bool |
|
│ %1564 = Base.sle_int(%240, %1552)::Bool |
|
│ %1565 = Base.and_int(%1563, %1564)::Bool |
|
│ %1566 = Base.sle_int(1, 3)::Bool |
|
│ %1567 = Base.sle_int(3, %1554)::Bool |
|
│ %1568 = Base.and_int(%1566, %1567)::Bool |
|
│ %1569 = Base.sle_int(1, %18)::Bool |
|
│ %1570 = Base.sle_int(%18, %1556)::Bool |
|
│ %1571 = Base.and_int(%1569, %1570)::Bool |
|
│ %1572 = Base.and_int(%1571, true)::Bool |
|
│ %1573 = Base.and_int(%1568, %1572)::Bool |
|
│ %1574 = Base.and_int(%1565, %1573)::Bool |
|
│ %1575 = Base.and_int(%1562, %1574)::Bool |
|
│ %1576 = Base.and_int(%1559, %1575)::Bool |
|
└──── goto #223 if not %1576 |
|
222 ─ goto #224 |
|
223 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1540::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
224 ┄ nothing::Nothing |
|
225 ┄ %1582 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1583 = Base.getfield(%1582, 1, true)::Int64 |
|
│ %1584 = Base.slt_int(%1583, 0)::Bool |
|
│ %1585 = Base.ifelse(%1584, 0, %1583)::Int64 |
|
│ %1586 = (getfield)(%1582, 2)::Int64 |
|
│ %1587 = (getfield)(%1582, 3)::Int64 |
|
│ %1588 = (getfield)(%1582, 4)::Int64 |
|
│ %1589 = Base.slt_int(%1586, 0)::Bool |
|
│ %1590 = Base.ifelse(%1589, 0, %1586)::Int64 |
|
│ %1591 = Base.slt_int(%1587, 0)::Bool |
|
│ %1592 = Base.ifelse(%1591, 0, %1587)::Int64 |
|
│ %1593 = Base.slt_int(%1588, 0)::Bool |
|
│ %1594 = Base.ifelse(%1593, 0, %1588)::Int64 |
|
│ %1595 = Base.sub_int(%1585, 0)::Int64 |
|
│ %1596 = Base.mul_int(1, %1595)::Int64 |
|
│ %1597 = Base.sub_int(%34, 1)::Int64 |
|
│ %1598 = Base.mul_int(%1597, 1)::Int64 |
|
│ %1599 = Base.add_int(1, %1598)::Int64 |
|
│ %1600 = Base.sub_int(%1590, 0)::Int64 |
|
│ %1601 = Base.mul_int(%1596, %1600)::Int64 |
|
│ %1602 = Base.sub_int(%28, 1)::Int64 |
|
│ %1603 = Base.mul_int(%1602, %1596)::Int64 |
|
│ %1604 = Base.add_int(%1599, %1603)::Int64 |
|
│ %1605 = Base.sub_int(%1592, 0)::Int64 |
|
│ %1606 = Base.mul_int(%1601, %1605)::Int64 |
|
│ %1607 = Base.sub_int(%240, 1)::Int64 |
|
│ %1608 = Base.mul_int(%1607, %1601)::Int64 |
|
│ %1609 = Base.add_int(%1604, %1608)::Int64 |
|
│ %1610 = Base.sub_int(%1594, 0)::Int64 |
|
│ %1611 = Base.mul_int(%1606, %1610)::Int64 |
|
│ %1612 = Base.sub_int(3, 1)::Int64 |
|
│ %1613 = Base.mul_int(%1612, %1606)::Int64 |
|
│ %1614 = Base.add_int(%1609, %1613)::Int64 |
|
│ %1615 = Base.sub_int(%18, 1)::Int64 |
|
│ %1616 = Base.mul_int(%1615, %1611)::Int64 |
|
│ %1617 = Base.add_int(%1614, %1616)::Int64 |
|
└──── goto #230 if not false |
|
226 ─ %1619 = Core.tuple(%1617)::Tuple{Int64} |
|
│ %1620 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1621 = (getfield)(%1620, 1)::Int64 |
|
│ %1622 = (getfield)(%1620, 2)::Int64 |
|
│ %1623 = (getfield)(%1620, 3)::Int64 |
|
│ %1624 = (getfield)(%1620, 4)::Int64 |
|
│ %1625 = (getfield)(%1620, 5)::Int64 |
|
│ %1626 = Base.mul_int(%1621, %1622)::Int64 |
|
│ %1627 = Base.mul_int(%1626, %1623)::Int64 |
|
│ %1628 = Base.mul_int(%1627, %1624)::Int64 |
|
│ %1629 = Base.mul_int(%1628, %1625)::Int64 |
|
│ %1630 = Base.slt_int(%1629, 0)::Bool |
|
│ %1631 = Base.ifelse(%1630, 0, %1629)::Int64 |
|
│ %1632 = Base.sle_int(1, %1617)::Bool |
|
│ %1633 = Base.sle_int(%1617, %1631)::Bool |
|
│ %1634 = Base.and_int(%1632, %1633)::Bool |
|
└──── goto #228 if not %1634 |
|
227 ─ goto #229 |
|
228 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1619::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
229 ┄ nothing::Nothing |
|
230 ┄ %1640 = Base.getfield(Q, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1641 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1642 = Base.sub_int(%1617, 1)::Int64 |
|
│ %1643 = (%1641)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1640, %1642)::Float32 |
|
└──── goto #231 |
|
231 ─ goto #232 |
|
232 ─ goto #233 |
|
233 ─ goto #238 if not false |
|
234 ─ %1648 = Core.tuple(%34, %28, %240, 4, %18)::NTuple{5,Int64} |
|
│ %1649 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1650 = Base.getfield(%1649, 1, true)::Int64 |
|
│ %1651 = Base.slt_int(%1650, 0)::Bool |
|
│ %1652 = Base.ifelse(%1651, 0, %1650)::Int64 |
|
│ %1653 = (getfield)(%1649, 2)::Int64 |
|
│ %1654 = (getfield)(%1649, 3)::Int64 |
|
│ %1655 = (getfield)(%1649, 4)::Int64 |
|
│ %1656 = (getfield)(%1649, 5)::Int64 |
|
│ %1657 = Base.slt_int(%1653, 0)::Bool |
|
│ %1658 = Base.ifelse(%1657, 0, %1653)::Int64 |
|
│ %1659 = Base.slt_int(%1654, 0)::Bool |
|
│ %1660 = Base.ifelse(%1659, 0, %1654)::Int64 |
|
│ %1661 = Base.slt_int(%1655, 0)::Bool |
|
│ %1662 = Base.ifelse(%1661, 0, %1655)::Int64 |
|
│ %1663 = Base.slt_int(%1656, 0)::Bool |
|
│ %1664 = Base.ifelse(%1663, 0, %1656)::Int64 |
|
│ %1665 = Base.sle_int(1, %34)::Bool |
|
│ %1666 = Base.sle_int(%34, %1652)::Bool |
|
│ %1667 = Base.and_int(%1665, %1666)::Bool |
|
│ %1668 = Base.sle_int(1, %28)::Bool |
|
│ %1669 = Base.sle_int(%28, %1658)::Bool |
|
│ %1670 = Base.and_int(%1668, %1669)::Bool |
|
│ %1671 = Base.sle_int(1, %240)::Bool |
|
│ %1672 = Base.sle_int(%240, %1660)::Bool |
|
│ %1673 = Base.and_int(%1671, %1672)::Bool |
|
│ %1674 = Base.sle_int(1, 4)::Bool |
|
│ %1675 = Base.sle_int(4, %1662)::Bool |
|
│ %1676 = Base.and_int(%1674, %1675)::Bool |
|
│ %1677 = Base.sle_int(1, %18)::Bool |
|
│ %1678 = Base.sle_int(%18, %1664)::Bool |
|
│ %1679 = Base.and_int(%1677, %1678)::Bool |
|
│ %1680 = Base.and_int(%1679, true)::Bool |
|
│ %1681 = Base.and_int(%1676, %1680)::Bool |
|
│ %1682 = Base.and_int(%1673, %1681)::Bool |
|
│ %1683 = Base.and_int(%1670, %1682)::Bool |
|
│ %1684 = Base.and_int(%1667, %1683)::Bool |
|
└──── goto #236 if not %1684 |
|
235 ─ goto #237 |
|
236 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1648::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
237 ┄ nothing::Nothing |
|
238 ┄ %1690 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1691 = Base.getfield(%1690, 1, true)::Int64 |
|
│ %1692 = Base.slt_int(%1691, 0)::Bool |
|
│ %1693 = Base.ifelse(%1692, 0, %1691)::Int64 |
|
│ %1694 = (getfield)(%1690, 2)::Int64 |
|
│ %1695 = (getfield)(%1690, 3)::Int64 |
|
│ %1696 = (getfield)(%1690, 4)::Int64 |
|
│ %1697 = Base.slt_int(%1694, 0)::Bool |
|
│ %1698 = Base.ifelse(%1697, 0, %1694)::Int64 |
|
│ %1699 = Base.slt_int(%1695, 0)::Bool |
|
│ %1700 = Base.ifelse(%1699, 0, %1695)::Int64 |
|
│ %1701 = Base.slt_int(%1696, 0)::Bool |
|
│ %1702 = Base.ifelse(%1701, 0, %1696)::Int64 |
|
│ %1703 = Base.sub_int(%1693, 0)::Int64 |
|
│ %1704 = Base.mul_int(1, %1703)::Int64 |
|
│ %1705 = Base.sub_int(%34, 1)::Int64 |
|
│ %1706 = Base.mul_int(%1705, 1)::Int64 |
|
│ %1707 = Base.add_int(1, %1706)::Int64 |
|
│ %1708 = Base.sub_int(%1698, 0)::Int64 |
|
│ %1709 = Base.mul_int(%1704, %1708)::Int64 |
|
│ %1710 = Base.sub_int(%28, 1)::Int64 |
|
│ %1711 = Base.mul_int(%1710, %1704)::Int64 |
|
│ %1712 = Base.add_int(%1707, %1711)::Int64 |
|
│ %1713 = Base.sub_int(%1700, 0)::Int64 |
|
│ %1714 = Base.mul_int(%1709, %1713)::Int64 |
|
│ %1715 = Base.sub_int(%240, 1)::Int64 |
|
│ %1716 = Base.mul_int(%1715, %1709)::Int64 |
|
│ %1717 = Base.add_int(%1712, %1716)::Int64 |
|
│ %1718 = Base.sub_int(%1702, 0)::Int64 |
|
│ %1719 = Base.mul_int(%1714, %1718)::Int64 |
|
│ %1720 = Base.sub_int(4, 1)::Int64 |
|
│ %1721 = Base.mul_int(%1720, %1714)::Int64 |
|
│ %1722 = Base.add_int(%1717, %1721)::Int64 |
|
│ %1723 = Base.sub_int(%18, 1)::Int64 |
|
│ %1724 = Base.mul_int(%1723, %1719)::Int64 |
|
│ %1725 = Base.add_int(%1722, %1724)::Int64 |
|
└──── goto #243 if not false |
|
239 ─ %1727 = Core.tuple(%1725)::Tuple{Int64} |
|
│ %1728 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1729 = (getfield)(%1728, 1)::Int64 |
|
│ %1730 = (getfield)(%1728, 2)::Int64 |
|
│ %1731 = (getfield)(%1728, 3)::Int64 |
|
│ %1732 = (getfield)(%1728, 4)::Int64 |
|
│ %1733 = (getfield)(%1728, 5)::Int64 |
|
│ %1734 = Base.mul_int(%1729, %1730)::Int64 |
|
│ %1735 = Base.mul_int(%1734, %1731)::Int64 |
|
│ %1736 = Base.mul_int(%1735, %1732)::Int64 |
|
│ %1737 = Base.mul_int(%1736, %1733)::Int64 |
|
│ %1738 = Base.slt_int(%1737, 0)::Bool |
|
│ %1739 = Base.ifelse(%1738, 0, %1737)::Int64 |
|
│ %1740 = Base.sle_int(1, %1725)::Bool |
|
│ %1741 = Base.sle_int(%1725, %1739)::Bool |
|
│ %1742 = Base.and_int(%1740, %1741)::Bool |
|
└──── goto #241 if not %1742 |
|
240 ─ goto #242 |
|
241 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1727::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
242 ┄ nothing::Nothing |
|
243 ┄ %1748 = Base.getfield(Q, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1749 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1750 = Base.sub_int(%1725, 1)::Int64 |
|
│ %1751 = (%1749)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1748, %1750)::Float32 |
|
└──── goto #244 |
|
244 ─ goto #245 |
|
245 ─ goto #246 |
|
246 ─ goto #251 if not false |
|
247 ─ %1756 = Core.tuple(%34, %28, %240, 1, %18)::NTuple{5,Int64} |
|
│ %1757 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1758 = Base.getfield(%1757, 1, true)::Int64 |
|
│ %1759 = Base.slt_int(%1758, 0)::Bool |
|
│ %1760 = Base.ifelse(%1759, 0, %1758)::Int64 |
|
│ %1761 = (getfield)(%1757, 2)::Int64 |
|
│ %1762 = (getfield)(%1757, 3)::Int64 |
|
│ %1763 = (getfield)(%1757, 4)::Int64 |
|
│ %1764 = (getfield)(%1757, 5)::Int64 |
|
│ %1765 = Base.slt_int(%1761, 0)::Bool |
|
│ %1766 = Base.ifelse(%1765, 0, %1761)::Int64 |
|
│ %1767 = Base.slt_int(%1762, 0)::Bool |
|
│ %1768 = Base.ifelse(%1767, 0, %1762)::Int64 |
|
│ %1769 = Base.slt_int(%1763, 0)::Bool |
|
│ %1770 = Base.ifelse(%1769, 0, %1763)::Int64 |
|
│ %1771 = Base.slt_int(%1764, 0)::Bool |
|
│ %1772 = Base.ifelse(%1771, 0, %1764)::Int64 |
|
│ %1773 = Base.sle_int(1, %34)::Bool |
|
│ %1774 = Base.sle_int(%34, %1760)::Bool |
|
│ %1775 = Base.and_int(%1773, %1774)::Bool |
|
│ %1776 = Base.sle_int(1, %28)::Bool |
|
│ %1777 = Base.sle_int(%28, %1766)::Bool |
|
│ %1778 = Base.and_int(%1776, %1777)::Bool |
|
│ %1779 = Base.sle_int(1, %240)::Bool |
|
│ %1780 = Base.sle_int(%240, %1768)::Bool |
|
│ %1781 = Base.and_int(%1779, %1780)::Bool |
|
│ %1782 = Base.sle_int(1, 1)::Bool |
|
│ %1783 = Base.sle_int(1, %1770)::Bool |
|
│ %1784 = Base.and_int(%1782, %1783)::Bool |
|
│ %1785 = Base.sle_int(1, %18)::Bool |
|
│ %1786 = Base.sle_int(%18, %1772)::Bool |
|
│ %1787 = Base.and_int(%1785, %1786)::Bool |
|
│ %1788 = Base.and_int(%1787, true)::Bool |
|
│ %1789 = Base.and_int(%1784, %1788)::Bool |
|
│ %1790 = Base.and_int(%1781, %1789)::Bool |
|
│ %1791 = Base.and_int(%1778, %1790)::Bool |
|
│ %1792 = Base.and_int(%1775, %1791)::Bool |
|
└──── goto #249 if not %1792 |
|
248 ─ goto #250 |
|
249 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1756::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
250 ┄ nothing::Nothing |
|
251 ┄ %1798 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1799 = Base.getfield(%1798, 1, true)::Int64 |
|
│ %1800 = Base.slt_int(%1799, 0)::Bool |
|
│ %1801 = Base.ifelse(%1800, 0, %1799)::Int64 |
|
│ %1802 = (getfield)(%1798, 2)::Int64 |
|
│ %1803 = (getfield)(%1798, 3)::Int64 |
|
│ %1804 = (getfield)(%1798, 4)::Int64 |
|
│ %1805 = Base.slt_int(%1802, 0)::Bool |
|
│ %1806 = Base.ifelse(%1805, 0, %1802)::Int64 |
|
│ %1807 = Base.slt_int(%1803, 0)::Bool |
|
│ %1808 = Base.ifelse(%1807, 0, %1803)::Int64 |
|
│ %1809 = Base.slt_int(%1804, 0)::Bool |
|
│ %1810 = Base.ifelse(%1809, 0, %1804)::Int64 |
|
│ %1811 = Base.sub_int(%1801, 0)::Int64 |
|
│ %1812 = Base.mul_int(1, %1811)::Int64 |
|
│ %1813 = Base.sub_int(%34, 1)::Int64 |
|
│ %1814 = Base.mul_int(%1813, 1)::Int64 |
|
│ %1815 = Base.add_int(1, %1814)::Int64 |
|
│ %1816 = Base.sub_int(%1806, 0)::Int64 |
|
│ %1817 = Base.mul_int(%1812, %1816)::Int64 |
|
│ %1818 = Base.sub_int(%28, 1)::Int64 |
|
│ %1819 = Base.mul_int(%1818, %1812)::Int64 |
|
│ %1820 = Base.add_int(%1815, %1819)::Int64 |
|
│ %1821 = Base.sub_int(%1808, 0)::Int64 |
|
│ %1822 = Base.mul_int(%1817, %1821)::Int64 |
|
│ %1823 = Base.sub_int(%240, 1)::Int64 |
|
│ %1824 = Base.mul_int(%1823, %1817)::Int64 |
|
│ %1825 = Base.add_int(%1820, %1824)::Int64 |
|
│ %1826 = Base.sub_int(%1810, 0)::Int64 |
|
│ %1827 = Base.mul_int(%1822, %1826)::Int64 |
|
│ %1828 = Base.sub_int(1, 1)::Int64 |
|
│ %1829 = Base.mul_int(%1828, %1822)::Int64 |
|
│ %1830 = Base.add_int(%1825, %1829)::Int64 |
|
│ %1831 = Base.sub_int(%18, 1)::Int64 |
|
│ %1832 = Base.mul_int(%1831, %1827)::Int64 |
|
│ %1833 = Base.add_int(%1830, %1832)::Int64 |
|
└──── goto #256 if not false |
|
252 ─ %1835 = Core.tuple(%1833)::Tuple{Int64} |
|
│ %1836 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1837 = (getfield)(%1836, 1)::Int64 |
|
│ %1838 = (getfield)(%1836, 2)::Int64 |
|
│ %1839 = (getfield)(%1836, 3)::Int64 |
|
│ %1840 = (getfield)(%1836, 4)::Int64 |
|
│ %1841 = (getfield)(%1836, 5)::Int64 |
|
│ %1842 = Base.mul_int(%1837, %1838)::Int64 |
|
│ %1843 = Base.mul_int(%1842, %1839)::Int64 |
|
│ %1844 = Base.mul_int(%1843, %1840)::Int64 |
|
│ %1845 = Base.mul_int(%1844, %1841)::Int64 |
|
│ %1846 = Base.slt_int(%1845, 0)::Bool |
|
│ %1847 = Base.ifelse(%1846, 0, %1845)::Int64 |
|
│ %1848 = Base.sle_int(1, %1833)::Bool |
|
│ %1849 = Base.sle_int(%1833, %1847)::Bool |
|
│ %1850 = Base.and_int(%1848, %1849)::Bool |
|
└──── goto #254 if not %1850 |
|
253 ─ goto #255 |
|
254 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1835::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
255 ┄ nothing::Nothing |
|
256 ┄ %1856 = Base.getfield(Q, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1857 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1858 = Base.sub_int(%1833, 1)::Int64 |
|
│ %1859 = (%1857)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1856, %1858)::Float32 |
|
└──── goto #257 |
|
257 ─ goto #258 |
|
258 ─ goto #259 |
|
259 ─ goto #264 if not false |
|
260 ─ %1864 = Core.tuple(%34, %28, %240, 5, %18)::NTuple{5,Int64} |
|
│ %1865 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1866 = Base.getfield(%1865, 1, true)::Int64 |
|
│ %1867 = Base.slt_int(%1866, 0)::Bool |
|
│ %1868 = Base.ifelse(%1867, 0, %1866)::Int64 |
|
│ %1869 = (getfield)(%1865, 2)::Int64 |
|
│ %1870 = (getfield)(%1865, 3)::Int64 |
|
│ %1871 = (getfield)(%1865, 4)::Int64 |
|
│ %1872 = (getfield)(%1865, 5)::Int64 |
|
│ %1873 = Base.slt_int(%1869, 0)::Bool |
|
│ %1874 = Base.ifelse(%1873, 0, %1869)::Int64 |
|
│ %1875 = Base.slt_int(%1870, 0)::Bool |
|
│ %1876 = Base.ifelse(%1875, 0, %1870)::Int64 |
|
│ %1877 = Base.slt_int(%1871, 0)::Bool |
|
│ %1878 = Base.ifelse(%1877, 0, %1871)::Int64 |
|
│ %1879 = Base.slt_int(%1872, 0)::Bool |
|
│ %1880 = Base.ifelse(%1879, 0, %1872)::Int64 |
|
│ %1881 = Base.sle_int(1, %34)::Bool |
|
│ %1882 = Base.sle_int(%34, %1868)::Bool |
|
│ %1883 = Base.and_int(%1881, %1882)::Bool |
|
│ %1884 = Base.sle_int(1, %28)::Bool |
|
│ %1885 = Base.sle_int(%28, %1874)::Bool |
|
│ %1886 = Base.and_int(%1884, %1885)::Bool |
|
│ %1887 = Base.sle_int(1, %240)::Bool |
|
│ %1888 = Base.sle_int(%240, %1876)::Bool |
|
│ %1889 = Base.and_int(%1887, %1888)::Bool |
|
│ %1890 = Base.sle_int(1, 5)::Bool |
|
│ %1891 = Base.sle_int(5, %1878)::Bool |
|
│ %1892 = Base.and_int(%1890, %1891)::Bool |
|
│ %1893 = Base.sle_int(1, %18)::Bool |
|
│ %1894 = Base.sle_int(%18, %1880)::Bool |
|
│ %1895 = Base.and_int(%1893, %1894)::Bool |
|
│ %1896 = Base.and_int(%1895, true)::Bool |
|
│ %1897 = Base.and_int(%1892, %1896)::Bool |
|
│ %1898 = Base.and_int(%1889, %1897)::Bool |
|
│ %1899 = Base.and_int(%1886, %1898)::Bool |
|
│ %1900 = Base.and_int(%1883, %1899)::Bool |
|
└──── goto #262 if not %1900 |
|
261 ─ goto #263 |
|
262 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1864::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
263 ┄ nothing::Nothing |
|
264 ┄ %1906 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1907 = Base.getfield(%1906, 1, true)::Int64 |
|
│ %1908 = Base.slt_int(%1907, 0)::Bool |
|
│ %1909 = Base.ifelse(%1908, 0, %1907)::Int64 |
|
│ %1910 = (getfield)(%1906, 2)::Int64 |
|
│ %1911 = (getfield)(%1906, 3)::Int64 |
|
│ %1912 = (getfield)(%1906, 4)::Int64 |
|
│ %1913 = Base.slt_int(%1910, 0)::Bool |
|
│ %1914 = Base.ifelse(%1913, 0, %1910)::Int64 |
|
│ %1915 = Base.slt_int(%1911, 0)::Bool |
|
│ %1916 = Base.ifelse(%1915, 0, %1911)::Int64 |
|
│ %1917 = Base.slt_int(%1912, 0)::Bool |
|
│ %1918 = Base.ifelse(%1917, 0, %1912)::Int64 |
|
│ %1919 = Base.sub_int(%1909, 0)::Int64 |
|
│ %1920 = Base.mul_int(1, %1919)::Int64 |
|
│ %1921 = Base.sub_int(%34, 1)::Int64 |
|
│ %1922 = Base.mul_int(%1921, 1)::Int64 |
|
│ %1923 = Base.add_int(1, %1922)::Int64 |
|
│ %1924 = Base.sub_int(%1914, 0)::Int64 |
|
│ %1925 = Base.mul_int(%1920, %1924)::Int64 |
|
│ %1926 = Base.sub_int(%28, 1)::Int64 |
|
│ %1927 = Base.mul_int(%1926, %1920)::Int64 |
|
│ %1928 = Base.add_int(%1923, %1927)::Int64 |
|
│ %1929 = Base.sub_int(%1916, 0)::Int64 |
|
│ %1930 = Base.mul_int(%1925, %1929)::Int64 |
|
│ %1931 = Base.sub_int(%240, 1)::Int64 |
|
│ %1932 = Base.mul_int(%1931, %1925)::Int64 |
|
│ %1933 = Base.add_int(%1928, %1932)::Int64 |
|
│ %1934 = Base.sub_int(%1918, 0)::Int64 |
|
│ %1935 = Base.mul_int(%1930, %1934)::Int64 |
|
│ %1936 = Base.sub_int(5, 1)::Int64 |
|
│ %1937 = Base.mul_int(%1936, %1930)::Int64 |
|
│ %1938 = Base.add_int(%1933, %1937)::Int64 |
|
│ %1939 = Base.sub_int(%18, 1)::Int64 |
|
│ %1940 = Base.mul_int(%1939, %1935)::Int64 |
|
│ %1941 = Base.add_int(%1938, %1940)::Int64 |
|
└──── goto #269 if not false |
|
265 ─ %1943 = Core.tuple(%1941)::Tuple{Int64} |
|
│ %1944 = Base.getfield(Q, :shape)::NTuple{5,Int64} |
|
│ %1945 = (getfield)(%1944, 1)::Int64 |
|
│ %1946 = (getfield)(%1944, 2)::Int64 |
|
│ %1947 = (getfield)(%1944, 3)::Int64 |
|
│ %1948 = (getfield)(%1944, 4)::Int64 |
|
│ %1949 = (getfield)(%1944, 5)::Int64 |
|
│ %1950 = Base.mul_int(%1945, %1946)::Int64 |
|
│ %1951 = Base.mul_int(%1950, %1947)::Int64 |
|
│ %1952 = Base.mul_int(%1951, %1948)::Int64 |
|
│ %1953 = Base.mul_int(%1952, %1949)::Int64 |
|
│ %1954 = Base.slt_int(%1953, 0)::Bool |
|
│ %1955 = Base.ifelse(%1954, 0, %1953)::Int64 |
|
│ %1956 = Base.sle_int(1, %1941)::Bool |
|
│ %1957 = Base.sle_int(%1941, %1955)::Bool |
|
│ %1958 = Base.and_int(%1956, %1957)::Bool |
|
└──── goto #267 if not %1958 |
|
266 ─ goto #268 |
|
267 ─ invoke Base.throw_boundserror(_4::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %1943::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
268 ┄ nothing::Nothing |
|
269 ┄ %1964 = Base.getfield(Q, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %1965 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %1966 = Base.sub_int(%1941, 1)::Int64 |
|
│ %1967 = (%1965)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %1964, %1966)::Float32 |
|
└──── goto #270 |
|
270 ─ goto #271 |
|
271 ─ goto #272 |
|
272 ─ %1971 = Base.mul_float(%1535, %1535)::Float32 |
|
│ %1972 = Base.mul_float(%1643, %1643)::Float32 |
|
│ %1973 = Base.mul_float(%1751, %1751)::Float32 |
|
│ %1974 = Base.add_float(%1971, %1972)::Float32 |
|
│ %1975 = Base.add_float(%1974, %1973)::Float32 |
|
│ %1976 = Base.mul_float(2.0f0, %1859)::Float32 |
|
│ %1977 = Base.div_float(%1975, %1976)::Float32 |
|
│ %1978 = Base.sub_float(%1967, %1977)::Float32 |
|
│ %1979 = Base.mul_float(%1859, gravity)::Float32 |
|
│ %1980 = Base.mul_float(%1979, %1427)::Float32 |
|
│ %1981 = Base.sub_float(%1978, %1980)::Float32 |
|
│ %1982 = Base.mul_float(0.4f0, %1981)::Float32 |
|
│ %1983 = Base.div_float(1.0f0, %1859)::Float32 |
|
│ %1984 = Base.mul_float(%1983, %1535)::Float32 |
|
│ %1985 = Base.mul_float(%1984, %1535)::Float32 |
|
│ %1986 = Base.add_float(%1985, %1982)::Float32 |
|
│ %1987 = Base.mul_float(%1983, %1535)::Float32 |
|
│ %1988 = Base.mul_float(%1987, %1643)::Float32 |
|
│ %1989 = Base.mul_float(%1983, %1535)::Float32 |
|
│ %1990 = Base.mul_float(%1989, %1751)::Float32 |
|
│ %1991 = Base.add_float(%1967, %1982)::Float32 |
|
│ %1992 = Base.mul_float(%1983, %1535)::Float32 |
|
│ %1993 = Base.mul_float(%1992, %1991)::Float32 |
|
│ %1994 = Base.mul_float(%1983, %1643)::Float32 |
|
│ %1995 = Base.mul_float(%1994, %1535)::Float32 |
|
│ %1996 = Base.mul_float(%1983, %1643)::Float32 |
|
│ %1997 = Base.mul_float(%1996, %1643)::Float32 |
|
│ %1998 = Base.add_float(%1997, %1982)::Float32 |
|
│ %1999 = Base.mul_float(%1983, %1643)::Float32 |
|
│ %2000 = Base.mul_float(%1999, %1751)::Float32 |
|
│ %2001 = Base.add_float(%1967, %1982)::Float32 |
|
│ %2002 = Base.mul_float(%1983, %1643)::Float32 |
|
│ %2003 = Base.mul_float(%2002, %2001)::Float32 |
|
│ %2004 = Base.mul_float(%1983, %1751)::Float32 |
|
│ %2005 = Base.mul_float(%2004, %1535)::Float32 |
|
│ %2006 = Base.mul_float(%1983, %1751)::Float32 |
|
│ %2007 = Base.mul_float(%2006, %1643)::Float32 |
|
│ %2008 = Base.mul_float(%1983, %1751)::Float32 |
|
│ %2009 = Base.mul_float(%2008, %1751)::Float32 |
|
│ %2010 = Base.add_float(%2009, %1982)::Float32 |
|
│ %2011 = Base.add_float(%1967, %1982)::Float32 |
|
│ %2012 = Base.mul_float(%1983, %1751)::Float32 |
|
│ %2013 = Base.mul_float(%2012, %2011)::Float32 |
|
│ %2014 = Base.mul_float(%455, %1535)::Float32 |
|
│ %2015 = Base.mul_float(%563, %1643)::Float32 |
|
│ %2016 = Base.mul_float(%671, %1751)::Float32 |
|
│ %2017 = Base.add_float(%2014, %2015)::Float32 |
|
│ %2018 = Base.add_float(%2017, %2016)::Float32 |
|
│ %2019 = Base.mul_float(%347, %2018)::Float32 |
|
│ %2020 = Main._ρ::Core.Compiler.Const(1, false) |
|
└──── goto #277 if not false |
|
273 ─ %2022 = Core.tuple(%34, %28, %2020)::Tuple{Int64,Int64,Int64} |
|
│ %2023 = Base.slt_int(5, 0)::Bool |
|
│ %2024 = Base.ifelse(%2023, 0, 5)::Int64 |
|
│ %2025 = Base.slt_int(5, 0)::Bool |
|
│ %2026 = Base.ifelse(%2025, 0, 5)::Int64 |
|
│ %2027 = Base.slt_int(5, 0)::Bool |
|
│ %2028 = Base.ifelse(%2027, 0, 5)::Int64 |
|
│ %2029 = Base.sle_int(1, %34)::Bool |
|
│ %2030 = Base.sle_int(%34, %2024)::Bool |
|
│ %2031 = Base.and_int(%2029, %2030)::Bool |
|
│ %2032 = Base.sle_int(1, %28)::Bool |
|
│ %2033 = Base.sle_int(%28, %2026)::Bool |
|
│ %2034 = Base.and_int(%2032, %2033)::Bool |
|
│ %2035 = Base.sle_int(1, %2020)::Bool |
|
│ %2036 = Base.sle_int(%2020, %2028)::Bool |
|
│ %2037 = Base.and_int(%2035, %2036)::Bool |
|
│ %2038 = Base.and_int(%2037, true)::Bool |
|
│ %2039 = Base.and_int(%2034, %2038)::Bool |
|
│ %2040 = Base.and_int(%2031, %2039)::Bool |
|
└──── goto #275 if not %2040 |
|
274 ─ goto #276 |
|
275 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2022::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
276 ┄ nothing::Nothing |
|
277 ┄ %2046 = Base.slt_int(5, 0)::Bool |
|
│ %2047 = Base.ifelse(%2046, 0, 5)::Int64 |
|
│ %2048 = Base.slt_int(5, 0)::Bool |
|
│ %2049 = Base.ifelse(%2048, 0, 5)::Int64 |
|
│ %2050 = Base.sub_int(%2047, 0)::Int64 |
|
│ %2051 = Base.mul_int(1, %2050)::Int64 |
|
│ %2052 = Base.sub_int(%34, 1)::Int64 |
|
│ %2053 = Base.mul_int(%2052, 1)::Int64 |
|
│ %2054 = Base.add_int(1, %2053)::Int64 |
|
│ %2055 = Base.sub_int(%2049, 0)::Int64 |
|
│ %2056 = Base.mul_int(%2051, %2055)::Int64 |
|
│ %2057 = Base.sub_int(%28, 1)::Int64 |
|
│ %2058 = Base.mul_int(%2057, %2051)::Int64 |
|
│ %2059 = Base.add_int(%2054, %2058)::Int64 |
|
│ %2060 = Base.sub_int(%2020, 1)::Int64 |
|
│ %2061 = Base.mul_int(%2060, %2056)::Int64 |
|
│ %2062 = Base.add_int(%2059, %2061)::Int64 |
|
└──── goto #282 if not false |
|
278 ─ %2064 = Core.tuple(%2062)::Tuple{Int64} |
|
│ %2065 = Base.mul_int(5, 5)::Int64 |
|
│ %2066 = Base.mul_int(%2065, 5)::Int64 |
|
│ %2067 = Base.slt_int(%2066, 0)::Bool |
|
│ %2068 = Base.ifelse(%2067, 0, %2066)::Int64 |
|
│ %2069 = Base.sle_int(1, %2062)::Bool |
|
│ %2070 = Base.sle_int(%2062, %2068)::Bool |
|
│ %2071 = Base.and_int(%2069, %2070)::Bool |
|
└──── goto #280 if not %2071 |
|
279 ─ goto #281 |
|
280 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2064::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
281 ┄ nothing::Nothing |
|
282 ┄ %2077 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2078 = Base.sub_int(%2062, 1)::Int64 |
|
│ (%2077)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %5, %2019, %2078)::Nothing |
|
└──── goto #283 |
|
283 ─ goto #284 |
|
284 ─ goto #285 |
|
285 ─ %2083 = Base.mul_float(%455, %1986)::Float32 |
|
│ %2084 = Base.mul_float(%563, %1995)::Float32 |
|
│ %2085 = Base.mul_float(%671, %2005)::Float32 |
|
│ %2086 = Base.add_float(%2083, %2084)::Float32 |
|
│ %2087 = Base.add_float(%2086, %2085)::Float32 |
|
│ %2088 = Base.mul_float(%347, %2087)::Float32 |
|
│ %2089 = Main._U::Core.Compiler.Const(2, false) |
|
└──── goto #290 if not false |
|
286 ─ %2091 = Core.tuple(%34, %28, %2089)::Tuple{Int64,Int64,Int64} |
|
│ %2092 = Base.slt_int(5, 0)::Bool |
|
│ %2093 = Base.ifelse(%2092, 0, 5)::Int64 |
|
│ %2094 = Base.slt_int(5, 0)::Bool |
|
│ %2095 = Base.ifelse(%2094, 0, 5)::Int64 |
|
│ %2096 = Base.slt_int(5, 0)::Bool |
|
│ %2097 = Base.ifelse(%2096, 0, 5)::Int64 |
|
│ %2098 = Base.sle_int(1, %34)::Bool |
|
│ %2099 = Base.sle_int(%34, %2093)::Bool |
|
│ %2100 = Base.and_int(%2098, %2099)::Bool |
|
│ %2101 = Base.sle_int(1, %28)::Bool |
|
│ %2102 = Base.sle_int(%28, %2095)::Bool |
|
│ %2103 = Base.and_int(%2101, %2102)::Bool |
|
│ %2104 = Base.sle_int(1, %2089)::Bool |
|
│ %2105 = Base.sle_int(%2089, %2097)::Bool |
|
│ %2106 = Base.and_int(%2104, %2105)::Bool |
|
│ %2107 = Base.and_int(%2106, true)::Bool |
|
│ %2108 = Base.and_int(%2103, %2107)::Bool |
|
│ %2109 = Base.and_int(%2100, %2108)::Bool |
|
└──── goto #288 if not %2109 |
|
287 ─ goto #289 |
|
288 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2091::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
289 ┄ nothing::Nothing |
|
290 ┄ %2115 = Base.slt_int(5, 0)::Bool |
|
│ %2116 = Base.ifelse(%2115, 0, 5)::Int64 |
|
│ %2117 = Base.slt_int(5, 0)::Bool |
|
│ %2118 = Base.ifelse(%2117, 0, 5)::Int64 |
|
│ %2119 = Base.sub_int(%2116, 0)::Int64 |
|
│ %2120 = Base.mul_int(1, %2119)::Int64 |
|
│ %2121 = Base.sub_int(%34, 1)::Int64 |
|
│ %2122 = Base.mul_int(%2121, 1)::Int64 |
|
│ %2123 = Base.add_int(1, %2122)::Int64 |
|
│ %2124 = Base.sub_int(%2118, 0)::Int64 |
|
│ %2125 = Base.mul_int(%2120, %2124)::Int64 |
|
│ %2126 = Base.sub_int(%28, 1)::Int64 |
|
│ %2127 = Base.mul_int(%2126, %2120)::Int64 |
|
│ %2128 = Base.add_int(%2123, %2127)::Int64 |
|
│ %2129 = Base.sub_int(%2089, 1)::Int64 |
|
│ %2130 = Base.mul_int(%2129, %2125)::Int64 |
|
│ %2131 = Base.add_int(%2128, %2130)::Int64 |
|
└──── goto #295 if not false |
|
291 ─ %2133 = Core.tuple(%2131)::Tuple{Int64} |
|
│ %2134 = Base.mul_int(5, 5)::Int64 |
|
│ %2135 = Base.mul_int(%2134, 5)::Int64 |
|
│ %2136 = Base.slt_int(%2135, 0)::Bool |
|
│ %2137 = Base.ifelse(%2136, 0, %2135)::Int64 |
|
│ %2138 = Base.sle_int(1, %2131)::Bool |
|
│ %2139 = Base.sle_int(%2131, %2137)::Bool |
|
│ %2140 = Base.and_int(%2138, %2139)::Bool |
|
└──── goto #293 if not %2140 |
|
292 ─ goto #294 |
|
293 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2133::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
294 ┄ nothing::Nothing |
|
295 ┄ %2146 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2147 = Base.sub_int(%2131, 1)::Int64 |
|
│ (%2146)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %5, %2088, %2147)::Nothing |
|
└──── goto #296 |
|
296 ─ goto #297 |
|
297 ─ goto #298 |
|
298 ─ %2152 = Base.mul_float(%455, %1988)::Float32 |
|
│ %2153 = Base.mul_float(%563, %1998)::Float32 |
|
│ %2154 = Base.mul_float(%671, %2007)::Float32 |
|
│ %2155 = Base.add_float(%2152, %2153)::Float32 |
|
│ %2156 = Base.add_float(%2155, %2154)::Float32 |
|
│ %2157 = Base.mul_float(%347, %2156)::Float32 |
|
│ %2158 = Main._V::Core.Compiler.Const(3, false) |
|
└──── goto #303 if not false |
|
299 ─ %2160 = Core.tuple(%34, %28, %2158)::Tuple{Int64,Int64,Int64} |
|
│ %2161 = Base.slt_int(5, 0)::Bool |
|
│ %2162 = Base.ifelse(%2161, 0, 5)::Int64 |
|
│ %2163 = Base.slt_int(5, 0)::Bool |
|
│ %2164 = Base.ifelse(%2163, 0, 5)::Int64 |
|
│ %2165 = Base.slt_int(5, 0)::Bool |
|
│ %2166 = Base.ifelse(%2165, 0, 5)::Int64 |
|
│ %2167 = Base.sle_int(1, %34)::Bool |
|
│ %2168 = Base.sle_int(%34, %2162)::Bool |
|
│ %2169 = Base.and_int(%2167, %2168)::Bool |
|
│ %2170 = Base.sle_int(1, %28)::Bool |
|
│ %2171 = Base.sle_int(%28, %2164)::Bool |
|
│ %2172 = Base.and_int(%2170, %2171)::Bool |
|
│ %2173 = Base.sle_int(1, %2158)::Bool |
|
│ %2174 = Base.sle_int(%2158, %2166)::Bool |
|
│ %2175 = Base.and_int(%2173, %2174)::Bool |
|
│ %2176 = Base.and_int(%2175, true)::Bool |
|
│ %2177 = Base.and_int(%2172, %2176)::Bool |
|
│ %2178 = Base.and_int(%2169, %2177)::Bool |
|
└──── goto #301 if not %2178 |
|
300 ─ goto #302 |
|
301 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2160::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
302 ┄ nothing::Nothing |
|
303 ┄ %2184 = Base.slt_int(5, 0)::Bool |
|
│ %2185 = Base.ifelse(%2184, 0, 5)::Int64 |
|
│ %2186 = Base.slt_int(5, 0)::Bool |
|
│ %2187 = Base.ifelse(%2186, 0, 5)::Int64 |
|
│ %2188 = Base.sub_int(%2185, 0)::Int64 |
|
│ %2189 = Base.mul_int(1, %2188)::Int64 |
|
│ %2190 = Base.sub_int(%34, 1)::Int64 |
|
│ %2191 = Base.mul_int(%2190, 1)::Int64 |
|
│ %2192 = Base.add_int(1, %2191)::Int64 |
|
│ %2193 = Base.sub_int(%2187, 0)::Int64 |
|
│ %2194 = Base.mul_int(%2189, %2193)::Int64 |
|
│ %2195 = Base.sub_int(%28, 1)::Int64 |
|
│ %2196 = Base.mul_int(%2195, %2189)::Int64 |
|
│ %2197 = Base.add_int(%2192, %2196)::Int64 |
|
│ %2198 = Base.sub_int(%2158, 1)::Int64 |
|
│ %2199 = Base.mul_int(%2198, %2194)::Int64 |
|
│ %2200 = Base.add_int(%2197, %2199)::Int64 |
|
└──── goto #308 if not false |
|
304 ─ %2202 = Core.tuple(%2200)::Tuple{Int64} |
|
│ %2203 = Base.mul_int(5, 5)::Int64 |
|
│ %2204 = Base.mul_int(%2203, 5)::Int64 |
|
│ %2205 = Base.slt_int(%2204, 0)::Bool |
|
│ %2206 = Base.ifelse(%2205, 0, %2204)::Int64 |
|
│ %2207 = Base.sle_int(1, %2200)::Bool |
|
│ %2208 = Base.sle_int(%2200, %2206)::Bool |
|
│ %2209 = Base.and_int(%2207, %2208)::Bool |
|
└──── goto #306 if not %2209 |
|
305 ─ goto #307 |
|
306 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2202::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
307 ┄ nothing::Nothing |
|
308 ┄ %2215 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2216 = Base.sub_int(%2200, 1)::Int64 |
|
│ (%2215)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %5, %2157, %2216)::Nothing |
|
└──── goto #309 |
|
309 ─ goto #310 |
|
310 ─ goto #311 |
|
311 ─ %2221 = Base.mul_float(%455, %1990)::Float32 |
|
│ %2222 = Base.mul_float(%563, %2000)::Float32 |
|
│ %2223 = Base.mul_float(%671, %2010)::Float32 |
|
│ %2224 = Base.add_float(%2221, %2222)::Float32 |
|
│ %2225 = Base.add_float(%2224, %2223)::Float32 |
|
│ %2226 = Base.mul_float(%347, %2225)::Float32 |
|
│ %2227 = Main._W::Core.Compiler.Const(4, false) |
|
└──── goto #316 if not false |
|
312 ─ %2229 = Core.tuple(%34, %28, %2227)::Tuple{Int64,Int64,Int64} |
|
│ %2230 = Base.slt_int(5, 0)::Bool |
|
│ %2231 = Base.ifelse(%2230, 0, 5)::Int64 |
|
│ %2232 = Base.slt_int(5, 0)::Bool |
|
│ %2233 = Base.ifelse(%2232, 0, 5)::Int64 |
|
│ %2234 = Base.slt_int(5, 0)::Bool |
|
│ %2235 = Base.ifelse(%2234, 0, 5)::Int64 |
|
│ %2236 = Base.sle_int(1, %34)::Bool |
|
│ %2237 = Base.sle_int(%34, %2231)::Bool |
|
│ %2238 = Base.and_int(%2236, %2237)::Bool |
|
│ %2239 = Base.sle_int(1, %28)::Bool |
|
│ %2240 = Base.sle_int(%28, %2233)::Bool |
|
│ %2241 = Base.and_int(%2239, %2240)::Bool |
|
│ %2242 = Base.sle_int(1, %2227)::Bool |
|
│ %2243 = Base.sle_int(%2227, %2235)::Bool |
|
│ %2244 = Base.and_int(%2242, %2243)::Bool |
|
│ %2245 = Base.and_int(%2244, true)::Bool |
|
│ %2246 = Base.and_int(%2241, %2245)::Bool |
|
│ %2247 = Base.and_int(%2238, %2246)::Bool |
|
└──── goto #314 if not %2247 |
|
313 ─ goto #315 |
|
314 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2229::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
315 ┄ nothing::Nothing |
|
316 ┄ %2253 = Base.slt_int(5, 0)::Bool |
|
│ %2254 = Base.ifelse(%2253, 0, 5)::Int64 |
|
│ %2255 = Base.slt_int(5, 0)::Bool |
|
│ %2256 = Base.ifelse(%2255, 0, 5)::Int64 |
|
│ %2257 = Base.sub_int(%2254, 0)::Int64 |
|
│ %2258 = Base.mul_int(1, %2257)::Int64 |
|
│ %2259 = Base.sub_int(%34, 1)::Int64 |
|
│ %2260 = Base.mul_int(%2259, 1)::Int64 |
|
│ %2261 = Base.add_int(1, %2260)::Int64 |
|
│ %2262 = Base.sub_int(%2256, 0)::Int64 |
|
│ %2263 = Base.mul_int(%2258, %2262)::Int64 |
|
│ %2264 = Base.sub_int(%28, 1)::Int64 |
|
│ %2265 = Base.mul_int(%2264, %2258)::Int64 |
|
│ %2266 = Base.add_int(%2261, %2265)::Int64 |
|
│ %2267 = Base.sub_int(%2227, 1)::Int64 |
|
│ %2268 = Base.mul_int(%2267, %2263)::Int64 |
|
│ %2269 = Base.add_int(%2266, %2268)::Int64 |
|
└──── goto #321 if not false |
|
317 ─ %2271 = Core.tuple(%2269)::Tuple{Int64} |
|
│ %2272 = Base.mul_int(5, 5)::Int64 |
|
│ %2273 = Base.mul_int(%2272, 5)::Int64 |
|
│ %2274 = Base.slt_int(%2273, 0)::Bool |
|
│ %2275 = Base.ifelse(%2274, 0, %2273)::Int64 |
|
│ %2276 = Base.sle_int(1, %2269)::Bool |
|
│ %2277 = Base.sle_int(%2269, %2275)::Bool |
|
│ %2278 = Base.and_int(%2276, %2277)::Bool |
|
└──── goto #319 if not %2278 |
|
318 ─ goto #320 |
|
319 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2271::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
320 ┄ nothing::Nothing |
|
321 ┄ %2284 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2285 = Base.sub_int(%2269, 1)::Int64 |
|
│ (%2284)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %5, %2226, %2285)::Nothing |
|
└──── goto #322 |
|
322 ─ goto #323 |
|
323 ─ goto #324 |
|
324 ─ %2290 = Base.mul_float(%455, %1993)::Float32 |
|
│ %2291 = Base.mul_float(%563, %2003)::Float32 |
|
│ %2292 = Base.mul_float(%671, %2013)::Float32 |
|
│ %2293 = Base.add_float(%2290, %2291)::Float32 |
|
│ %2294 = Base.add_float(%2293, %2292)::Float32 |
|
│ %2295 = Base.mul_float(%347, %2294)::Float32 |
|
│ %2296 = Main._E::Core.Compiler.Const(5, false) |
|
└──── goto #329 if not false |
|
325 ─ %2298 = Core.tuple(%34, %28, %2296)::Tuple{Int64,Int64,Int64} |
|
│ %2299 = Base.slt_int(5, 0)::Bool |
|
│ %2300 = Base.ifelse(%2299, 0, 5)::Int64 |
|
│ %2301 = Base.slt_int(5, 0)::Bool |
|
│ %2302 = Base.ifelse(%2301, 0, 5)::Int64 |
|
│ %2303 = Base.slt_int(5, 0)::Bool |
|
│ %2304 = Base.ifelse(%2303, 0, 5)::Int64 |
|
│ %2305 = Base.sle_int(1, %34)::Bool |
|
│ %2306 = Base.sle_int(%34, %2300)::Bool |
|
│ %2307 = Base.and_int(%2305, %2306)::Bool |
|
│ %2308 = Base.sle_int(1, %28)::Bool |
|
│ %2309 = Base.sle_int(%28, %2302)::Bool |
|
│ %2310 = Base.and_int(%2308, %2309)::Bool |
|
│ %2311 = Base.sle_int(1, %2296)::Bool |
|
│ %2312 = Base.sle_int(%2296, %2304)::Bool |
|
│ %2313 = Base.and_int(%2311, %2312)::Bool |
|
│ %2314 = Base.and_int(%2313, true)::Bool |
|
│ %2315 = Base.and_int(%2310, %2314)::Bool |
|
│ %2316 = Base.and_int(%2307, %2315)::Bool |
|
└──── goto #327 if not %2316 |
|
326 ─ goto #328 |
|
327 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2298::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
328 ┄ nothing::Nothing |
|
329 ┄ %2322 = Base.slt_int(5, 0)::Bool |
|
│ %2323 = Base.ifelse(%2322, 0, 5)::Int64 |
|
│ %2324 = Base.slt_int(5, 0)::Bool |
|
│ %2325 = Base.ifelse(%2324, 0, 5)::Int64 |
|
│ %2326 = Base.sub_int(%2323, 0)::Int64 |
|
│ %2327 = Base.mul_int(1, %2326)::Int64 |
|
│ %2328 = Base.sub_int(%34, 1)::Int64 |
|
│ %2329 = Base.mul_int(%2328, 1)::Int64 |
|
│ %2330 = Base.add_int(1, %2329)::Int64 |
|
│ %2331 = Base.sub_int(%2325, 0)::Int64 |
|
│ %2332 = Base.mul_int(%2327, %2331)::Int64 |
|
│ %2333 = Base.sub_int(%28, 1)::Int64 |
|
│ %2334 = Base.mul_int(%2333, %2327)::Int64 |
|
│ %2335 = Base.add_int(%2330, %2334)::Int64 |
|
│ %2336 = Base.sub_int(%2296, 1)::Int64 |
|
│ %2337 = Base.mul_int(%2336, %2332)::Int64 |
|
│ %2338 = Base.add_int(%2335, %2337)::Int64 |
|
└──── goto #334 if not false |
|
330 ─ %2340 = Core.tuple(%2338)::Tuple{Int64} |
|
│ %2341 = Base.mul_int(5, 5)::Int64 |
|
│ %2342 = Base.mul_int(%2341, 5)::Int64 |
|
│ %2343 = Base.slt_int(%2342, 0)::Bool |
|
│ %2344 = Base.ifelse(%2343, 0, %2342)::Int64 |
|
│ %2345 = Base.sle_int(1, %2338)::Bool |
|
│ %2346 = Base.sle_int(%2338, %2344)::Bool |
|
│ %2347 = Base.and_int(%2345, %2346)::Bool |
|
└──── goto #332 if not %2347 |
|
331 ─ goto #333 |
|
332 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2340::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
333 ┄ nothing::Nothing |
|
334 ┄ %2353 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2354 = Base.sub_int(%2338, 1)::Int64 |
|
│ (%2353)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %5, %2295, %2354)::Nothing |
|
└──── goto #335 |
|
335 ─ goto #336 |
|
336 ─ goto #337 |
|
337 ─ %2359 = Base.mul_float(%779, %1535)::Float32 |
|
│ %2360 = Base.mul_float(%887, %1643)::Float32 |
|
│ %2361 = Base.mul_float(%995, %1751)::Float32 |
|
│ %2362 = Base.add_float(%2359, %2360)::Float32 |
|
│ %2363 = Base.add_float(%2362, %2361)::Float32 |
|
│ %2364 = Base.mul_float(%347, %2363)::Float32 |
|
│ %2365 = Main._ρ::Core.Compiler.Const(1, false) |
|
└──── goto #342 if not false |
|
338 ─ %2367 = Core.tuple(%34, %28, %2365)::Tuple{Int64,Int64,Int64} |
|
│ %2368 = Base.slt_int(5, 0)::Bool |
|
│ %2369 = Base.ifelse(%2368, 0, 5)::Int64 |
|
│ %2370 = Base.slt_int(5, 0)::Bool |
|
│ %2371 = Base.ifelse(%2370, 0, 5)::Int64 |
|
│ %2372 = Base.slt_int(5, 0)::Bool |
|
│ %2373 = Base.ifelse(%2372, 0, 5)::Int64 |
|
│ %2374 = Base.sle_int(1, %34)::Bool |
|
│ %2375 = Base.sle_int(%34, %2369)::Bool |
|
│ %2376 = Base.and_int(%2374, %2375)::Bool |
|
│ %2377 = Base.sle_int(1, %28)::Bool |
|
│ %2378 = Base.sle_int(%28, %2371)::Bool |
|
│ %2379 = Base.and_int(%2377, %2378)::Bool |
|
│ %2380 = Base.sle_int(1, %2365)::Bool |
|
│ %2381 = Base.sle_int(%2365, %2373)::Bool |
|
│ %2382 = Base.and_int(%2380, %2381)::Bool |
|
│ %2383 = Base.and_int(%2382, true)::Bool |
|
│ %2384 = Base.and_int(%2379, %2383)::Bool |
|
│ %2385 = Base.and_int(%2376, %2384)::Bool |
|
└──── goto #340 if not %2385 |
|
339 ─ goto #341 |
|
340 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2367::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
341 ┄ nothing::Nothing |
|
342 ┄ %2391 = Base.slt_int(5, 0)::Bool |
|
│ %2392 = Base.ifelse(%2391, 0, 5)::Int64 |
|
│ %2393 = Base.slt_int(5, 0)::Bool |
|
│ %2394 = Base.ifelse(%2393, 0, 5)::Int64 |
|
│ %2395 = Base.sub_int(%2392, 0)::Int64 |
|
│ %2396 = Base.mul_int(1, %2395)::Int64 |
|
│ %2397 = Base.sub_int(%34, 1)::Int64 |
|
│ %2398 = Base.mul_int(%2397, 1)::Int64 |
|
│ %2399 = Base.add_int(1, %2398)::Int64 |
|
│ %2400 = Base.sub_int(%2394, 0)::Int64 |
|
│ %2401 = Base.mul_int(%2396, %2400)::Int64 |
|
│ %2402 = Base.sub_int(%28, 1)::Int64 |
|
│ %2403 = Base.mul_int(%2402, %2396)::Int64 |
|
│ %2404 = Base.add_int(%2399, %2403)::Int64 |
|
│ %2405 = Base.sub_int(%2365, 1)::Int64 |
|
│ %2406 = Base.mul_int(%2405, %2401)::Int64 |
|
│ %2407 = Base.add_int(%2404, %2406)::Int64 |
|
└──── goto #347 if not false |
|
343 ─ %2409 = Core.tuple(%2407)::Tuple{Int64} |
|
│ %2410 = Base.mul_int(5, 5)::Int64 |
|
│ %2411 = Base.mul_int(%2410, 5)::Int64 |
|
│ %2412 = Base.slt_int(%2411, 0)::Bool |
|
│ %2413 = Base.ifelse(%2412, 0, %2411)::Int64 |
|
│ %2414 = Base.sle_int(1, %2407)::Bool |
|
│ %2415 = Base.sle_int(%2407, %2413)::Bool |
|
│ %2416 = Base.and_int(%2414, %2415)::Bool |
|
└──── goto #345 if not %2416 |
|
344 ─ goto #346 |
|
345 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2409::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
346 ┄ nothing::Nothing |
|
347 ┄ %2422 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2423 = Base.sub_int(%2407, 1)::Int64 |
|
│ (%2422)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %8, %2364, %2423)::Nothing |
|
└──── goto #348 |
|
348 ─ goto #349 |
|
349 ─ goto #350 |
|
350 ─ %2428 = Base.mul_float(%779, %1986)::Float32 |
|
│ %2429 = Base.mul_float(%887, %1995)::Float32 |
|
│ %2430 = Base.mul_float(%995, %2005)::Float32 |
|
│ %2431 = Base.add_float(%2428, %2429)::Float32 |
|
│ %2432 = Base.add_float(%2431, %2430)::Float32 |
|
│ %2433 = Base.mul_float(%347, %2432)::Float32 |
|
│ %2434 = Main._U::Core.Compiler.Const(2, false) |
|
└──── goto #355 if not false |
|
351 ─ %2436 = Core.tuple(%34, %28, %2434)::Tuple{Int64,Int64,Int64} |
|
│ %2437 = Base.slt_int(5, 0)::Bool |
|
│ %2438 = Base.ifelse(%2437, 0, 5)::Int64 |
|
│ %2439 = Base.slt_int(5, 0)::Bool |
|
│ %2440 = Base.ifelse(%2439, 0, 5)::Int64 |
|
│ %2441 = Base.slt_int(5, 0)::Bool |
|
│ %2442 = Base.ifelse(%2441, 0, 5)::Int64 |
|
│ %2443 = Base.sle_int(1, %34)::Bool |
|
│ %2444 = Base.sle_int(%34, %2438)::Bool |
|
│ %2445 = Base.and_int(%2443, %2444)::Bool |
|
│ %2446 = Base.sle_int(1, %28)::Bool |
|
│ %2447 = Base.sle_int(%28, %2440)::Bool |
|
│ %2448 = Base.and_int(%2446, %2447)::Bool |
|
│ %2449 = Base.sle_int(1, %2434)::Bool |
|
│ %2450 = Base.sle_int(%2434, %2442)::Bool |
|
│ %2451 = Base.and_int(%2449, %2450)::Bool |
|
│ %2452 = Base.and_int(%2451, true)::Bool |
|
│ %2453 = Base.and_int(%2448, %2452)::Bool |
|
│ %2454 = Base.and_int(%2445, %2453)::Bool |
|
└──── goto #353 if not %2454 |
|
352 ─ goto #354 |
|
353 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2436::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
354 ┄ nothing::Nothing |
|
355 ┄ %2460 = Base.slt_int(5, 0)::Bool |
|
│ %2461 = Base.ifelse(%2460, 0, 5)::Int64 |
|
│ %2462 = Base.slt_int(5, 0)::Bool |
|
│ %2463 = Base.ifelse(%2462, 0, 5)::Int64 |
|
│ %2464 = Base.sub_int(%2461, 0)::Int64 |
|
│ %2465 = Base.mul_int(1, %2464)::Int64 |
|
│ %2466 = Base.sub_int(%34, 1)::Int64 |
|
│ %2467 = Base.mul_int(%2466, 1)::Int64 |
|
│ %2468 = Base.add_int(1, %2467)::Int64 |
|
│ %2469 = Base.sub_int(%2463, 0)::Int64 |
|
│ %2470 = Base.mul_int(%2465, %2469)::Int64 |
|
│ %2471 = Base.sub_int(%28, 1)::Int64 |
|
│ %2472 = Base.mul_int(%2471, %2465)::Int64 |
|
│ %2473 = Base.add_int(%2468, %2472)::Int64 |
|
│ %2474 = Base.sub_int(%2434, 1)::Int64 |
|
│ %2475 = Base.mul_int(%2474, %2470)::Int64 |
|
│ %2476 = Base.add_int(%2473, %2475)::Int64 |
|
└──── goto #360 if not false |
|
356 ─ %2478 = Core.tuple(%2476)::Tuple{Int64} |
|
│ %2479 = Base.mul_int(5, 5)::Int64 |
|
│ %2480 = Base.mul_int(%2479, 5)::Int64 |
|
│ %2481 = Base.slt_int(%2480, 0)::Bool |
|
│ %2482 = Base.ifelse(%2481, 0, %2480)::Int64 |
|
│ %2483 = Base.sle_int(1, %2476)::Bool |
|
│ %2484 = Base.sle_int(%2476, %2482)::Bool |
|
│ %2485 = Base.and_int(%2483, %2484)::Bool |
|
└──── goto #358 if not %2485 |
|
357 ─ goto #359 |
|
358 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2478::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
359 ┄ nothing::Nothing |
|
360 ┄ %2491 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2492 = Base.sub_int(%2476, 1)::Int64 |
|
│ (%2491)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %8, %2433, %2492)::Nothing |
|
└──── goto #361 |
|
361 ─ goto #362 |
|
362 ─ goto #363 |
|
363 ─ %2497 = Base.mul_float(%779, %1988)::Float32 |
|
│ %2498 = Base.mul_float(%887, %1998)::Float32 |
|
│ %2499 = Base.mul_float(%995, %2007)::Float32 |
|
│ %2500 = Base.add_float(%2497, %2498)::Float32 |
|
│ %2501 = Base.add_float(%2500, %2499)::Float32 |
|
│ %2502 = Base.mul_float(%347, %2501)::Float32 |
|
│ %2503 = Main._V::Core.Compiler.Const(3, false) |
|
└──── goto #368 if not false |
|
364 ─ %2505 = Core.tuple(%34, %28, %2503)::Tuple{Int64,Int64,Int64} |
|
│ %2506 = Base.slt_int(5, 0)::Bool |
|
│ %2507 = Base.ifelse(%2506, 0, 5)::Int64 |
|
│ %2508 = Base.slt_int(5, 0)::Bool |
|
│ %2509 = Base.ifelse(%2508, 0, 5)::Int64 |
|
│ %2510 = Base.slt_int(5, 0)::Bool |
|
│ %2511 = Base.ifelse(%2510, 0, 5)::Int64 |
|
│ %2512 = Base.sle_int(1, %34)::Bool |
|
│ %2513 = Base.sle_int(%34, %2507)::Bool |
|
│ %2514 = Base.and_int(%2512, %2513)::Bool |
|
│ %2515 = Base.sle_int(1, %28)::Bool |
|
│ %2516 = Base.sle_int(%28, %2509)::Bool |
|
│ %2517 = Base.and_int(%2515, %2516)::Bool |
|
│ %2518 = Base.sle_int(1, %2503)::Bool |
|
│ %2519 = Base.sle_int(%2503, %2511)::Bool |
|
│ %2520 = Base.and_int(%2518, %2519)::Bool |
|
│ %2521 = Base.and_int(%2520, true)::Bool |
|
│ %2522 = Base.and_int(%2517, %2521)::Bool |
|
│ %2523 = Base.and_int(%2514, %2522)::Bool |
|
└──── goto #366 if not %2523 |
|
365 ─ goto #367 |
|
366 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2505::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
367 ┄ nothing::Nothing |
|
368 ┄ %2529 = Base.slt_int(5, 0)::Bool |
|
│ %2530 = Base.ifelse(%2529, 0, 5)::Int64 |
|
│ %2531 = Base.slt_int(5, 0)::Bool |
|
│ %2532 = Base.ifelse(%2531, 0, 5)::Int64 |
|
│ %2533 = Base.sub_int(%2530, 0)::Int64 |
|
│ %2534 = Base.mul_int(1, %2533)::Int64 |
|
│ %2535 = Base.sub_int(%34, 1)::Int64 |
|
│ %2536 = Base.mul_int(%2535, 1)::Int64 |
|
│ %2537 = Base.add_int(1, %2536)::Int64 |
|
│ %2538 = Base.sub_int(%2532, 0)::Int64 |
|
│ %2539 = Base.mul_int(%2534, %2538)::Int64 |
|
│ %2540 = Base.sub_int(%28, 1)::Int64 |
|
│ %2541 = Base.mul_int(%2540, %2534)::Int64 |
|
│ %2542 = Base.add_int(%2537, %2541)::Int64 |
|
│ %2543 = Base.sub_int(%2503, 1)::Int64 |
|
│ %2544 = Base.mul_int(%2543, %2539)::Int64 |
|
│ %2545 = Base.add_int(%2542, %2544)::Int64 |
|
└──── goto #373 if not false |
|
369 ─ %2547 = Core.tuple(%2545)::Tuple{Int64} |
|
│ %2548 = Base.mul_int(5, 5)::Int64 |
|
│ %2549 = Base.mul_int(%2548, 5)::Int64 |
|
│ %2550 = Base.slt_int(%2549, 0)::Bool |
|
│ %2551 = Base.ifelse(%2550, 0, %2549)::Int64 |
|
│ %2552 = Base.sle_int(1, %2545)::Bool |
|
│ %2553 = Base.sle_int(%2545, %2551)::Bool |
|
│ %2554 = Base.and_int(%2552, %2553)::Bool |
|
└──── goto #371 if not %2554 |
|
370 ─ goto #372 |
|
371 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2547::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
372 ┄ nothing::Nothing |
|
373 ┄ %2560 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2561 = Base.sub_int(%2545, 1)::Int64 |
|
│ (%2560)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %8, %2502, %2561)::Nothing |
|
└──── goto #374 |
|
374 ─ goto #375 |
|
375 ─ goto #376 |
|
376 ─ %2566 = Base.mul_float(%779, %1990)::Float32 |
|
│ %2567 = Base.mul_float(%887, %2000)::Float32 |
|
│ %2568 = Base.mul_float(%995, %2010)::Float32 |
|
│ %2569 = Base.add_float(%2566, %2567)::Float32 |
|
│ %2570 = Base.add_float(%2569, %2568)::Float32 |
|
│ %2571 = Base.mul_float(%347, %2570)::Float32 |
|
│ %2572 = Main._W::Core.Compiler.Const(4, false) |
|
└──── goto #381 if not false |
|
377 ─ %2574 = Core.tuple(%34, %28, %2572)::Tuple{Int64,Int64,Int64} |
|
│ %2575 = Base.slt_int(5, 0)::Bool |
|
│ %2576 = Base.ifelse(%2575, 0, 5)::Int64 |
|
│ %2577 = Base.slt_int(5, 0)::Bool |
|
│ %2578 = Base.ifelse(%2577, 0, 5)::Int64 |
|
│ %2579 = Base.slt_int(5, 0)::Bool |
|
│ %2580 = Base.ifelse(%2579, 0, 5)::Int64 |
|
│ %2581 = Base.sle_int(1, %34)::Bool |
|
│ %2582 = Base.sle_int(%34, %2576)::Bool |
|
│ %2583 = Base.and_int(%2581, %2582)::Bool |
|
│ %2584 = Base.sle_int(1, %28)::Bool |
|
│ %2585 = Base.sle_int(%28, %2578)::Bool |
|
│ %2586 = Base.and_int(%2584, %2585)::Bool |
|
│ %2587 = Base.sle_int(1, %2572)::Bool |
|
│ %2588 = Base.sle_int(%2572, %2580)::Bool |
|
│ %2589 = Base.and_int(%2587, %2588)::Bool |
|
│ %2590 = Base.and_int(%2589, true)::Bool |
|
│ %2591 = Base.and_int(%2586, %2590)::Bool |
|
│ %2592 = Base.and_int(%2583, %2591)::Bool |
|
└──── goto #379 if not %2592 |
|
378 ─ goto #380 |
|
379 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2574::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
380 ┄ nothing::Nothing |
|
381 ┄ %2598 = Base.slt_int(5, 0)::Bool |
|
│ %2599 = Base.ifelse(%2598, 0, 5)::Int64 |
|
│ %2600 = Base.slt_int(5, 0)::Bool |
|
│ %2601 = Base.ifelse(%2600, 0, 5)::Int64 |
|
│ %2602 = Base.sub_int(%2599, 0)::Int64 |
|
│ %2603 = Base.mul_int(1, %2602)::Int64 |
|
│ %2604 = Base.sub_int(%34, 1)::Int64 |
|
│ %2605 = Base.mul_int(%2604, 1)::Int64 |
|
│ %2606 = Base.add_int(1, %2605)::Int64 |
|
│ %2607 = Base.sub_int(%2601, 0)::Int64 |
|
│ %2608 = Base.mul_int(%2603, %2607)::Int64 |
|
│ %2609 = Base.sub_int(%28, 1)::Int64 |
|
│ %2610 = Base.mul_int(%2609, %2603)::Int64 |
|
│ %2611 = Base.add_int(%2606, %2610)::Int64 |
|
│ %2612 = Base.sub_int(%2572, 1)::Int64 |
|
│ %2613 = Base.mul_int(%2612, %2608)::Int64 |
|
│ %2614 = Base.add_int(%2611, %2613)::Int64 |
|
└──── goto #386 if not false |
|
382 ─ %2616 = Core.tuple(%2614)::Tuple{Int64} |
|
│ %2617 = Base.mul_int(5, 5)::Int64 |
|
│ %2618 = Base.mul_int(%2617, 5)::Int64 |
|
│ %2619 = Base.slt_int(%2618, 0)::Bool |
|
│ %2620 = Base.ifelse(%2619, 0, %2618)::Int64 |
|
│ %2621 = Base.sle_int(1, %2614)::Bool |
|
│ %2622 = Base.sle_int(%2614, %2620)::Bool |
|
│ %2623 = Base.and_int(%2621, %2622)::Bool |
|
└──── goto #384 if not %2623 |
|
383 ─ goto #385 |
|
384 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2616::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
385 ┄ nothing::Nothing |
|
386 ┄ %2629 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2630 = Base.sub_int(%2614, 1)::Int64 |
|
│ (%2629)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %8, %2571, %2630)::Nothing |
|
└──── goto #387 |
|
387 ─ goto #388 |
|
388 ─ goto #389 |
|
389 ─ %2635 = Base.mul_float(%779, %1993)::Float32 |
|
│ %2636 = Base.mul_float(%887, %2003)::Float32 |
|
│ %2637 = Base.mul_float(%995, %2013)::Float32 |
|
│ %2638 = Base.add_float(%2635, %2636)::Float32 |
|
│ %2639 = Base.add_float(%2638, %2637)::Float32 |
|
│ %2640 = Base.mul_float(%347, %2639)::Float32 |
|
│ %2641 = Main._E::Core.Compiler.Const(5, false) |
|
└──── goto #394 if not false |
|
390 ─ %2643 = Core.tuple(%34, %28, %2641)::Tuple{Int64,Int64,Int64} |
|
│ %2644 = Base.slt_int(5, 0)::Bool |
|
│ %2645 = Base.ifelse(%2644, 0, 5)::Int64 |
|
│ %2646 = Base.slt_int(5, 0)::Bool |
|
│ %2647 = Base.ifelse(%2646, 0, 5)::Int64 |
|
│ %2648 = Base.slt_int(5, 0)::Bool |
|
│ %2649 = Base.ifelse(%2648, 0, 5)::Int64 |
|
│ %2650 = Base.sle_int(1, %34)::Bool |
|
│ %2651 = Base.sle_int(%34, %2645)::Bool |
|
│ %2652 = Base.and_int(%2650, %2651)::Bool |
|
│ %2653 = Base.sle_int(1, %28)::Bool |
|
│ %2654 = Base.sle_int(%28, %2647)::Bool |
|
│ %2655 = Base.and_int(%2653, %2654)::Bool |
|
│ %2656 = Base.sle_int(1, %2641)::Bool |
|
│ %2657 = Base.sle_int(%2641, %2649)::Bool |
|
│ %2658 = Base.and_int(%2656, %2657)::Bool |
|
│ %2659 = Base.and_int(%2658, true)::Bool |
|
│ %2660 = Base.and_int(%2655, %2659)::Bool |
|
│ %2661 = Base.and_int(%2652, %2660)::Bool |
|
└──── goto #392 if not %2661 |
|
391 ─ goto #393 |
|
392 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2643::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
393 ┄ nothing::Nothing |
|
394 ┄ %2667 = Base.slt_int(5, 0)::Bool |
|
│ %2668 = Base.ifelse(%2667, 0, 5)::Int64 |
|
│ %2669 = Base.slt_int(5, 0)::Bool |
|
│ %2670 = Base.ifelse(%2669, 0, 5)::Int64 |
|
│ %2671 = Base.sub_int(%2668, 0)::Int64 |
|
│ %2672 = Base.mul_int(1, %2671)::Int64 |
|
│ %2673 = Base.sub_int(%34, 1)::Int64 |
|
│ %2674 = Base.mul_int(%2673, 1)::Int64 |
|
│ %2675 = Base.add_int(1, %2674)::Int64 |
|
│ %2676 = Base.sub_int(%2670, 0)::Int64 |
|
│ %2677 = Base.mul_int(%2672, %2676)::Int64 |
|
│ %2678 = Base.sub_int(%28, 1)::Int64 |
|
│ %2679 = Base.mul_int(%2678, %2672)::Int64 |
|
│ %2680 = Base.add_int(%2675, %2679)::Int64 |
|
│ %2681 = Base.sub_int(%2641, 1)::Int64 |
|
│ %2682 = Base.mul_int(%2681, %2677)::Int64 |
|
│ %2683 = Base.add_int(%2680, %2682)::Int64 |
|
└──── goto #399 if not false |
|
395 ─ %2685 = Core.tuple(%2683)::Tuple{Int64} |
|
│ %2686 = Base.mul_int(5, 5)::Int64 |
|
│ %2687 = Base.mul_int(%2686, 5)::Int64 |
|
│ %2688 = Base.slt_int(%2687, 0)::Bool |
|
│ %2689 = Base.ifelse(%2688, 0, %2687)::Int64 |
|
│ %2690 = Base.sle_int(1, %2683)::Bool |
|
│ %2691 = Base.sle_int(%2683, %2689)::Bool |
|
│ %2692 = Base.and_int(%2690, %2691)::Bool |
|
└──── goto #397 if not %2692 |
|
396 ─ goto #398 |
|
397 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %2685::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
398 ┄ nothing::Nothing |
|
399 ┄ %2698 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2699 = Base.sub_int(%2683, 1)::Int64 |
|
│ (%2698)($(QuoteNode(Ptr{Nothing} @0x000000000492e818)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Float32,Int64}, %8, %2640, %2699)::Nothing |
|
└──── goto #400 |
|
400 ─ goto #401 |
|
401 ─ goto #402 |
|
402 ─ %2704 = Base.mul_float(%1103, %1535)::Float32 |
|
│ %2705 = Base.mul_float(%1211, %1643)::Float32 |
|
│ %2706 = Base.mul_float(%1319, %1751)::Float32 |
|
│ %2707 = Base.add_float(%2704, %2705)::Float32 |
|
│ %2708 = Base.add_float(%2707, %2706)::Float32 |
|
│ %2709 = Base.mul_float(%347, %2708)::Float32 |
|
│ %2710 = Base.mul_float(%1103, %1986)::Float32 |
|
│ %2711 = Base.mul_float(%1211, %1995)::Float32 |
|
│ %2712 = Base.mul_float(%1319, %2005)::Float32 |
|
│ %2713 = Base.add_float(%2710, %2711)::Float32 |
|
│ %2714 = Base.add_float(%2713, %2712)::Float32 |
|
│ %2715 = Base.mul_float(%347, %2714)::Float32 |
|
│ %2716 = Base.mul_float(%1103, %1988)::Float32 |
|
│ %2717 = Base.mul_float(%1211, %1998)::Float32 |
|
│ %2718 = Base.mul_float(%1319, %2007)::Float32 |
|
│ %2719 = Base.add_float(%2716, %2717)::Float32 |
|
│ %2720 = Base.add_float(%2719, %2718)::Float32 |
|
│ %2721 = Base.mul_float(%347, %2720)::Float32 |
|
│ %2722 = Base.mul_float(%1103, %1990)::Float32 |
|
│ %2723 = Base.mul_float(%1211, %2000)::Float32 |
|
│ %2724 = Base.mul_float(%1319, %2010)::Float32 |
|
│ %2725 = Base.add_float(%2722, %2723)::Float32 |
|
│ %2726 = Base.add_float(%2725, %2724)::Float32 |
|
│ %2727 = Base.mul_float(%347, %2726)::Float32 |
|
│ %2728 = Base.mul_float(%1103, %1993)::Float32 |
|
│ %2729 = Base.mul_float(%1211, %2003)::Float32 |
|
│ %2730 = Base.mul_float(%1319, %2013)::Float32 |
|
│ %2731 = Base.add_float(%2728, %2729)::Float32 |
|
│ %2732 = Base.add_float(%2731, %2730)::Float32 |
|
│ %2733 = Base.mul_float(%347, %2732)::Float32 |
|
└──── goto #481 if not true |
|
403 ┄ %2735 = φ (#402 => 1, #480 => %2957)::Int64 |
|
│ %2736 = φ (#402 => 1, #480 => %2958)::Int64 |
|
└──── goto #408 if not false |
|
404 ─ %2738 = Core.tuple(%240, %2735)::Tuple{Int64,Int64} |
|
│ %2739 = Base.slt_int(5, 0)::Bool |
|
│ %2740 = Base.ifelse(%2739, 0, 5)::Int64 |
|
│ %2741 = Base.slt_int(5, 0)::Bool |
|
│ %2742 = Base.ifelse(%2741, 0, 5)::Int64 |
|
│ %2743 = Base.sle_int(1, %240)::Bool |
|
│ %2744 = Base.sle_int(%240, %2740)::Bool |
|
│ %2745 = Base.and_int(%2743, %2744)::Bool |
|
│ %2746 = Base.sle_int(1, %2735)::Bool |
|
│ %2747 = Base.sle_int(%2735, %2742)::Bool |
|
│ %2748 = Base.and_int(%2746, %2747)::Bool |
|
│ %2749 = Base.and_int(%2748, true)::Bool |
|
│ %2750 = Base.and_int(%2745, %2749)::Bool |
|
└──── goto #406 if not %2750 |
|
405 ─ goto #407 |
|
406 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %2738::Tuple{Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
407 ┄ nothing::Nothing |
|
408 ┄ %2756 = Base.sub_int(%240, 1)::Int64 |
|
│ %2757 = Base.mul_int(%2756, 1)::Int64 |
|
│ %2758 = Base.add_int(1, %2757)::Int64 |
|
│ %2759 = Base.sub_int(%2735, 1)::Int64 |
|
│ %2760 = Base.mul_int(%2759, 5)::Int64 |
|
│ %2761 = Base.add_int(%2758, %2760)::Int64 |
|
└──── goto #413 if not false |
|
409 ─ %2763 = Core.tuple(%2761)::Tuple{Int64} |
|
│ %2764 = Base.mul_int(5, 5)::Int64 |
|
│ %2765 = Base.slt_int(%2764, 0)::Bool |
|
│ %2766 = Base.ifelse(%2765, 0, %2764)::Int64 |
|
│ %2767 = Base.sle_int(1, %2761)::Bool |
|
│ %2768 = Base.sle_int(%2761, %2766)::Bool |
|
│ %2769 = Base.and_int(%2767, %2768)::Bool |
|
└──── goto #411 if not %2769 |
|
410 ─ goto #412 |
|
411 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %2763::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
412 ┄ nothing::Nothing |
|
413 ┄ %2775 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %2776 = Base.sub_int(%2761, 1)::Int64 |
|
│ %2777 = (%2775)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %2, %2776)::Float32 |
|
└──── goto #414 |
|
414 ─ goto #415 |
|
415 ─ goto #416 |
|
416 ─ goto #421 if not false |
|
417 ─ %2782 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2783 = Base.sle_int(1, %2735)::Bool |
|
│ %2784 = Base.sle_int(%2735, 5)::Bool |
|
│ %2785 = Base.and_int(%2783, %2784)::Bool |
|
└──── goto #419 if not %2785 |
|
418 ─ goto #420 |
|
419 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %2782::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
420 ┄ nothing::Nothing |
|
421 ┄ %2791 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %2792 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %2793 = Base.bitcast(Ptr{Float32}, %2792)::Ptr{Float32} |
|
│ %2794 = Base.pointerref(%2793, %2735, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2791))) |
|
└──── goto #422 |
|
422 ─ %2797 = Base.mul_float(%2777, %2709)::Float32 |
|
│ %2798 = Base.add_float(%2794, %2797)::Float32 |
|
└──── goto #427 if not false |
|
423 ─ %2800 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2801 = Base.sle_int(1, %2735)::Bool |
|
│ %2802 = Base.sle_int(%2735, 5)::Bool |
|
│ %2803 = Base.and_int(%2801, %2802)::Bool |
|
└──── goto #425 if not %2803 |
|
424 ─ goto #426 |
|
425 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %2800::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
426 ┄ nothing::Nothing |
|
427 ┄ %2809 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %2810 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %2811 = Base.bitcast(Ptr{Float32}, %2810)::Ptr{Float32} |
|
│ Base.pointerset(%2811, %2798, %2735, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2809))) |
|
└──── goto #428 |
|
428 ─ goto #433 if not false |
|
429 ─ %2816 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2817 = Base.sle_int(1, %2735)::Bool |
|
│ %2818 = Base.sle_int(%2735, 5)::Bool |
|
│ %2819 = Base.and_int(%2817, %2818)::Bool |
|
└──── goto #431 if not %2819 |
|
430 ─ goto #432 |
|
431 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %2816::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
432 ┄ nothing::Nothing |
|
433 ┄ %2825 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %2826 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %2827 = Base.bitcast(Ptr{Float32}, %2826)::Ptr{Float32} |
|
│ %2828 = Base.pointerref(%2827, %2735, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2825))) |
|
└──── goto #434 |
|
434 ─ %2831 = Base.mul_float(%2777, %2715)::Float32 |
|
│ %2832 = Base.add_float(%2828, %2831)::Float32 |
|
└──── goto #439 if not false |
|
435 ─ %2834 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2835 = Base.sle_int(1, %2735)::Bool |
|
│ %2836 = Base.sle_int(%2735, 5)::Bool |
|
│ %2837 = Base.and_int(%2835, %2836)::Bool |
|
└──── goto #437 if not %2837 |
|
436 ─ goto #438 |
|
437 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %2834::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
438 ┄ nothing::Nothing |
|
439 ┄ %2843 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %2844 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %2845 = Base.bitcast(Ptr{Float32}, %2844)::Ptr{Float32} |
|
│ Base.pointerset(%2845, %2832, %2735, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2843))) |
|
└──── goto #440 |
|
440 ─ goto #445 if not false |
|
441 ─ %2850 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2851 = Base.sle_int(1, %2735)::Bool |
|
│ %2852 = Base.sle_int(%2735, 5)::Bool |
|
│ %2853 = Base.and_int(%2851, %2852)::Bool |
|
└──── goto #443 if not %2853 |
|
442 ─ goto #444 |
|
443 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %2850::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
444 ┄ nothing::Nothing |
|
445 ┄ %2859 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %2860 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %2861 = Base.bitcast(Ptr{Float32}, %2860)::Ptr{Float32} |
|
│ %2862 = Base.pointerref(%2861, %2735, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2859))) |
|
└──── goto #446 |
|
446 ─ %2865 = Base.mul_float(%2777, %2721)::Float32 |
|
│ %2866 = Base.add_float(%2862, %2865)::Float32 |
|
└──── goto #451 if not false |
|
447 ─ %2868 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2869 = Base.sle_int(1, %2735)::Bool |
|
│ %2870 = Base.sle_int(%2735, 5)::Bool |
|
│ %2871 = Base.and_int(%2869, %2870)::Bool |
|
└──── goto #449 if not %2871 |
|
448 ─ goto #450 |
|
449 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %2868::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
450 ┄ nothing::Nothing |
|
451 ┄ %2877 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %2878 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %2879 = Base.bitcast(Ptr{Float32}, %2878)::Ptr{Float32} |
|
│ Base.pointerset(%2879, %2866, %2735, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2877))) |
|
└──── goto #452 |
|
452 ─ goto #457 if not false |
|
453 ─ %2884 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2885 = Base.sle_int(1, %2735)::Bool |
|
│ %2886 = Base.sle_int(%2735, 5)::Bool |
|
│ %2887 = Base.and_int(%2885, %2886)::Bool |
|
└──── goto #455 if not %2887 |
|
454 ─ goto #456 |
|
455 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %2884::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
456 ┄ nothing::Nothing |
|
457 ┄ %2893 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %2894 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %2895 = Base.bitcast(Ptr{Float32}, %2894)::Ptr{Float32} |
|
│ %2896 = Base.pointerref(%2895, %2735, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2893))) |
|
└──── goto #458 |
|
458 ─ %2899 = Base.mul_float(%2777, %2727)::Float32 |
|
│ %2900 = Base.add_float(%2896, %2899)::Float32 |
|
└──── goto #463 if not false |
|
459 ─ %2902 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2903 = Base.sle_int(1, %2735)::Bool |
|
│ %2904 = Base.sle_int(%2735, 5)::Bool |
|
│ %2905 = Base.and_int(%2903, %2904)::Bool |
|
└──── goto #461 if not %2905 |
|
460 ─ goto #462 |
|
461 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %2902::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
462 ┄ nothing::Nothing |
|
463 ┄ %2911 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %2912 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %2913 = Base.bitcast(Ptr{Float32}, %2912)::Ptr{Float32} |
|
│ Base.pointerset(%2913, %2900, %2735, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2911))) |
|
└──── goto #464 |
|
464 ─ goto #469 if not false |
|
465 ─ %2918 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2919 = Base.sle_int(1, %2735)::Bool |
|
│ %2920 = Base.sle_int(%2735, 5)::Bool |
|
│ %2921 = Base.and_int(%2919, %2920)::Bool |
|
└──── goto #467 if not %2921 |
|
466 ─ goto #468 |
|
467 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %2918::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
468 ┄ nothing::Nothing |
|
469 ┄ %2927 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %2928 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %2929 = Base.bitcast(Ptr{Float32}, %2928)::Ptr{Float32} |
|
│ %2930 = Base.pointerref(%2929, %2735, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2927))) |
|
└──── goto #470 |
|
470 ─ %2933 = Base.mul_float(%2777, %2733)::Float32 |
|
│ %2934 = Base.add_float(%2930, %2933)::Float32 |
|
└──── goto #475 if not false |
|
471 ─ %2936 = Core.tuple(%2735)::Tuple{Int64} |
|
│ %2937 = Base.sle_int(1, %2735)::Bool |
|
│ %2938 = Base.sle_int(%2735, 5)::Bool |
|
│ %2939 = Base.and_int(%2937, %2938)::Bool |
|
└──── goto #473 if not %2939 |
|
472 ─ goto #474 |
|
473 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %2936::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
474 ┄ nothing::Nothing |
|
475 ┄ %2945 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %2946 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %2947 = Base.bitcast(Ptr{Float32}, %2946)::Ptr{Float32} |
|
│ Base.pointerset(%2947, %2934, %2735, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2945))) |
|
└──── goto #476 |
|
476 ─ $(Expr(:loopinfo, (Symbol("llvm.loop.unroll.full"), 1)))::Any |
|
│ %2952 = (%2736 === 5)::Bool |
|
└──── goto #478 if not %2952 |
|
477 ─ goto #479 |
|
478 ─ %2955 = Base.add_int(%2736, 1)::Int64 |
|
└──── goto #479 |
|
479 ┄ %2957 = φ (#478 => %2955)::Int64 |
|
│ %2958 = φ (#478 => %2955)::Int64 |
|
│ %2959 = φ (#477 => true, #478 => false)::Bool |
|
│ %2960 = Base.not_int(%2959)::Bool |
|
└──── goto #481 if not %2960 |
|
480 ─ goto #403 |
|
481 ┄ goto #486 if not false |
|
482 ─ %2964 = Core.tuple(%240)::Tuple{Int64} |
|
│ %2965 = Base.sle_int(1, %240)::Bool |
|
│ %2966 = Base.sle_int(%240, 5)::Bool |
|
│ %2967 = Base.and_int(%2965, %2966)::Bool |
|
└──── goto #484 if not %2967 |
|
483 ─ goto #485 |
|
484 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %2964::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
485 ┄ nothing::Nothing |
|
486 ┄ %2973 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %2974 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %2975 = Base.bitcast(Ptr{Float32}, %2974)::Ptr{Float32} |
|
│ %2976 = Base.pointerref(%2975, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%2973))) |
|
└──── goto #487 |
|
487 ─ %2979 = Base.mul_float(%347, %1859)::Float32 |
|
│ %2980 = Base.mul_float(%2979, gravity)::Float32 |
|
│ %2981 = Base.sub_float(%2976, %2980)::Float32 |
|
└──── goto #492 if not false |
|
488 ─ %2983 = Core.tuple(%240)::Tuple{Int64} |
|
│ %2984 = Base.sle_int(1, %240)::Bool |
|
│ %2985 = Base.sle_int(%240, 5)::Bool |
|
│ %2986 = Base.and_int(%2984, %2985)::Bool |
|
└──── goto #490 if not %2986 |
|
489 ─ goto #491 |
|
490 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %2983::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
491 ┄ nothing::Nothing |
|
492 ┄ %2992 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %2993 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %2994 = Base.bitcast(Ptr{Float32}, %2993)::Ptr{Float32} |
|
│ Base.pointerset(%2994, %2981, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%2992))) |
|
└──── goto #493 |
|
493 ─ $(Expr(:foreigncall, "llvm.nvvm.barrier0", Nothing, svec(), :(:llvmcall), 0))::Nothing |
|
└──── goto #775 if not true |
|
494 ┄ %3000 = φ (#493 => 1, #774 => %3976)::Int64 |
|
│ %3001 = φ (#493 => 1, #774 => %3977)::Int64 |
|
└──── goto #499 if not false |
|
495 ─ %3003 = Core.tuple(%3000, %34)::Tuple{Int64,Int64} |
|
│ %3004 = Base.slt_int(5, 0)::Bool |
|
│ %3005 = Base.ifelse(%3004, 0, 5)::Int64 |
|
│ %3006 = Base.slt_int(5, 0)::Bool |
|
│ %3007 = Base.ifelse(%3006, 0, 5)::Int64 |
|
│ %3008 = Base.sle_int(1, %3000)::Bool |
|
│ %3009 = Base.sle_int(%3000, %3005)::Bool |
|
│ %3010 = Base.and_int(%3008, %3009)::Bool |
|
│ %3011 = Base.sle_int(1, %34)::Bool |
|
│ %3012 = Base.sle_int(%34, %3007)::Bool |
|
│ %3013 = Base.and_int(%3011, %3012)::Bool |
|
│ %3014 = Base.and_int(%3013, true)::Bool |
|
│ %3015 = Base.and_int(%3010, %3014)::Bool |
|
└──── goto #497 if not %3015 |
|
496 ─ goto #498 |
|
497 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %3003::Tuple{Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
498 ┄ nothing::Nothing |
|
499 ┄ %3021 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3022 = Base.mul_int(%3021, 1)::Int64 |
|
│ %3023 = Base.add_int(1, %3022)::Int64 |
|
│ %3024 = Base.sub_int(%34, 1)::Int64 |
|
│ %3025 = Base.mul_int(%3024, 5)::Int64 |
|
│ %3026 = Base.add_int(%3023, %3025)::Int64 |
|
└──── goto #504 if not false |
|
500 ─ %3028 = Core.tuple(%3026)::Tuple{Int64} |
|
│ %3029 = Base.mul_int(5, 5)::Int64 |
|
│ %3030 = Base.slt_int(%3029, 0)::Bool |
|
│ %3031 = Base.ifelse(%3030, 0, %3029)::Int64 |
|
│ %3032 = Base.sle_int(1, %3026)::Bool |
|
│ %3033 = Base.sle_int(%3026, %3031)::Bool |
|
│ %3034 = Base.and_int(%3032, %3033)::Bool |
|
└──── goto #502 if not %3034 |
|
501 ─ goto #503 |
|
502 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %3028::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
503 ┄ nothing::Nothing |
|
504 ┄ %3040 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3041 = Base.sub_int(%3026, 1)::Int64 |
|
│ %3042 = (%3040)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %2, %3041)::Float32 |
|
└──── goto #505 |
|
505 ─ goto #506 |
|
506 ─ goto #507 |
|
507 ─ goto #512 if not false |
|
508 ─ %3047 = Core.tuple(%3000, %28)::Tuple{Int64,Int64} |
|
│ %3048 = Base.slt_int(5, 0)::Bool |
|
│ %3049 = Base.ifelse(%3048, 0, 5)::Int64 |
|
│ %3050 = Base.slt_int(5, 0)::Bool |
|
│ %3051 = Base.ifelse(%3050, 0, 5)::Int64 |
|
│ %3052 = Base.sle_int(1, %3000)::Bool |
|
│ %3053 = Base.sle_int(%3000, %3049)::Bool |
|
│ %3054 = Base.and_int(%3052, %3053)::Bool |
|
│ %3055 = Base.sle_int(1, %28)::Bool |
|
│ %3056 = Base.sle_int(%28, %3051)::Bool |
|
│ %3057 = Base.and_int(%3055, %3056)::Bool |
|
│ %3058 = Base.and_int(%3057, true)::Bool |
|
│ %3059 = Base.and_int(%3054, %3058)::Bool |
|
└──── goto #510 if not %3059 |
|
509 ─ goto #511 |
|
510 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %3047::Tuple{Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
511 ┄ nothing::Nothing |
|
512 ┄ %3065 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3066 = Base.mul_int(%3065, 1)::Int64 |
|
│ %3067 = Base.add_int(1, %3066)::Int64 |
|
│ %3068 = Base.sub_int(%28, 1)::Int64 |
|
│ %3069 = Base.mul_int(%3068, 5)::Int64 |
|
│ %3070 = Base.add_int(%3067, %3069)::Int64 |
|
└──── goto #517 if not false |
|
513 ─ %3072 = Core.tuple(%3070)::Tuple{Int64} |
|
│ %3073 = Base.mul_int(5, 5)::Int64 |
|
│ %3074 = Base.slt_int(%3073, 0)::Bool |
|
│ %3075 = Base.ifelse(%3074, 0, %3073)::Int64 |
|
│ %3076 = Base.sle_int(1, %3070)::Bool |
|
│ %3077 = Base.sle_int(%3070, %3075)::Bool |
|
│ %3078 = Base.and_int(%3076, %3077)::Bool |
|
└──── goto #515 if not %3078 |
|
514 ─ goto #516 |
|
515 ─ invoke Base.throw_boundserror(%3::CuDeviceArray{Float32,2,CUDAnative.AS.Shared}, %3072::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
516 ┄ nothing::Nothing |
|
517 ┄ %3084 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3085 = Base.sub_int(%3070, 1)::Int64 |
|
│ %3086 = (%3084)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %2, %3085)::Float32 |
|
└──── goto #518 |
|
518 ─ goto #519 |
|
519 ─ goto #520 |
|
520 ─ goto #525 if not false |
|
521 ─ %3091 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3092 = Base.sle_int(1, %240)::Bool |
|
│ %3093 = Base.sle_int(%240, 5)::Bool |
|
│ %3094 = Base.and_int(%3092, %3093)::Bool |
|
└──── goto #523 if not %3094 |
|
522 ─ goto #524 |
|
523 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %3091::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
524 ┄ nothing::Nothing |
|
525 ┄ %3100 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %3101 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %3102 = Base.bitcast(Ptr{Float32}, %3101)::Ptr{Float32} |
|
│ %3103 = Base.pointerref(%3102, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3100))) |
|
└──── goto #526 |
|
526 ─ goto #531 if not false |
|
527 ─ %3107 = Core.tuple(%3000, %28, 1)::Tuple{Int64,Int64,Int64} |
|
│ %3108 = Base.slt_int(5, 0)::Bool |
|
│ %3109 = Base.ifelse(%3108, 0, 5)::Int64 |
|
│ %3110 = Base.slt_int(5, 0)::Bool |
|
│ %3111 = Base.ifelse(%3110, 0, 5)::Int64 |
|
│ %3112 = Base.slt_int(5, 0)::Bool |
|
│ %3113 = Base.ifelse(%3112, 0, 5)::Int64 |
|
│ %3114 = Base.sle_int(1, %3000)::Bool |
|
│ %3115 = Base.sle_int(%3000, %3109)::Bool |
|
│ %3116 = Base.and_int(%3114, %3115)::Bool |
|
│ %3117 = Base.sle_int(1, %28)::Bool |
|
│ %3118 = Base.sle_int(%28, %3111)::Bool |
|
│ %3119 = Base.and_int(%3117, %3118)::Bool |
|
│ %3120 = Base.sle_int(1, 1)::Bool |
|
│ %3121 = Base.sle_int(1, %3113)::Bool |
|
│ %3122 = Base.and_int(%3120, %3121)::Bool |
|
│ %3123 = Base.and_int(%3122, true)::Bool |
|
│ %3124 = Base.and_int(%3119, %3123)::Bool |
|
│ %3125 = Base.and_int(%3116, %3124)::Bool |
|
└──── goto #529 if not %3125 |
|
528 ─ goto #530 |
|
529 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3107::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
530 ┄ nothing::Nothing |
|
531 ┄ %3131 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3132 = Base.mul_int(%3131, 1)::Int64 |
|
│ %3133 = Base.add_int(1, %3132)::Int64 |
|
│ %3134 = Base.sub_int(%28, 1)::Int64 |
|
│ %3135 = Base.mul_int(%3134, 5)::Int64 |
|
│ %3136 = Base.add_int(%3133, %3135)::Int64 |
|
│ %3137 = Base.sub_int(1, 1)::Int64 |
|
│ %3138 = Base.mul_int(%3137, 25)::Int64 |
|
│ %3139 = Base.add_int(%3136, %3138)::Int64 |
|
└──── goto #536 if not false |
|
532 ─ %3141 = Core.tuple(%3139)::Tuple{Int64} |
|
│ %3142 = Base.mul_int(5, 5)::Int64 |
|
│ %3143 = Base.mul_int(%3142, 5)::Int64 |
|
│ %3144 = Base.slt_int(%3143, 0)::Bool |
|
│ %3145 = Base.ifelse(%3144, 0, %3143)::Int64 |
|
│ %3146 = Base.sle_int(1, %3139)::Bool |
|
│ %3147 = Base.sle_int(%3139, %3145)::Bool |
|
│ %3148 = Base.and_int(%3146, %3147)::Bool |
|
└──── goto #534 if not %3148 |
|
533 ─ goto #535 |
|
534 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3141::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
535 ┄ nothing::Nothing |
|
536 ┄ %3154 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3155 = Base.sub_int(%3139, 1)::Int64 |
|
│ %3156 = (%3154)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %5, %3155)::Float32 |
|
└──── goto #537 |
|
537 ─ goto #538 |
|
538 ─ goto #539 |
|
539 ─ %3160 = Base.mul_float(%3042, %3156)::Float32 |
|
│ %3161 = Base.add_float(%3103, %3160)::Float32 |
|
└──── goto #544 if not false |
|
540 ─ %3163 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3164 = Base.sle_int(1, %240)::Bool |
|
│ %3165 = Base.sle_int(%240, 5)::Bool |
|
│ %3166 = Base.and_int(%3164, %3165)::Bool |
|
└──── goto #542 if not %3166 |
|
541 ─ goto #543 |
|
542 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %3163::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
543 ┄ nothing::Nothing |
|
544 ┄ %3172 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %3173 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %3174 = Base.bitcast(Ptr{Float32}, %3173)::Ptr{Float32} |
|
│ Base.pointerset(%3174, %3161, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3172))) |
|
└──── goto #545 |
|
545 ─ goto #550 if not false |
|
546 ─ %3179 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3180 = Base.sle_int(1, %240)::Bool |
|
│ %3181 = Base.sle_int(%240, 5)::Bool |
|
│ %3182 = Base.and_int(%3180, %3181)::Bool |
|
└──── goto #548 if not %3182 |
|
547 ─ goto #549 |
|
548 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %3179::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
549 ┄ nothing::Nothing |
|
550 ┄ %3188 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %3189 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %3190 = Base.bitcast(Ptr{Float32}, %3189)::Ptr{Float32} |
|
│ %3191 = Base.pointerref(%3190, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3188))) |
|
└──── goto #551 |
|
551 ─ goto #556 if not false |
|
552 ─ %3195 = Core.tuple(%34, %3000, 1)::Tuple{Int64,Int64,Int64} |
|
│ %3196 = Base.slt_int(5, 0)::Bool |
|
│ %3197 = Base.ifelse(%3196, 0, 5)::Int64 |
|
│ %3198 = Base.slt_int(5, 0)::Bool |
|
│ %3199 = Base.ifelse(%3198, 0, 5)::Int64 |
|
│ %3200 = Base.slt_int(5, 0)::Bool |
|
│ %3201 = Base.ifelse(%3200, 0, 5)::Int64 |
|
│ %3202 = Base.sle_int(1, %34)::Bool |
|
│ %3203 = Base.sle_int(%34, %3197)::Bool |
|
│ %3204 = Base.and_int(%3202, %3203)::Bool |
|
│ %3205 = Base.sle_int(1, %3000)::Bool |
|
│ %3206 = Base.sle_int(%3000, %3199)::Bool |
|
│ %3207 = Base.and_int(%3205, %3206)::Bool |
|
│ %3208 = Base.sle_int(1, 1)::Bool |
|
│ %3209 = Base.sle_int(1, %3201)::Bool |
|
│ %3210 = Base.and_int(%3208, %3209)::Bool |
|
│ %3211 = Base.and_int(%3210, true)::Bool |
|
│ %3212 = Base.and_int(%3207, %3211)::Bool |
|
│ %3213 = Base.and_int(%3204, %3212)::Bool |
|
└──── goto #554 if not %3213 |
|
553 ─ goto #555 |
|
554 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3195::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
555 ┄ nothing::Nothing |
|
556 ┄ %3219 = Base.sub_int(%34, 1)::Int64 |
|
│ %3220 = Base.mul_int(%3219, 1)::Int64 |
|
│ %3221 = Base.add_int(1, %3220)::Int64 |
|
│ %3222 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3223 = Base.mul_int(%3222, 5)::Int64 |
|
│ %3224 = Base.add_int(%3221, %3223)::Int64 |
|
│ %3225 = Base.sub_int(1, 1)::Int64 |
|
│ %3226 = Base.mul_int(%3225, 25)::Int64 |
|
│ %3227 = Base.add_int(%3224, %3226)::Int64 |
|
└──── goto #561 if not false |
|
557 ─ %3229 = Core.tuple(%3227)::Tuple{Int64} |
|
│ %3230 = Base.mul_int(5, 5)::Int64 |
|
│ %3231 = Base.mul_int(%3230, 5)::Int64 |
|
│ %3232 = Base.slt_int(%3231, 0)::Bool |
|
│ %3233 = Base.ifelse(%3232, 0, %3231)::Int64 |
|
│ %3234 = Base.sle_int(1, %3227)::Bool |
|
│ %3235 = Base.sle_int(%3227, %3233)::Bool |
|
│ %3236 = Base.and_int(%3234, %3235)::Bool |
|
└──── goto #559 if not %3236 |
|
558 ─ goto #560 |
|
559 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3229::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
560 ┄ nothing::Nothing |
|
561 ┄ %3242 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3243 = Base.sub_int(%3227, 1)::Int64 |
|
│ %3244 = (%3242)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %8, %3243)::Float32 |
|
└──── goto #562 |
|
562 ─ goto #563 |
|
563 ─ goto #564 |
|
564 ─ %3248 = Base.mul_float(%3086, %3244)::Float32 |
|
│ %3249 = Base.add_float(%3191, %3248)::Float32 |
|
└──── goto #569 if not false |
|
565 ─ %3251 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3252 = Base.sle_int(1, %240)::Bool |
|
│ %3253 = Base.sle_int(%240, 5)::Bool |
|
│ %3254 = Base.and_int(%3252, %3253)::Bool |
|
└──── goto #567 if not %3254 |
|
566 ─ goto #568 |
|
567 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %3251::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
568 ┄ nothing::Nothing |
|
569 ┄ %3260 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %3261 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %3262 = Base.bitcast(Ptr{Float32}, %3261)::Ptr{Float32} |
|
│ Base.pointerset(%3262, %3249, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3260))) |
|
└──── goto #570 |
|
570 ─ goto #575 if not false |
|
571 ─ %3267 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3268 = Base.sle_int(1, %240)::Bool |
|
│ %3269 = Base.sle_int(%240, 5)::Bool |
|
│ %3270 = Base.and_int(%3268, %3269)::Bool |
|
└──── goto #573 if not %3270 |
|
572 ─ goto #574 |
|
573 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %3267::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
574 ┄ nothing::Nothing |
|
575 ┄ %3276 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %3277 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %3278 = Base.bitcast(Ptr{Float32}, %3277)::Ptr{Float32} |
|
│ %3279 = Base.pointerref(%3278, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3276))) |
|
└──── goto #576 |
|
576 ─ goto #581 if not false |
|
577 ─ %3283 = Core.tuple(%3000, %28, 2)::Tuple{Int64,Int64,Int64} |
|
│ %3284 = Base.slt_int(5, 0)::Bool |
|
│ %3285 = Base.ifelse(%3284, 0, 5)::Int64 |
|
│ %3286 = Base.slt_int(5, 0)::Bool |
|
│ %3287 = Base.ifelse(%3286, 0, 5)::Int64 |
|
│ %3288 = Base.slt_int(5, 0)::Bool |
|
│ %3289 = Base.ifelse(%3288, 0, 5)::Int64 |
|
│ %3290 = Base.sle_int(1, %3000)::Bool |
|
│ %3291 = Base.sle_int(%3000, %3285)::Bool |
|
│ %3292 = Base.and_int(%3290, %3291)::Bool |
|
│ %3293 = Base.sle_int(1, %28)::Bool |
|
│ %3294 = Base.sle_int(%28, %3287)::Bool |
|
│ %3295 = Base.and_int(%3293, %3294)::Bool |
|
│ %3296 = Base.sle_int(1, 2)::Bool |
|
│ %3297 = Base.sle_int(2, %3289)::Bool |
|
│ %3298 = Base.and_int(%3296, %3297)::Bool |
|
│ %3299 = Base.and_int(%3298, true)::Bool |
|
│ %3300 = Base.and_int(%3295, %3299)::Bool |
|
│ %3301 = Base.and_int(%3292, %3300)::Bool |
|
└──── goto #579 if not %3301 |
|
578 ─ goto #580 |
|
579 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3283::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
580 ┄ nothing::Nothing |
|
581 ┄ %3307 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3308 = Base.mul_int(%3307, 1)::Int64 |
|
│ %3309 = Base.add_int(1, %3308)::Int64 |
|
│ %3310 = Base.sub_int(%28, 1)::Int64 |
|
│ %3311 = Base.mul_int(%3310, 5)::Int64 |
|
│ %3312 = Base.add_int(%3309, %3311)::Int64 |
|
│ %3313 = Base.sub_int(2, 1)::Int64 |
|
│ %3314 = Base.mul_int(%3313, 25)::Int64 |
|
│ %3315 = Base.add_int(%3312, %3314)::Int64 |
|
└──── goto #586 if not false |
|
582 ─ %3317 = Core.tuple(%3315)::Tuple{Int64} |
|
│ %3318 = Base.mul_int(5, 5)::Int64 |
|
│ %3319 = Base.mul_int(%3318, 5)::Int64 |
|
│ %3320 = Base.slt_int(%3319, 0)::Bool |
|
│ %3321 = Base.ifelse(%3320, 0, %3319)::Int64 |
|
│ %3322 = Base.sle_int(1, %3315)::Bool |
|
│ %3323 = Base.sle_int(%3315, %3321)::Bool |
|
│ %3324 = Base.and_int(%3322, %3323)::Bool |
|
└──── goto #584 if not %3324 |
|
583 ─ goto #585 |
|
584 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3317::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
585 ┄ nothing::Nothing |
|
586 ┄ %3330 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3331 = Base.sub_int(%3315, 1)::Int64 |
|
│ %3332 = (%3330)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %5, %3331)::Float32 |
|
└──── goto #587 |
|
587 ─ goto #588 |
|
588 ─ goto #589 |
|
589 ─ %3336 = Base.mul_float(%3042, %3332)::Float32 |
|
│ %3337 = Base.add_float(%3279, %3336)::Float32 |
|
└──── goto #594 if not false |
|
590 ─ %3339 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3340 = Base.sle_int(1, %240)::Bool |
|
│ %3341 = Base.sle_int(%240, 5)::Bool |
|
│ %3342 = Base.and_int(%3340, %3341)::Bool |
|
└──── goto #592 if not %3342 |
|
591 ─ goto #593 |
|
592 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %3339::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
593 ┄ nothing::Nothing |
|
594 ┄ %3348 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %3349 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %3350 = Base.bitcast(Ptr{Float32}, %3349)::Ptr{Float32} |
|
│ Base.pointerset(%3350, %3337, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3348))) |
|
└──── goto #595 |
|
595 ─ goto #600 if not false |
|
596 ─ %3355 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3356 = Base.sle_int(1, %240)::Bool |
|
│ %3357 = Base.sle_int(%240, 5)::Bool |
|
│ %3358 = Base.and_int(%3356, %3357)::Bool |
|
└──── goto #598 if not %3358 |
|
597 ─ goto #599 |
|
598 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %3355::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
599 ┄ nothing::Nothing |
|
600 ┄ %3364 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %3365 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %3366 = Base.bitcast(Ptr{Float32}, %3365)::Ptr{Float32} |
|
│ %3367 = Base.pointerref(%3366, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3364))) |
|
└──── goto #601 |
|
601 ─ goto #606 if not false |
|
602 ─ %3371 = Core.tuple(%34, %3000, 2)::Tuple{Int64,Int64,Int64} |
|
│ %3372 = Base.slt_int(5, 0)::Bool |
|
│ %3373 = Base.ifelse(%3372, 0, 5)::Int64 |
|
│ %3374 = Base.slt_int(5, 0)::Bool |
|
│ %3375 = Base.ifelse(%3374, 0, 5)::Int64 |
|
│ %3376 = Base.slt_int(5, 0)::Bool |
|
│ %3377 = Base.ifelse(%3376, 0, 5)::Int64 |
|
│ %3378 = Base.sle_int(1, %34)::Bool |
|
│ %3379 = Base.sle_int(%34, %3373)::Bool |
|
│ %3380 = Base.and_int(%3378, %3379)::Bool |
|
│ %3381 = Base.sle_int(1, %3000)::Bool |
|
│ %3382 = Base.sle_int(%3000, %3375)::Bool |
|
│ %3383 = Base.and_int(%3381, %3382)::Bool |
|
│ %3384 = Base.sle_int(1, 2)::Bool |
|
│ %3385 = Base.sle_int(2, %3377)::Bool |
|
│ %3386 = Base.and_int(%3384, %3385)::Bool |
|
│ %3387 = Base.and_int(%3386, true)::Bool |
|
│ %3388 = Base.and_int(%3383, %3387)::Bool |
|
│ %3389 = Base.and_int(%3380, %3388)::Bool |
|
└──── goto #604 if not %3389 |
|
603 ─ goto #605 |
|
604 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3371::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
605 ┄ nothing::Nothing |
|
606 ┄ %3395 = Base.sub_int(%34, 1)::Int64 |
|
│ %3396 = Base.mul_int(%3395, 1)::Int64 |
|
│ %3397 = Base.add_int(1, %3396)::Int64 |
|
│ %3398 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3399 = Base.mul_int(%3398, 5)::Int64 |
|
│ %3400 = Base.add_int(%3397, %3399)::Int64 |
|
│ %3401 = Base.sub_int(2, 1)::Int64 |
|
│ %3402 = Base.mul_int(%3401, 25)::Int64 |
|
│ %3403 = Base.add_int(%3400, %3402)::Int64 |
|
└──── goto #611 if not false |
|
607 ─ %3405 = Core.tuple(%3403)::Tuple{Int64} |
|
│ %3406 = Base.mul_int(5, 5)::Int64 |
|
│ %3407 = Base.mul_int(%3406, 5)::Int64 |
|
│ %3408 = Base.slt_int(%3407, 0)::Bool |
|
│ %3409 = Base.ifelse(%3408, 0, %3407)::Int64 |
|
│ %3410 = Base.sle_int(1, %3403)::Bool |
|
│ %3411 = Base.sle_int(%3403, %3409)::Bool |
|
│ %3412 = Base.and_int(%3410, %3411)::Bool |
|
└──── goto #609 if not %3412 |
|
608 ─ goto #610 |
|
609 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3405::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
610 ┄ nothing::Nothing |
|
611 ┄ %3418 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3419 = Base.sub_int(%3403, 1)::Int64 |
|
│ %3420 = (%3418)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %8, %3419)::Float32 |
|
└──── goto #612 |
|
612 ─ goto #613 |
|
613 ─ goto #614 |
|
614 ─ %3424 = Base.mul_float(%3086, %3420)::Float32 |
|
│ %3425 = Base.add_float(%3367, %3424)::Float32 |
|
└──── goto #619 if not false |
|
615 ─ %3427 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3428 = Base.sle_int(1, %240)::Bool |
|
│ %3429 = Base.sle_int(%240, 5)::Bool |
|
│ %3430 = Base.and_int(%3428, %3429)::Bool |
|
└──── goto #617 if not %3430 |
|
616 ─ goto #618 |
|
617 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %3427::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
618 ┄ nothing::Nothing |
|
619 ┄ %3436 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %3437 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %3438 = Base.bitcast(Ptr{Float32}, %3437)::Ptr{Float32} |
|
│ Base.pointerset(%3438, %3425, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3436))) |
|
└──── goto #620 |
|
620 ─ goto #625 if not false |
|
621 ─ %3443 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3444 = Base.sle_int(1, %240)::Bool |
|
│ %3445 = Base.sle_int(%240, 5)::Bool |
|
│ %3446 = Base.and_int(%3444, %3445)::Bool |
|
└──── goto #623 if not %3446 |
|
622 ─ goto #624 |
|
623 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %3443::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
624 ┄ nothing::Nothing |
|
625 ┄ %3452 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %3453 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %3454 = Base.bitcast(Ptr{Float32}, %3453)::Ptr{Float32} |
|
│ %3455 = Base.pointerref(%3454, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3452))) |
|
└──── goto #626 |
|
626 ─ goto #631 if not false |
|
627 ─ %3459 = Core.tuple(%3000, %28, 3)::Tuple{Int64,Int64,Int64} |
|
│ %3460 = Base.slt_int(5, 0)::Bool |
|
│ %3461 = Base.ifelse(%3460, 0, 5)::Int64 |
|
│ %3462 = Base.slt_int(5, 0)::Bool |
|
│ %3463 = Base.ifelse(%3462, 0, 5)::Int64 |
|
│ %3464 = Base.slt_int(5, 0)::Bool |
|
│ %3465 = Base.ifelse(%3464, 0, 5)::Int64 |
|
│ %3466 = Base.sle_int(1, %3000)::Bool |
|
│ %3467 = Base.sle_int(%3000, %3461)::Bool |
|
│ %3468 = Base.and_int(%3466, %3467)::Bool |
|
│ %3469 = Base.sle_int(1, %28)::Bool |
|
│ %3470 = Base.sle_int(%28, %3463)::Bool |
|
│ %3471 = Base.and_int(%3469, %3470)::Bool |
|
│ %3472 = Base.sle_int(1, 3)::Bool |
|
│ %3473 = Base.sle_int(3, %3465)::Bool |
|
│ %3474 = Base.and_int(%3472, %3473)::Bool |
|
│ %3475 = Base.and_int(%3474, true)::Bool |
|
│ %3476 = Base.and_int(%3471, %3475)::Bool |
|
│ %3477 = Base.and_int(%3468, %3476)::Bool |
|
└──── goto #629 if not %3477 |
|
628 ─ goto #630 |
|
629 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3459::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
630 ┄ nothing::Nothing |
|
631 ┄ %3483 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3484 = Base.mul_int(%3483, 1)::Int64 |
|
│ %3485 = Base.add_int(1, %3484)::Int64 |
|
│ %3486 = Base.sub_int(%28, 1)::Int64 |
|
│ %3487 = Base.mul_int(%3486, 5)::Int64 |
|
│ %3488 = Base.add_int(%3485, %3487)::Int64 |
|
│ %3489 = Base.sub_int(3, 1)::Int64 |
|
│ %3490 = Base.mul_int(%3489, 25)::Int64 |
|
│ %3491 = Base.add_int(%3488, %3490)::Int64 |
|
└──── goto #636 if not false |
|
632 ─ %3493 = Core.tuple(%3491)::Tuple{Int64} |
|
│ %3494 = Base.mul_int(5, 5)::Int64 |
|
│ %3495 = Base.mul_int(%3494, 5)::Int64 |
|
│ %3496 = Base.slt_int(%3495, 0)::Bool |
|
│ %3497 = Base.ifelse(%3496, 0, %3495)::Int64 |
|
│ %3498 = Base.sle_int(1, %3491)::Bool |
|
│ %3499 = Base.sle_int(%3491, %3497)::Bool |
|
│ %3500 = Base.and_int(%3498, %3499)::Bool |
|
└──── goto #634 if not %3500 |
|
633 ─ goto #635 |
|
634 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3493::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
635 ┄ nothing::Nothing |
|
636 ┄ %3506 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3507 = Base.sub_int(%3491, 1)::Int64 |
|
│ %3508 = (%3506)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %5, %3507)::Float32 |
|
└──── goto #637 |
|
637 ─ goto #638 |
|
638 ─ goto #639 |
|
639 ─ %3512 = Base.mul_float(%3042, %3508)::Float32 |
|
│ %3513 = Base.add_float(%3455, %3512)::Float32 |
|
└──── goto #644 if not false |
|
640 ─ %3515 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3516 = Base.sle_int(1, %240)::Bool |
|
│ %3517 = Base.sle_int(%240, 5)::Bool |
|
│ %3518 = Base.and_int(%3516, %3517)::Bool |
|
└──── goto #642 if not %3518 |
|
641 ─ goto #643 |
|
642 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %3515::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
643 ┄ nothing::Nothing |
|
644 ┄ %3524 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %3525 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %3526 = Base.bitcast(Ptr{Float32}, %3525)::Ptr{Float32} |
|
│ Base.pointerset(%3526, %3513, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3524))) |
|
└──── goto #645 |
|
645 ─ goto #650 if not false |
|
646 ─ %3531 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3532 = Base.sle_int(1, %240)::Bool |
|
│ %3533 = Base.sle_int(%240, 5)::Bool |
|
│ %3534 = Base.and_int(%3532, %3533)::Bool |
|
└──── goto #648 if not %3534 |
|
647 ─ goto #649 |
|
648 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %3531::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
649 ┄ nothing::Nothing |
|
650 ┄ %3540 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %3541 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %3542 = Base.bitcast(Ptr{Float32}, %3541)::Ptr{Float32} |
|
│ %3543 = Base.pointerref(%3542, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3540))) |
|
└──── goto #651 |
|
651 ─ goto #656 if not false |
|
652 ─ %3547 = Core.tuple(%34, %3000, 3)::Tuple{Int64,Int64,Int64} |
|
│ %3548 = Base.slt_int(5, 0)::Bool |
|
│ %3549 = Base.ifelse(%3548, 0, 5)::Int64 |
|
│ %3550 = Base.slt_int(5, 0)::Bool |
|
│ %3551 = Base.ifelse(%3550, 0, 5)::Int64 |
|
│ %3552 = Base.slt_int(5, 0)::Bool |
|
│ %3553 = Base.ifelse(%3552, 0, 5)::Int64 |
|
│ %3554 = Base.sle_int(1, %34)::Bool |
|
│ %3555 = Base.sle_int(%34, %3549)::Bool |
|
│ %3556 = Base.and_int(%3554, %3555)::Bool |
|
│ %3557 = Base.sle_int(1, %3000)::Bool |
|
│ %3558 = Base.sle_int(%3000, %3551)::Bool |
|
│ %3559 = Base.and_int(%3557, %3558)::Bool |
|
│ %3560 = Base.sle_int(1, 3)::Bool |
|
│ %3561 = Base.sle_int(3, %3553)::Bool |
|
│ %3562 = Base.and_int(%3560, %3561)::Bool |
|
│ %3563 = Base.and_int(%3562, true)::Bool |
|
│ %3564 = Base.and_int(%3559, %3563)::Bool |
|
│ %3565 = Base.and_int(%3556, %3564)::Bool |
|
└──── goto #654 if not %3565 |
|
653 ─ goto #655 |
|
654 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3547::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
655 ┄ nothing::Nothing |
|
656 ┄ %3571 = Base.sub_int(%34, 1)::Int64 |
|
│ %3572 = Base.mul_int(%3571, 1)::Int64 |
|
│ %3573 = Base.add_int(1, %3572)::Int64 |
|
│ %3574 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3575 = Base.mul_int(%3574, 5)::Int64 |
|
│ %3576 = Base.add_int(%3573, %3575)::Int64 |
|
│ %3577 = Base.sub_int(3, 1)::Int64 |
|
│ %3578 = Base.mul_int(%3577, 25)::Int64 |
|
│ %3579 = Base.add_int(%3576, %3578)::Int64 |
|
└──── goto #661 if not false |
|
657 ─ %3581 = Core.tuple(%3579)::Tuple{Int64} |
|
│ %3582 = Base.mul_int(5, 5)::Int64 |
|
│ %3583 = Base.mul_int(%3582, 5)::Int64 |
|
│ %3584 = Base.slt_int(%3583, 0)::Bool |
|
│ %3585 = Base.ifelse(%3584, 0, %3583)::Int64 |
|
│ %3586 = Base.sle_int(1, %3579)::Bool |
|
│ %3587 = Base.sle_int(%3579, %3585)::Bool |
|
│ %3588 = Base.and_int(%3586, %3587)::Bool |
|
└──── goto #659 if not %3588 |
|
658 ─ goto #660 |
|
659 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3581::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
660 ┄ nothing::Nothing |
|
661 ┄ %3594 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3595 = Base.sub_int(%3579, 1)::Int64 |
|
│ %3596 = (%3594)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %8, %3595)::Float32 |
|
└──── goto #662 |
|
662 ─ goto #663 |
|
663 ─ goto #664 |
|
664 ─ %3600 = Base.mul_float(%3086, %3596)::Float32 |
|
│ %3601 = Base.add_float(%3543, %3600)::Float32 |
|
└──── goto #669 if not false |
|
665 ─ %3603 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3604 = Base.sle_int(1, %240)::Bool |
|
│ %3605 = Base.sle_int(%240, 5)::Bool |
|
│ %3606 = Base.and_int(%3604, %3605)::Bool |
|
└──── goto #667 if not %3606 |
|
666 ─ goto #668 |
|
667 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %3603::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
668 ┄ nothing::Nothing |
|
669 ┄ %3612 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %3613 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %3614 = Base.bitcast(Ptr{Float32}, %3613)::Ptr{Float32} |
|
│ Base.pointerset(%3614, %3601, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3612))) |
|
└──── goto #670 |
|
670 ─ goto #675 if not false |
|
671 ─ %3619 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3620 = Base.sle_int(1, %240)::Bool |
|
│ %3621 = Base.sle_int(%240, 5)::Bool |
|
│ %3622 = Base.and_int(%3620, %3621)::Bool |
|
└──── goto #673 if not %3622 |
|
672 ─ goto #674 |
|
673 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %3619::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
674 ┄ nothing::Nothing |
|
675 ┄ %3628 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %3629 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %3630 = Base.bitcast(Ptr{Float32}, %3629)::Ptr{Float32} |
|
│ %3631 = Base.pointerref(%3630, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3628))) |
|
└──── goto #676 |
|
676 ─ goto #681 if not false |
|
677 ─ %3635 = Core.tuple(%3000, %28, 4)::Tuple{Int64,Int64,Int64} |
|
│ %3636 = Base.slt_int(5, 0)::Bool |
|
│ %3637 = Base.ifelse(%3636, 0, 5)::Int64 |
|
│ %3638 = Base.slt_int(5, 0)::Bool |
|
│ %3639 = Base.ifelse(%3638, 0, 5)::Int64 |
|
│ %3640 = Base.slt_int(5, 0)::Bool |
|
│ %3641 = Base.ifelse(%3640, 0, 5)::Int64 |
|
│ %3642 = Base.sle_int(1, %3000)::Bool |
|
│ %3643 = Base.sle_int(%3000, %3637)::Bool |
|
│ %3644 = Base.and_int(%3642, %3643)::Bool |
|
│ %3645 = Base.sle_int(1, %28)::Bool |
|
│ %3646 = Base.sle_int(%28, %3639)::Bool |
|
│ %3647 = Base.and_int(%3645, %3646)::Bool |
|
│ %3648 = Base.sle_int(1, 4)::Bool |
|
│ %3649 = Base.sle_int(4, %3641)::Bool |
|
│ %3650 = Base.and_int(%3648, %3649)::Bool |
|
│ %3651 = Base.and_int(%3650, true)::Bool |
|
│ %3652 = Base.and_int(%3647, %3651)::Bool |
|
│ %3653 = Base.and_int(%3644, %3652)::Bool |
|
└──── goto #679 if not %3653 |
|
678 ─ goto #680 |
|
679 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3635::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
680 ┄ nothing::Nothing |
|
681 ┄ %3659 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3660 = Base.mul_int(%3659, 1)::Int64 |
|
│ %3661 = Base.add_int(1, %3660)::Int64 |
|
│ %3662 = Base.sub_int(%28, 1)::Int64 |
|
│ %3663 = Base.mul_int(%3662, 5)::Int64 |
|
│ %3664 = Base.add_int(%3661, %3663)::Int64 |
|
│ %3665 = Base.sub_int(4, 1)::Int64 |
|
│ %3666 = Base.mul_int(%3665, 25)::Int64 |
|
│ %3667 = Base.add_int(%3664, %3666)::Int64 |
|
└──── goto #686 if not false |
|
682 ─ %3669 = Core.tuple(%3667)::Tuple{Int64} |
|
│ %3670 = Base.mul_int(5, 5)::Int64 |
|
│ %3671 = Base.mul_int(%3670, 5)::Int64 |
|
│ %3672 = Base.slt_int(%3671, 0)::Bool |
|
│ %3673 = Base.ifelse(%3672, 0, %3671)::Int64 |
|
│ %3674 = Base.sle_int(1, %3667)::Bool |
|
│ %3675 = Base.sle_int(%3667, %3673)::Bool |
|
│ %3676 = Base.and_int(%3674, %3675)::Bool |
|
└──── goto #684 if not %3676 |
|
683 ─ goto #685 |
|
684 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3669::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
685 ┄ nothing::Nothing |
|
686 ┄ %3682 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3683 = Base.sub_int(%3667, 1)::Int64 |
|
│ %3684 = (%3682)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %5, %3683)::Float32 |
|
└──── goto #687 |
|
687 ─ goto #688 |
|
688 ─ goto #689 |
|
689 ─ %3688 = Base.mul_float(%3042, %3684)::Float32 |
|
│ %3689 = Base.add_float(%3631, %3688)::Float32 |
|
└──── goto #694 if not false |
|
690 ─ %3691 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3692 = Base.sle_int(1, %240)::Bool |
|
│ %3693 = Base.sle_int(%240, 5)::Bool |
|
│ %3694 = Base.and_int(%3692, %3693)::Bool |
|
└──── goto #692 if not %3694 |
|
691 ─ goto #693 |
|
692 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %3691::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
693 ┄ nothing::Nothing |
|
694 ┄ %3700 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %3701 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %3702 = Base.bitcast(Ptr{Float32}, %3701)::Ptr{Float32} |
|
│ Base.pointerset(%3702, %3689, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3700))) |
|
└──── goto #695 |
|
695 ─ goto #700 if not false |
|
696 ─ %3707 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3708 = Base.sle_int(1, %240)::Bool |
|
│ %3709 = Base.sle_int(%240, 5)::Bool |
|
│ %3710 = Base.and_int(%3708, %3709)::Bool |
|
└──── goto #698 if not %3710 |
|
697 ─ goto #699 |
|
698 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %3707::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
699 ┄ nothing::Nothing |
|
700 ┄ %3716 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %3717 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %3718 = Base.bitcast(Ptr{Float32}, %3717)::Ptr{Float32} |
|
│ %3719 = Base.pointerref(%3718, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3716))) |
|
└──── goto #701 |
|
701 ─ goto #706 if not false |
|
702 ─ %3723 = Core.tuple(%34, %3000, 4)::Tuple{Int64,Int64,Int64} |
|
│ %3724 = Base.slt_int(5, 0)::Bool |
|
│ %3725 = Base.ifelse(%3724, 0, 5)::Int64 |
|
│ %3726 = Base.slt_int(5, 0)::Bool |
|
│ %3727 = Base.ifelse(%3726, 0, 5)::Int64 |
|
│ %3728 = Base.slt_int(5, 0)::Bool |
|
│ %3729 = Base.ifelse(%3728, 0, 5)::Int64 |
|
│ %3730 = Base.sle_int(1, %34)::Bool |
|
│ %3731 = Base.sle_int(%34, %3725)::Bool |
|
│ %3732 = Base.and_int(%3730, %3731)::Bool |
|
│ %3733 = Base.sle_int(1, %3000)::Bool |
|
│ %3734 = Base.sle_int(%3000, %3727)::Bool |
|
│ %3735 = Base.and_int(%3733, %3734)::Bool |
|
│ %3736 = Base.sle_int(1, 4)::Bool |
|
│ %3737 = Base.sle_int(4, %3729)::Bool |
|
│ %3738 = Base.and_int(%3736, %3737)::Bool |
|
│ %3739 = Base.and_int(%3738, true)::Bool |
|
│ %3740 = Base.and_int(%3735, %3739)::Bool |
|
│ %3741 = Base.and_int(%3732, %3740)::Bool |
|
└──── goto #704 if not %3741 |
|
703 ─ goto #705 |
|
704 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3723::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
705 ┄ nothing::Nothing |
|
706 ┄ %3747 = Base.sub_int(%34, 1)::Int64 |
|
│ %3748 = Base.mul_int(%3747, 1)::Int64 |
|
│ %3749 = Base.add_int(1, %3748)::Int64 |
|
│ %3750 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3751 = Base.mul_int(%3750, 5)::Int64 |
|
│ %3752 = Base.add_int(%3749, %3751)::Int64 |
|
│ %3753 = Base.sub_int(4, 1)::Int64 |
|
│ %3754 = Base.mul_int(%3753, 25)::Int64 |
|
│ %3755 = Base.add_int(%3752, %3754)::Int64 |
|
└──── goto #711 if not false |
|
707 ─ %3757 = Core.tuple(%3755)::Tuple{Int64} |
|
│ %3758 = Base.mul_int(5, 5)::Int64 |
|
│ %3759 = Base.mul_int(%3758, 5)::Int64 |
|
│ %3760 = Base.slt_int(%3759, 0)::Bool |
|
│ %3761 = Base.ifelse(%3760, 0, %3759)::Int64 |
|
│ %3762 = Base.sle_int(1, %3755)::Bool |
|
│ %3763 = Base.sle_int(%3755, %3761)::Bool |
|
│ %3764 = Base.and_int(%3762, %3763)::Bool |
|
└──── goto #709 if not %3764 |
|
708 ─ goto #710 |
|
709 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3757::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
710 ┄ nothing::Nothing |
|
711 ┄ %3770 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3771 = Base.sub_int(%3755, 1)::Int64 |
|
│ %3772 = (%3770)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %8, %3771)::Float32 |
|
└──── goto #712 |
|
712 ─ goto #713 |
|
713 ─ goto #714 |
|
714 ─ %3776 = Base.mul_float(%3086, %3772)::Float32 |
|
│ %3777 = Base.add_float(%3719, %3776)::Float32 |
|
└──── goto #719 if not false |
|
715 ─ %3779 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3780 = Base.sle_int(1, %240)::Bool |
|
│ %3781 = Base.sle_int(%240, 5)::Bool |
|
│ %3782 = Base.and_int(%3780, %3781)::Bool |
|
└──── goto #717 if not %3782 |
|
716 ─ goto #718 |
|
717 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %3779::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
718 ┄ nothing::Nothing |
|
719 ┄ %3788 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %3789 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %3790 = Base.bitcast(Ptr{Float32}, %3789)::Ptr{Float32} |
|
│ Base.pointerset(%3790, %3777, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3788))) |
|
└──── goto #720 |
|
720 ─ goto #725 if not false |
|
721 ─ %3795 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3796 = Base.sle_int(1, %240)::Bool |
|
│ %3797 = Base.sle_int(%240, 5)::Bool |
|
│ %3798 = Base.and_int(%3796, %3797)::Bool |
|
└──── goto #723 if not %3798 |
|
722 ─ goto #724 |
|
723 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %3795::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
724 ┄ nothing::Nothing |
|
725 ┄ %3804 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %3805 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %3806 = Base.bitcast(Ptr{Float32}, %3805)::Ptr{Float32} |
|
│ %3807 = Base.pointerref(%3806, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3804))) |
|
└──── goto #726 |
|
726 ─ goto #731 if not false |
|
727 ─ %3811 = Core.tuple(%3000, %28, 5)::Tuple{Int64,Int64,Int64} |
|
│ %3812 = Base.slt_int(5, 0)::Bool |
|
│ %3813 = Base.ifelse(%3812, 0, 5)::Int64 |
|
│ %3814 = Base.slt_int(5, 0)::Bool |
|
│ %3815 = Base.ifelse(%3814, 0, 5)::Int64 |
|
│ %3816 = Base.slt_int(5, 0)::Bool |
|
│ %3817 = Base.ifelse(%3816, 0, 5)::Int64 |
|
│ %3818 = Base.sle_int(1, %3000)::Bool |
|
│ %3819 = Base.sle_int(%3000, %3813)::Bool |
|
│ %3820 = Base.and_int(%3818, %3819)::Bool |
|
│ %3821 = Base.sle_int(1, %28)::Bool |
|
│ %3822 = Base.sle_int(%28, %3815)::Bool |
|
│ %3823 = Base.and_int(%3821, %3822)::Bool |
|
│ %3824 = Base.sle_int(1, 5)::Bool |
|
│ %3825 = Base.sle_int(5, %3817)::Bool |
|
│ %3826 = Base.and_int(%3824, %3825)::Bool |
|
│ %3827 = Base.and_int(%3826, true)::Bool |
|
│ %3828 = Base.and_int(%3823, %3827)::Bool |
|
│ %3829 = Base.and_int(%3820, %3828)::Bool |
|
└──── goto #729 if not %3829 |
|
728 ─ goto #730 |
|
729 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3811::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
730 ┄ nothing::Nothing |
|
731 ┄ %3835 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3836 = Base.mul_int(%3835, 1)::Int64 |
|
│ %3837 = Base.add_int(1, %3836)::Int64 |
|
│ %3838 = Base.sub_int(%28, 1)::Int64 |
|
│ %3839 = Base.mul_int(%3838, 5)::Int64 |
|
│ %3840 = Base.add_int(%3837, %3839)::Int64 |
|
│ %3841 = Base.sub_int(5, 1)::Int64 |
|
│ %3842 = Base.mul_int(%3841, 25)::Int64 |
|
│ %3843 = Base.add_int(%3840, %3842)::Int64 |
|
└──── goto #736 if not false |
|
732 ─ %3845 = Core.tuple(%3843)::Tuple{Int64} |
|
│ %3846 = Base.mul_int(5, 5)::Int64 |
|
│ %3847 = Base.mul_int(%3846, 5)::Int64 |
|
│ %3848 = Base.slt_int(%3847, 0)::Bool |
|
│ %3849 = Base.ifelse(%3848, 0, %3847)::Int64 |
|
│ %3850 = Base.sle_int(1, %3843)::Bool |
|
│ %3851 = Base.sle_int(%3843, %3849)::Bool |
|
│ %3852 = Base.and_int(%3850, %3851)::Bool |
|
└──── goto #734 if not %3852 |
|
733 ─ goto #735 |
|
734 ─ invoke Base.throw_boundserror(%6::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3845::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
735 ┄ nothing::Nothing |
|
736 ┄ %3858 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3859 = Base.sub_int(%3843, 1)::Int64 |
|
│ %3860 = (%3858)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %5, %3859)::Float32 |
|
└──── goto #737 |
|
737 ─ goto #738 |
|
738 ─ goto #739 |
|
739 ─ %3864 = Base.mul_float(%3042, %3860)::Float32 |
|
│ %3865 = Base.add_float(%3807, %3864)::Float32 |
|
└──── goto #744 if not false |
|
740 ─ %3867 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3868 = Base.sle_int(1, %240)::Bool |
|
│ %3869 = Base.sle_int(%240, 5)::Bool |
|
│ %3870 = Base.and_int(%3868, %3869)::Bool |
|
└──── goto #742 if not %3870 |
|
741 ─ goto #743 |
|
742 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %3867::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
743 ┄ nothing::Nothing |
|
744 ┄ %3876 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %3877 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %3878 = Base.bitcast(Ptr{Float32}, %3877)::Ptr{Float32} |
|
│ Base.pointerset(%3878, %3865, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3876))) |
|
└──── goto #745 |
|
745 ─ goto #750 if not false |
|
746 ─ %3883 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3884 = Base.sle_int(1, %240)::Bool |
|
│ %3885 = Base.sle_int(%240, 5)::Bool |
|
│ %3886 = Base.and_int(%3884, %3885)::Bool |
|
└──── goto #748 if not %3886 |
|
747 ─ goto #749 |
|
748 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %3883::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
749 ┄ nothing::Nothing |
|
750 ┄ %3892 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %3893 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %3894 = Base.bitcast(Ptr{Float32}, %3893)::Ptr{Float32} |
|
│ %3895 = Base.pointerref(%3894, %240, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%3892))) |
|
└──── goto #751 |
|
751 ─ goto #756 if not false |
|
752 ─ %3899 = Core.tuple(%34, %3000, 5)::Tuple{Int64,Int64,Int64} |
|
│ %3900 = Base.slt_int(5, 0)::Bool |
|
│ %3901 = Base.ifelse(%3900, 0, 5)::Int64 |
|
│ %3902 = Base.slt_int(5, 0)::Bool |
|
│ %3903 = Base.ifelse(%3902, 0, 5)::Int64 |
|
│ %3904 = Base.slt_int(5, 0)::Bool |
|
│ %3905 = Base.ifelse(%3904, 0, 5)::Int64 |
|
│ %3906 = Base.sle_int(1, %34)::Bool |
|
│ %3907 = Base.sle_int(%34, %3901)::Bool |
|
│ %3908 = Base.and_int(%3906, %3907)::Bool |
|
│ %3909 = Base.sle_int(1, %3000)::Bool |
|
│ %3910 = Base.sle_int(%3000, %3903)::Bool |
|
│ %3911 = Base.and_int(%3909, %3910)::Bool |
|
│ %3912 = Base.sle_int(1, 5)::Bool |
|
│ %3913 = Base.sle_int(5, %3905)::Bool |
|
│ %3914 = Base.and_int(%3912, %3913)::Bool |
|
│ %3915 = Base.and_int(%3914, true)::Bool |
|
│ %3916 = Base.and_int(%3911, %3915)::Bool |
|
│ %3917 = Base.and_int(%3908, %3916)::Bool |
|
└──── goto #754 if not %3917 |
|
753 ─ goto #755 |
|
754 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3899::Tuple{Int64,Int64,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
755 ┄ nothing::Nothing |
|
756 ┄ %3923 = Base.sub_int(%34, 1)::Int64 |
|
│ %3924 = Base.mul_int(%3923, 1)::Int64 |
|
│ %3925 = Base.add_int(1, %3924)::Int64 |
|
│ %3926 = Base.sub_int(%3000, 1)::Int64 |
|
│ %3927 = Base.mul_int(%3926, 5)::Int64 |
|
│ %3928 = Base.add_int(%3925, %3927)::Int64 |
|
│ %3929 = Base.sub_int(5, 1)::Int64 |
|
│ %3930 = Base.mul_int(%3929, 25)::Int64 |
|
│ %3931 = Base.add_int(%3928, %3930)::Int64 |
|
└──── goto #761 if not false |
|
757 ─ %3933 = Core.tuple(%3931)::Tuple{Int64} |
|
│ %3934 = Base.mul_int(5, 5)::Int64 |
|
│ %3935 = Base.mul_int(%3934, 5)::Int64 |
|
│ %3936 = Base.slt_int(%3935, 0)::Bool |
|
│ %3937 = Base.ifelse(%3936, 0, %3935)::Int64 |
|
│ %3938 = Base.sle_int(1, %3931)::Bool |
|
│ %3939 = Base.sle_int(%3931, %3937)::Bool |
|
│ %3940 = Base.and_int(%3938, %3939)::Bool |
|
└──── goto #759 if not %3940 |
|
758 ─ goto #760 |
|
759 ─ invoke Base.throw_boundserror(%9::CuDeviceArray{Float32,3,CUDAnative.AS.Shared}, %3933::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
760 ┄ nothing::Nothing |
|
761 ┄ %3946 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %3947 = Base.sub_int(%3931, 1)::Int64 |
|
│ %3948 = (%3946)($(QuoteNode(Ptr{Nothing} @0x0000000003d30348)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Shared},Int64}, %8, %3947)::Float32 |
|
└──── goto #762 |
|
762 ─ goto #763 |
|
763 ─ goto #764 |
|
764 ─ %3952 = Base.mul_float(%3086, %3948)::Float32 |
|
│ %3953 = Base.add_float(%3895, %3952)::Float32 |
|
└──── goto #769 if not false |
|
765 ─ %3955 = Core.tuple(%240)::Tuple{Int64} |
|
│ %3956 = Base.sle_int(1, %240)::Bool |
|
│ %3957 = Base.sle_int(%240, 5)::Bool |
|
│ %3958 = Base.and_int(%3956, %3957)::Bool |
|
└──── goto #767 if not %3958 |
|
766 ─ goto #768 |
|
767 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %3955::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
768 ┄ nothing::Nothing |
|
769 ┄ %3964 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %3965 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %3966 = Base.bitcast(Ptr{Float32}, %3965)::Ptr{Float32} |
|
│ Base.pointerset(%3966, %3953, %240, 1)::Ptr{Float32} |
|
│ $(Expr(:gc_preserve_end, :(%3964))) |
|
└──── goto #770 |
|
770 ─ $(Expr(:loopinfo, (Symbol("llvm.loop.unroll.full"), 1)))::Any |
|
│ %3971 = (%3001 === 5)::Bool |
|
└──── goto #772 if not %3971 |
|
771 ─ goto #773 |
|
772 ─ %3974 = Base.add_int(%3001, 1)::Int64 |
|
└──── goto #773 |
|
773 ┄ %3976 = φ (#772 => %3974)::Int64 |
|
│ %3977 = φ (#772 => %3974)::Int64 |
|
│ %3978 = φ (#771 => true, #772 => false)::Bool |
|
│ %3979 = Base.not_int(%3978)::Bool |
|
└──── goto #775 if not %3979 |
|
774 ─ goto #494 |
|
775 ┄ $(Expr(:loopinfo, (Symbol("llvm.loop.unroll.full"), 1)))::Any |
|
│ %3983 = (%241 === 5)::Bool |
|
└──── goto #777 if not %3983 |
|
776 ─ goto #778 |
|
777 ─ %3986 = Base.add_int(%241, 1)::Int64 |
|
└──── goto #778 |
|
778 ┄ %3988 = φ (#777 => %3986)::Int64 |
|
│ %3989 = φ (#777 => %3986)::Int64 |
|
│ %3990 = φ (#776 => true, #777 => false)::Bool |
|
│ %3991 = Base.not_int(%3990)::Bool |
|
└──── goto #780 if not %3991 |
|
779 ─ goto #64 |
|
780 ┄ goto #959 if not true |
|
781 ┄ %3995 = φ (#780 => 1, #958 => %5286)::Int64 |
|
│ %3996 = φ (#780 => 1, #958 => %5287)::Int64 |
|
└──── goto #786 if not false |
|
782 ─ %3998 = Core.tuple(%34, %28, %3995, 11, %18)::NTuple{5,Int64} |
|
│ %3999 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %4000 = Base.getfield(%3999, 1, true)::Int64 |
|
│ %4001 = Base.slt_int(%4000, 0)::Bool |
|
│ %4002 = Base.ifelse(%4001, 0, %4000)::Int64 |
|
│ %4003 = (getfield)(%3999, 2)::Int64 |
|
│ %4004 = (getfield)(%3999, 3)::Int64 |
|
│ %4005 = (getfield)(%3999, 4)::Int64 |
|
│ %4006 = (getfield)(%3999, 5)::Int64 |
|
│ %4007 = Base.slt_int(%4003, 0)::Bool |
|
│ %4008 = Base.ifelse(%4007, 0, %4003)::Int64 |
|
│ %4009 = Base.slt_int(%4004, 0)::Bool |
|
│ %4010 = Base.ifelse(%4009, 0, %4004)::Int64 |
|
│ %4011 = Base.slt_int(%4005, 0)::Bool |
|
│ %4012 = Base.ifelse(%4011, 0, %4005)::Int64 |
|
│ %4013 = Base.slt_int(%4006, 0)::Bool |
|
│ %4014 = Base.ifelse(%4013, 0, %4006)::Int64 |
|
│ %4015 = Base.sle_int(1, %34)::Bool |
|
│ %4016 = Base.sle_int(%34, %4002)::Bool |
|
│ %4017 = Base.and_int(%4015, %4016)::Bool |
|
│ %4018 = Base.sle_int(1, %28)::Bool |
|
│ %4019 = Base.sle_int(%28, %4008)::Bool |
|
│ %4020 = Base.and_int(%4018, %4019)::Bool |
|
│ %4021 = Base.sle_int(1, %3995)::Bool |
|
│ %4022 = Base.sle_int(%3995, %4010)::Bool |
|
│ %4023 = Base.and_int(%4021, %4022)::Bool |
|
│ %4024 = Base.sle_int(1, 11)::Bool |
|
│ %4025 = Base.sle_int(11, %4012)::Bool |
|
│ %4026 = Base.and_int(%4024, %4025)::Bool |
|
│ %4027 = Base.sle_int(1, %18)::Bool |
|
│ %4028 = Base.sle_int(%18, %4014)::Bool |
|
│ %4029 = Base.and_int(%4027, %4028)::Bool |
|
│ %4030 = Base.and_int(%4029, true)::Bool |
|
│ %4031 = Base.and_int(%4026, %4030)::Bool |
|
│ %4032 = Base.and_int(%4023, %4031)::Bool |
|
│ %4033 = Base.and_int(%4020, %4032)::Bool |
|
│ %4034 = Base.and_int(%4017, %4033)::Bool |
|
└──── goto #784 if not %4034 |
|
783 ─ goto #785 |
|
784 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %3998::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
785 ┄ nothing::Nothing |
|
786 ┄ %4040 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %4041 = Base.getfield(%4040, 1, true)::Int64 |
|
│ %4042 = Base.slt_int(%4041, 0)::Bool |
|
│ %4043 = Base.ifelse(%4042, 0, %4041)::Int64 |
|
│ %4044 = (getfield)(%4040, 2)::Int64 |
|
│ %4045 = (getfield)(%4040, 3)::Int64 |
|
│ %4046 = (getfield)(%4040, 4)::Int64 |
|
│ %4047 = Base.slt_int(%4044, 0)::Bool |
|
│ %4048 = Base.ifelse(%4047, 0, %4044)::Int64 |
|
│ %4049 = Base.slt_int(%4045, 0)::Bool |
|
│ %4050 = Base.ifelse(%4049, 0, %4045)::Int64 |
|
│ %4051 = Base.slt_int(%4046, 0)::Bool |
|
│ %4052 = Base.ifelse(%4051, 0, %4046)::Int64 |
|
│ %4053 = Base.sub_int(%4043, 0)::Int64 |
|
│ %4054 = Base.mul_int(1, %4053)::Int64 |
|
│ %4055 = Base.sub_int(%34, 1)::Int64 |
|
│ %4056 = Base.mul_int(%4055, 1)::Int64 |
|
│ %4057 = Base.add_int(1, %4056)::Int64 |
|
│ %4058 = Base.sub_int(%4048, 0)::Int64 |
|
│ %4059 = Base.mul_int(%4054, %4058)::Int64 |
|
│ %4060 = Base.sub_int(%28, 1)::Int64 |
|
│ %4061 = Base.mul_int(%4060, %4054)::Int64 |
|
│ %4062 = Base.add_int(%4057, %4061)::Int64 |
|
│ %4063 = Base.sub_int(%4050, 0)::Int64 |
|
│ %4064 = Base.mul_int(%4059, %4063)::Int64 |
|
│ %4065 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4066 = Base.mul_int(%4065, %4059)::Int64 |
|
│ %4067 = Base.add_int(%4062, %4066)::Int64 |
|
│ %4068 = Base.sub_int(%4052, 0)::Int64 |
|
│ %4069 = Base.mul_int(%4064, %4068)::Int64 |
|
│ %4070 = Base.sub_int(11, 1)::Int64 |
|
│ %4071 = Base.mul_int(%4070, %4064)::Int64 |
|
│ %4072 = Base.add_int(%4067, %4071)::Int64 |
|
│ %4073 = Base.sub_int(%18, 1)::Int64 |
|
│ %4074 = Base.mul_int(%4073, %4069)::Int64 |
|
│ %4075 = Base.add_int(%4072, %4074)::Int64 |
|
└──── goto #791 if not false |
|
787 ─ %4077 = Core.tuple(%4075)::Tuple{Int64} |
|
│ %4078 = Base.getfield(vgeo, :shape)::NTuple{5,Int64} |
|
│ %4079 = (getfield)(%4078, 1)::Int64 |
|
│ %4080 = (getfield)(%4078, 2)::Int64 |
|
│ %4081 = (getfield)(%4078, 3)::Int64 |
|
│ %4082 = (getfield)(%4078, 4)::Int64 |
|
│ %4083 = (getfield)(%4078, 5)::Int64 |
|
│ %4084 = Base.mul_int(%4079, %4080)::Int64 |
|
│ %4085 = Base.mul_int(%4084, %4081)::Int64 |
|
│ %4086 = Base.mul_int(%4085, %4082)::Int64 |
|
│ %4087 = Base.mul_int(%4086, %4083)::Int64 |
|
│ %4088 = Base.slt_int(%4087, 0)::Bool |
|
│ %4089 = Base.ifelse(%4088, 0, %4087)::Int64 |
|
│ %4090 = Base.sle_int(1, %4075)::Bool |
|
│ %4091 = Base.sle_int(%4075, %4089)::Bool |
|
│ %4092 = Base.and_int(%4090, %4091)::Bool |
|
└──── goto #789 if not %4092 |
|
788 ─ goto #790 |
|
789 ─ invoke Base.throw_boundserror(_5::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4077::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
790 ┄ nothing::Nothing |
|
791 ┄ %4098 = Base.getfield(vgeo, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4099 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4100 = Base.sub_int(%4075, 1)::Int64 |
|
│ %4101 = (%4099)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %4098, %4100)::Float32 |
|
└──── goto #792 |
|
792 ─ goto #793 |
|
793 ─ goto #794 |
|
794 ─ goto #799 if not false |
|
795 ─ %4106 = Core.tuple(%34, %28, %3995, 2, %18)::NTuple{5,Int64} |
|
│ %4107 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4108 = Base.getfield(%4107, 1, true)::Int64 |
|
│ %4109 = Base.slt_int(%4108, 0)::Bool |
|
│ %4110 = Base.ifelse(%4109, 0, %4108)::Int64 |
|
│ %4111 = (getfield)(%4107, 2)::Int64 |
|
│ %4112 = (getfield)(%4107, 3)::Int64 |
|
│ %4113 = (getfield)(%4107, 4)::Int64 |
|
│ %4114 = (getfield)(%4107, 5)::Int64 |
|
│ %4115 = Base.slt_int(%4111, 0)::Bool |
|
│ %4116 = Base.ifelse(%4115, 0, %4111)::Int64 |
|
│ %4117 = Base.slt_int(%4112, 0)::Bool |
|
│ %4118 = Base.ifelse(%4117, 0, %4112)::Int64 |
|
│ %4119 = Base.slt_int(%4113, 0)::Bool |
|
│ %4120 = Base.ifelse(%4119, 0, %4113)::Int64 |
|
│ %4121 = Base.slt_int(%4114, 0)::Bool |
|
│ %4122 = Base.ifelse(%4121, 0, %4114)::Int64 |
|
│ %4123 = Base.sle_int(1, %34)::Bool |
|
│ %4124 = Base.sle_int(%34, %4110)::Bool |
|
│ %4125 = Base.and_int(%4123, %4124)::Bool |
|
│ %4126 = Base.sle_int(1, %28)::Bool |
|
│ %4127 = Base.sle_int(%28, %4116)::Bool |
|
│ %4128 = Base.and_int(%4126, %4127)::Bool |
|
│ %4129 = Base.sle_int(1, %3995)::Bool |
|
│ %4130 = Base.sle_int(%3995, %4118)::Bool |
|
│ %4131 = Base.and_int(%4129, %4130)::Bool |
|
│ %4132 = Base.sle_int(1, 2)::Bool |
|
│ %4133 = Base.sle_int(2, %4120)::Bool |
|
│ %4134 = Base.and_int(%4132, %4133)::Bool |
|
│ %4135 = Base.sle_int(1, %18)::Bool |
|
│ %4136 = Base.sle_int(%18, %4122)::Bool |
|
│ %4137 = Base.and_int(%4135, %4136)::Bool |
|
│ %4138 = Base.and_int(%4137, true)::Bool |
|
│ %4139 = Base.and_int(%4134, %4138)::Bool |
|
│ %4140 = Base.and_int(%4131, %4139)::Bool |
|
│ %4141 = Base.and_int(%4128, %4140)::Bool |
|
│ %4142 = Base.and_int(%4125, %4141)::Bool |
|
└──── goto #797 if not %4142 |
|
796 ─ goto #798 |
|
797 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4106::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
798 ┄ nothing::Nothing |
|
799 ┄ %4148 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4149 = Base.getfield(%4148, 1, true)::Int64 |
|
│ %4150 = Base.slt_int(%4149, 0)::Bool |
|
│ %4151 = Base.ifelse(%4150, 0, %4149)::Int64 |
|
│ %4152 = (getfield)(%4148, 2)::Int64 |
|
│ %4153 = (getfield)(%4148, 3)::Int64 |
|
│ %4154 = (getfield)(%4148, 4)::Int64 |
|
│ %4155 = Base.slt_int(%4152, 0)::Bool |
|
│ %4156 = Base.ifelse(%4155, 0, %4152)::Int64 |
|
│ %4157 = Base.slt_int(%4153, 0)::Bool |
|
│ %4158 = Base.ifelse(%4157, 0, %4153)::Int64 |
|
│ %4159 = Base.slt_int(%4154, 0)::Bool |
|
│ %4160 = Base.ifelse(%4159, 0, %4154)::Int64 |
|
│ %4161 = Base.sub_int(%4151, 0)::Int64 |
|
│ %4162 = Base.mul_int(1, %4161)::Int64 |
|
│ %4163 = Base.sub_int(%34, 1)::Int64 |
|
│ %4164 = Base.mul_int(%4163, 1)::Int64 |
|
│ %4165 = Base.add_int(1, %4164)::Int64 |
|
│ %4166 = Base.sub_int(%4156, 0)::Int64 |
|
│ %4167 = Base.mul_int(%4162, %4166)::Int64 |
|
│ %4168 = Base.sub_int(%28, 1)::Int64 |
|
│ %4169 = Base.mul_int(%4168, %4162)::Int64 |
|
│ %4170 = Base.add_int(%4165, %4169)::Int64 |
|
│ %4171 = Base.sub_int(%4158, 0)::Int64 |
|
│ %4172 = Base.mul_int(%4167, %4171)::Int64 |
|
│ %4173 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4174 = Base.mul_int(%4173, %4167)::Int64 |
|
│ %4175 = Base.add_int(%4170, %4174)::Int64 |
|
│ %4176 = Base.sub_int(%4160, 0)::Int64 |
|
│ %4177 = Base.mul_int(%4172, %4176)::Int64 |
|
│ %4178 = Base.sub_int(2, 1)::Int64 |
|
│ %4179 = Base.mul_int(%4178, %4172)::Int64 |
|
│ %4180 = Base.add_int(%4175, %4179)::Int64 |
|
│ %4181 = Base.sub_int(%18, 1)::Int64 |
|
│ %4182 = Base.mul_int(%4181, %4177)::Int64 |
|
│ %4183 = Base.add_int(%4180, %4182)::Int64 |
|
└──── goto #804 if not false |
|
800 ─ %4185 = Core.tuple(%4183)::Tuple{Int64} |
|
│ %4186 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4187 = (getfield)(%4186, 1)::Int64 |
|
│ %4188 = (getfield)(%4186, 2)::Int64 |
|
│ %4189 = (getfield)(%4186, 3)::Int64 |
|
│ %4190 = (getfield)(%4186, 4)::Int64 |
|
│ %4191 = (getfield)(%4186, 5)::Int64 |
|
│ %4192 = Base.mul_int(%4187, %4188)::Int64 |
|
│ %4193 = Base.mul_int(%4192, %4189)::Int64 |
|
│ %4194 = Base.mul_int(%4193, %4190)::Int64 |
|
│ %4195 = Base.mul_int(%4194, %4191)::Int64 |
|
│ %4196 = Base.slt_int(%4195, 0)::Bool |
|
│ %4197 = Base.ifelse(%4196, 0, %4195)::Int64 |
|
│ %4198 = Base.sle_int(1, %4183)::Bool |
|
│ %4199 = Base.sle_int(%4183, %4197)::Bool |
|
│ %4200 = Base.and_int(%4198, %4199)::Bool |
|
└──── goto #802 if not %4200 |
|
801 ─ goto #803 |
|
802 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4185::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
803 ┄ nothing::Nothing |
|
804 ┄ %4206 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4207 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4208 = Base.sub_int(%4183, 1)::Int64 |
|
│ %4209 = (%4207)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %4206, %4208)::Float32 |
|
└──── goto #805 |
|
805 ─ goto #806 |
|
806 ─ goto #807 |
|
807 ─ goto #812 if not false |
|
808 ─ %4214 = Core.tuple(%3995)::Tuple{Int64} |
|
│ %4215 = Base.sle_int(1, %3995)::Bool |
|
│ %4216 = Base.sle_int(%3995, 5)::Bool |
|
│ %4217 = Base.and_int(%4215, %4216)::Bool |
|
└──── goto #810 if not %4217 |
|
809 ─ goto #811 |
|
810 ─ invoke Base.throw_boundserror(%11::MArray{Tuple{5},Float32,1,5}, %4214::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
811 ┄ nothing::Nothing |
|
812 ┄ %4223 = $(Expr(:gc_preserve_begin, :(%11))) |
|
│ %4224 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%11)))::Ptr{Nothing} |
|
│ %4225 = Base.bitcast(Ptr{Float32}, %4224)::Ptr{Float32} |
|
│ %4226 = Base.pointerref(%4225, %3995, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%4223))) |
|
└──── goto #813 |
|
813 ─ %4229 = Base.mul_float(%4101, %4226)::Float32 |
|
│ %4230 = Base.add_float(%4209, %4229)::Float32 |
|
│ %4231 = Main._U::Core.Compiler.Const(2, false) |
|
└──── goto #818 if not false |
|
814 ─ %4233 = Core.tuple(%34, %28, %3995, %4231, %18)::NTuple{5,Int64} |
|
│ %4234 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4235 = Base.getfield(%4234, 1, true)::Int64 |
|
│ %4236 = Base.slt_int(%4235, 0)::Bool |
|
│ %4237 = Base.ifelse(%4236, 0, %4235)::Int64 |
|
│ %4238 = (getfield)(%4234, 2)::Int64 |
|
│ %4239 = (getfield)(%4234, 3)::Int64 |
|
│ %4240 = (getfield)(%4234, 4)::Int64 |
|
│ %4241 = (getfield)(%4234, 5)::Int64 |
|
│ %4242 = Base.slt_int(%4238, 0)::Bool |
|
│ %4243 = Base.ifelse(%4242, 0, %4238)::Int64 |
|
│ %4244 = Base.slt_int(%4239, 0)::Bool |
|
│ %4245 = Base.ifelse(%4244, 0, %4239)::Int64 |
|
│ %4246 = Base.slt_int(%4240, 0)::Bool |
|
│ %4247 = Base.ifelse(%4246, 0, %4240)::Int64 |
|
│ %4248 = Base.slt_int(%4241, 0)::Bool |
|
│ %4249 = Base.ifelse(%4248, 0, %4241)::Int64 |
|
│ %4250 = Base.sle_int(1, %34)::Bool |
|
│ %4251 = Base.sle_int(%34, %4237)::Bool |
|
│ %4252 = Base.and_int(%4250, %4251)::Bool |
|
│ %4253 = Base.sle_int(1, %28)::Bool |
|
│ %4254 = Base.sle_int(%28, %4243)::Bool |
|
│ %4255 = Base.and_int(%4253, %4254)::Bool |
|
│ %4256 = Base.sle_int(1, %3995)::Bool |
|
│ %4257 = Base.sle_int(%3995, %4245)::Bool |
|
│ %4258 = Base.and_int(%4256, %4257)::Bool |
|
│ %4259 = Base.sle_int(1, %4231)::Bool |
|
│ %4260 = Base.sle_int(%4231, %4247)::Bool |
|
│ %4261 = Base.and_int(%4259, %4260)::Bool |
|
│ %4262 = Base.sle_int(1, %18)::Bool |
|
│ %4263 = Base.sle_int(%18, %4249)::Bool |
|
│ %4264 = Base.and_int(%4262, %4263)::Bool |
|
│ %4265 = Base.and_int(%4264, true)::Bool |
|
│ %4266 = Base.and_int(%4261, %4265)::Bool |
|
│ %4267 = Base.and_int(%4258, %4266)::Bool |
|
│ %4268 = Base.and_int(%4255, %4267)::Bool |
|
│ %4269 = Base.and_int(%4252, %4268)::Bool |
|
└──── goto #816 if not %4269 |
|
815 ─ goto #817 |
|
816 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4233::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
817 ┄ nothing::Nothing |
|
818 ┄ %4275 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4276 = Base.getfield(%4275, 1, true)::Int64 |
|
│ %4277 = Base.slt_int(%4276, 0)::Bool |
|
│ %4278 = Base.ifelse(%4277, 0, %4276)::Int64 |
|
│ %4279 = (getfield)(%4275, 2)::Int64 |
|
│ %4280 = (getfield)(%4275, 3)::Int64 |
|
│ %4281 = (getfield)(%4275, 4)::Int64 |
|
│ %4282 = Base.slt_int(%4279, 0)::Bool |
|
│ %4283 = Base.ifelse(%4282, 0, %4279)::Int64 |
|
│ %4284 = Base.slt_int(%4280, 0)::Bool |
|
│ %4285 = Base.ifelse(%4284, 0, %4280)::Int64 |
|
│ %4286 = Base.slt_int(%4281, 0)::Bool |
|
│ %4287 = Base.ifelse(%4286, 0, %4281)::Int64 |
|
│ %4288 = Base.sub_int(%4278, 0)::Int64 |
|
│ %4289 = Base.mul_int(1, %4288)::Int64 |
|
│ %4290 = Base.sub_int(%34, 1)::Int64 |
|
│ %4291 = Base.mul_int(%4290, 1)::Int64 |
|
│ %4292 = Base.add_int(1, %4291)::Int64 |
|
│ %4293 = Base.sub_int(%4283, 0)::Int64 |
|
│ %4294 = Base.mul_int(%4289, %4293)::Int64 |
|
│ %4295 = Base.sub_int(%28, 1)::Int64 |
|
│ %4296 = Base.mul_int(%4295, %4289)::Int64 |
|
│ %4297 = Base.add_int(%4292, %4296)::Int64 |
|
│ %4298 = Base.sub_int(%4285, 0)::Int64 |
|
│ %4299 = Base.mul_int(%4294, %4298)::Int64 |
|
│ %4300 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4301 = Base.mul_int(%4300, %4294)::Int64 |
|
│ %4302 = Base.add_int(%4297, %4301)::Int64 |
|
│ %4303 = Base.sub_int(%4287, 0)::Int64 |
|
│ %4304 = Base.mul_int(%4299, %4303)::Int64 |
|
│ %4305 = Base.sub_int(%4231, 1)::Int64 |
|
│ %4306 = Base.mul_int(%4305, %4299)::Int64 |
|
│ %4307 = Base.add_int(%4302, %4306)::Int64 |
|
│ %4308 = Base.sub_int(%18, 1)::Int64 |
|
│ %4309 = Base.mul_int(%4308, %4304)::Int64 |
|
│ %4310 = Base.add_int(%4307, %4309)::Int64 |
|
└──── goto #823 if not false |
|
819 ─ %4312 = Core.tuple(%4310)::Tuple{Int64} |
|
│ %4313 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4314 = (getfield)(%4313, 1)::Int64 |
|
│ %4315 = (getfield)(%4313, 2)::Int64 |
|
│ %4316 = (getfield)(%4313, 3)::Int64 |
|
│ %4317 = (getfield)(%4313, 4)::Int64 |
|
│ %4318 = (getfield)(%4313, 5)::Int64 |
|
│ %4319 = Base.mul_int(%4314, %4315)::Int64 |
|
│ %4320 = Base.mul_int(%4319, %4316)::Int64 |
|
│ %4321 = Base.mul_int(%4320, %4317)::Int64 |
|
│ %4322 = Base.mul_int(%4321, %4318)::Int64 |
|
│ %4323 = Base.slt_int(%4322, 0)::Bool |
|
│ %4324 = Base.ifelse(%4323, 0, %4322)::Int64 |
|
│ %4325 = Base.sle_int(1, %4310)::Bool |
|
│ %4326 = Base.sle_int(%4310, %4324)::Bool |
|
│ %4327 = Base.and_int(%4325, %4326)::Bool |
|
└──── goto #821 if not %4327 |
|
820 ─ goto #822 |
|
821 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4312::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
822 ┄ nothing::Nothing |
|
823 ┄ %4333 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4334 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4335 = Base.sub_int(%4310, 1)::Int64 |
|
│ (%4334)($(QuoteNode(Ptr{Nothing} @0x0000000002ffdd58)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Float32,Int64}, %4333, %4230, %4335)::Nothing |
|
└──── goto #824 |
|
824 ─ goto #825 |
|
825 ─ goto #826 |
|
826 ─ goto #831 if not false |
|
827 ─ %4341 = Core.tuple(%34, %28, %3995, 3, %18)::NTuple{5,Int64} |
|
│ %4342 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4343 = Base.getfield(%4342, 1, true)::Int64 |
|
│ %4344 = Base.slt_int(%4343, 0)::Bool |
|
│ %4345 = Base.ifelse(%4344, 0, %4343)::Int64 |
|
│ %4346 = (getfield)(%4342, 2)::Int64 |
|
│ %4347 = (getfield)(%4342, 3)::Int64 |
|
│ %4348 = (getfield)(%4342, 4)::Int64 |
|
│ %4349 = (getfield)(%4342, 5)::Int64 |
|
│ %4350 = Base.slt_int(%4346, 0)::Bool |
|
│ %4351 = Base.ifelse(%4350, 0, %4346)::Int64 |
|
│ %4352 = Base.slt_int(%4347, 0)::Bool |
|
│ %4353 = Base.ifelse(%4352, 0, %4347)::Int64 |
|
│ %4354 = Base.slt_int(%4348, 0)::Bool |
|
│ %4355 = Base.ifelse(%4354, 0, %4348)::Int64 |
|
│ %4356 = Base.slt_int(%4349, 0)::Bool |
|
│ %4357 = Base.ifelse(%4356, 0, %4349)::Int64 |
|
│ %4358 = Base.sle_int(1, %34)::Bool |
|
│ %4359 = Base.sle_int(%34, %4345)::Bool |
|
│ %4360 = Base.and_int(%4358, %4359)::Bool |
|
│ %4361 = Base.sle_int(1, %28)::Bool |
|
│ %4362 = Base.sle_int(%28, %4351)::Bool |
|
│ %4363 = Base.and_int(%4361, %4362)::Bool |
|
│ %4364 = Base.sle_int(1, %3995)::Bool |
|
│ %4365 = Base.sle_int(%3995, %4353)::Bool |
|
│ %4366 = Base.and_int(%4364, %4365)::Bool |
|
│ %4367 = Base.sle_int(1, 3)::Bool |
|
│ %4368 = Base.sle_int(3, %4355)::Bool |
|
│ %4369 = Base.and_int(%4367, %4368)::Bool |
|
│ %4370 = Base.sle_int(1, %18)::Bool |
|
│ %4371 = Base.sle_int(%18, %4357)::Bool |
|
│ %4372 = Base.and_int(%4370, %4371)::Bool |
|
│ %4373 = Base.and_int(%4372, true)::Bool |
|
│ %4374 = Base.and_int(%4369, %4373)::Bool |
|
│ %4375 = Base.and_int(%4366, %4374)::Bool |
|
│ %4376 = Base.and_int(%4363, %4375)::Bool |
|
│ %4377 = Base.and_int(%4360, %4376)::Bool |
|
└──── goto #829 if not %4377 |
|
828 ─ goto #830 |
|
829 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4341::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
830 ┄ nothing::Nothing |
|
831 ┄ %4383 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4384 = Base.getfield(%4383, 1, true)::Int64 |
|
│ %4385 = Base.slt_int(%4384, 0)::Bool |
|
│ %4386 = Base.ifelse(%4385, 0, %4384)::Int64 |
|
│ %4387 = (getfield)(%4383, 2)::Int64 |
|
│ %4388 = (getfield)(%4383, 3)::Int64 |
|
│ %4389 = (getfield)(%4383, 4)::Int64 |
|
│ %4390 = Base.slt_int(%4387, 0)::Bool |
|
│ %4391 = Base.ifelse(%4390, 0, %4387)::Int64 |
|
│ %4392 = Base.slt_int(%4388, 0)::Bool |
|
│ %4393 = Base.ifelse(%4392, 0, %4388)::Int64 |
|
│ %4394 = Base.slt_int(%4389, 0)::Bool |
|
│ %4395 = Base.ifelse(%4394, 0, %4389)::Int64 |
|
│ %4396 = Base.sub_int(%4386, 0)::Int64 |
|
│ %4397 = Base.mul_int(1, %4396)::Int64 |
|
│ %4398 = Base.sub_int(%34, 1)::Int64 |
|
│ %4399 = Base.mul_int(%4398, 1)::Int64 |
|
│ %4400 = Base.add_int(1, %4399)::Int64 |
|
│ %4401 = Base.sub_int(%4391, 0)::Int64 |
|
│ %4402 = Base.mul_int(%4397, %4401)::Int64 |
|
│ %4403 = Base.sub_int(%28, 1)::Int64 |
|
│ %4404 = Base.mul_int(%4403, %4397)::Int64 |
|
│ %4405 = Base.add_int(%4400, %4404)::Int64 |
|
│ %4406 = Base.sub_int(%4393, 0)::Int64 |
|
│ %4407 = Base.mul_int(%4402, %4406)::Int64 |
|
│ %4408 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4409 = Base.mul_int(%4408, %4402)::Int64 |
|
│ %4410 = Base.add_int(%4405, %4409)::Int64 |
|
│ %4411 = Base.sub_int(%4395, 0)::Int64 |
|
│ %4412 = Base.mul_int(%4407, %4411)::Int64 |
|
│ %4413 = Base.sub_int(3, 1)::Int64 |
|
│ %4414 = Base.mul_int(%4413, %4407)::Int64 |
|
│ %4415 = Base.add_int(%4410, %4414)::Int64 |
|
│ %4416 = Base.sub_int(%18, 1)::Int64 |
|
│ %4417 = Base.mul_int(%4416, %4412)::Int64 |
|
│ %4418 = Base.add_int(%4415, %4417)::Int64 |
|
└──── goto #836 if not false |
|
832 ─ %4420 = Core.tuple(%4418)::Tuple{Int64} |
|
│ %4421 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4422 = (getfield)(%4421, 1)::Int64 |
|
│ %4423 = (getfield)(%4421, 2)::Int64 |
|
│ %4424 = (getfield)(%4421, 3)::Int64 |
|
│ %4425 = (getfield)(%4421, 4)::Int64 |
|
│ %4426 = (getfield)(%4421, 5)::Int64 |
|
│ %4427 = Base.mul_int(%4422, %4423)::Int64 |
|
│ %4428 = Base.mul_int(%4427, %4424)::Int64 |
|
│ %4429 = Base.mul_int(%4428, %4425)::Int64 |
|
│ %4430 = Base.mul_int(%4429, %4426)::Int64 |
|
│ %4431 = Base.slt_int(%4430, 0)::Bool |
|
│ %4432 = Base.ifelse(%4431, 0, %4430)::Int64 |
|
│ %4433 = Base.sle_int(1, %4418)::Bool |
|
│ %4434 = Base.sle_int(%4418, %4432)::Bool |
|
│ %4435 = Base.and_int(%4433, %4434)::Bool |
|
└──── goto #834 if not %4435 |
|
833 ─ goto #835 |
|
834 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4420::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
835 ┄ nothing::Nothing |
|
836 ┄ %4441 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4442 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4443 = Base.sub_int(%4418, 1)::Int64 |
|
│ %4444 = (%4442)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %4441, %4443)::Float32 |
|
└──── goto #837 |
|
837 ─ goto #838 |
|
838 ─ goto #839 |
|
839 ─ goto #844 if not false |
|
840 ─ %4449 = Core.tuple(%3995)::Tuple{Int64} |
|
│ %4450 = Base.sle_int(1, %3995)::Bool |
|
│ %4451 = Base.sle_int(%3995, 5)::Bool |
|
│ %4452 = Base.and_int(%4450, %4451)::Bool |
|
└──── goto #842 if not %4452 |
|
841 ─ goto #843 |
|
842 ─ invoke Base.throw_boundserror(%12::MArray{Tuple{5},Float32,1,5}, %4449::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
843 ┄ nothing::Nothing |
|
844 ┄ %4458 = $(Expr(:gc_preserve_begin, :(%12))) |
|
│ %4459 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%12)))::Ptr{Nothing} |
|
│ %4460 = Base.bitcast(Ptr{Float32}, %4459)::Ptr{Float32} |
|
│ %4461 = Base.pointerref(%4460, %3995, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%4458))) |
|
└──── goto #845 |
|
845 ─ %4464 = Base.mul_float(%4101, %4461)::Float32 |
|
│ %4465 = Base.add_float(%4444, %4464)::Float32 |
|
│ %4466 = Main._V::Core.Compiler.Const(3, false) |
|
└──── goto #850 if not false |
|
846 ─ %4468 = Core.tuple(%34, %28, %3995, %4466, %18)::NTuple{5,Int64} |
|
│ %4469 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4470 = Base.getfield(%4469, 1, true)::Int64 |
|
│ %4471 = Base.slt_int(%4470, 0)::Bool |
|
│ %4472 = Base.ifelse(%4471, 0, %4470)::Int64 |
|
│ %4473 = (getfield)(%4469, 2)::Int64 |
|
│ %4474 = (getfield)(%4469, 3)::Int64 |
|
│ %4475 = (getfield)(%4469, 4)::Int64 |
|
│ %4476 = (getfield)(%4469, 5)::Int64 |
|
│ %4477 = Base.slt_int(%4473, 0)::Bool |
|
│ %4478 = Base.ifelse(%4477, 0, %4473)::Int64 |
|
│ %4479 = Base.slt_int(%4474, 0)::Bool |
|
│ %4480 = Base.ifelse(%4479, 0, %4474)::Int64 |
|
│ %4481 = Base.slt_int(%4475, 0)::Bool |
|
│ %4482 = Base.ifelse(%4481, 0, %4475)::Int64 |
|
│ %4483 = Base.slt_int(%4476, 0)::Bool |
|
│ %4484 = Base.ifelse(%4483, 0, %4476)::Int64 |
|
│ %4485 = Base.sle_int(1, %34)::Bool |
|
│ %4486 = Base.sle_int(%34, %4472)::Bool |
|
│ %4487 = Base.and_int(%4485, %4486)::Bool |
|
│ %4488 = Base.sle_int(1, %28)::Bool |
|
│ %4489 = Base.sle_int(%28, %4478)::Bool |
|
│ %4490 = Base.and_int(%4488, %4489)::Bool |
|
│ %4491 = Base.sle_int(1, %3995)::Bool |
|
│ %4492 = Base.sle_int(%3995, %4480)::Bool |
|
│ %4493 = Base.and_int(%4491, %4492)::Bool |
|
│ %4494 = Base.sle_int(1, %4466)::Bool |
|
│ %4495 = Base.sle_int(%4466, %4482)::Bool |
|
│ %4496 = Base.and_int(%4494, %4495)::Bool |
|
│ %4497 = Base.sle_int(1, %18)::Bool |
|
│ %4498 = Base.sle_int(%18, %4484)::Bool |
|
│ %4499 = Base.and_int(%4497, %4498)::Bool |
|
│ %4500 = Base.and_int(%4499, true)::Bool |
|
│ %4501 = Base.and_int(%4496, %4500)::Bool |
|
│ %4502 = Base.and_int(%4493, %4501)::Bool |
|
│ %4503 = Base.and_int(%4490, %4502)::Bool |
|
│ %4504 = Base.and_int(%4487, %4503)::Bool |
|
└──── goto #848 if not %4504 |
|
847 ─ goto #849 |
|
848 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4468::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
849 ┄ nothing::Nothing |
|
850 ┄ %4510 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4511 = Base.getfield(%4510, 1, true)::Int64 |
|
│ %4512 = Base.slt_int(%4511, 0)::Bool |
|
│ %4513 = Base.ifelse(%4512, 0, %4511)::Int64 |
|
│ %4514 = (getfield)(%4510, 2)::Int64 |
|
│ %4515 = (getfield)(%4510, 3)::Int64 |
|
│ %4516 = (getfield)(%4510, 4)::Int64 |
|
│ %4517 = Base.slt_int(%4514, 0)::Bool |
|
│ %4518 = Base.ifelse(%4517, 0, %4514)::Int64 |
|
│ %4519 = Base.slt_int(%4515, 0)::Bool |
|
│ %4520 = Base.ifelse(%4519, 0, %4515)::Int64 |
|
│ %4521 = Base.slt_int(%4516, 0)::Bool |
|
│ %4522 = Base.ifelse(%4521, 0, %4516)::Int64 |
|
│ %4523 = Base.sub_int(%4513, 0)::Int64 |
|
│ %4524 = Base.mul_int(1, %4523)::Int64 |
|
│ %4525 = Base.sub_int(%34, 1)::Int64 |
|
│ %4526 = Base.mul_int(%4525, 1)::Int64 |
|
│ %4527 = Base.add_int(1, %4526)::Int64 |
|
│ %4528 = Base.sub_int(%4518, 0)::Int64 |
|
│ %4529 = Base.mul_int(%4524, %4528)::Int64 |
|
│ %4530 = Base.sub_int(%28, 1)::Int64 |
|
│ %4531 = Base.mul_int(%4530, %4524)::Int64 |
|
│ %4532 = Base.add_int(%4527, %4531)::Int64 |
|
│ %4533 = Base.sub_int(%4520, 0)::Int64 |
|
│ %4534 = Base.mul_int(%4529, %4533)::Int64 |
|
│ %4535 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4536 = Base.mul_int(%4535, %4529)::Int64 |
|
│ %4537 = Base.add_int(%4532, %4536)::Int64 |
|
│ %4538 = Base.sub_int(%4522, 0)::Int64 |
|
│ %4539 = Base.mul_int(%4534, %4538)::Int64 |
|
│ %4540 = Base.sub_int(%4466, 1)::Int64 |
|
│ %4541 = Base.mul_int(%4540, %4534)::Int64 |
|
│ %4542 = Base.add_int(%4537, %4541)::Int64 |
|
│ %4543 = Base.sub_int(%18, 1)::Int64 |
|
│ %4544 = Base.mul_int(%4543, %4539)::Int64 |
|
│ %4545 = Base.add_int(%4542, %4544)::Int64 |
|
└──── goto #855 if not false |
|
851 ─ %4547 = Core.tuple(%4545)::Tuple{Int64} |
|
│ %4548 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4549 = (getfield)(%4548, 1)::Int64 |
|
│ %4550 = (getfield)(%4548, 2)::Int64 |
|
│ %4551 = (getfield)(%4548, 3)::Int64 |
|
│ %4552 = (getfield)(%4548, 4)::Int64 |
|
│ %4553 = (getfield)(%4548, 5)::Int64 |
|
│ %4554 = Base.mul_int(%4549, %4550)::Int64 |
|
│ %4555 = Base.mul_int(%4554, %4551)::Int64 |
|
│ %4556 = Base.mul_int(%4555, %4552)::Int64 |
|
│ %4557 = Base.mul_int(%4556, %4553)::Int64 |
|
│ %4558 = Base.slt_int(%4557, 0)::Bool |
|
│ %4559 = Base.ifelse(%4558, 0, %4557)::Int64 |
|
│ %4560 = Base.sle_int(1, %4545)::Bool |
|
│ %4561 = Base.sle_int(%4545, %4559)::Bool |
|
│ %4562 = Base.and_int(%4560, %4561)::Bool |
|
└──── goto #853 if not %4562 |
|
852 ─ goto #854 |
|
853 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4547::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
854 ┄ nothing::Nothing |
|
855 ┄ %4568 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4569 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4570 = Base.sub_int(%4545, 1)::Int64 |
|
│ (%4569)($(QuoteNode(Ptr{Nothing} @0x0000000002ffdd58)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Float32,Int64}, %4568, %4465, %4570)::Nothing |
|
└──── goto #856 |
|
856 ─ goto #857 |
|
857 ─ goto #858 |
|
858 ─ goto #863 if not false |
|
859 ─ %4576 = Core.tuple(%34, %28, %3995, 4, %18)::NTuple{5,Int64} |
|
│ %4577 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4578 = Base.getfield(%4577, 1, true)::Int64 |
|
│ %4579 = Base.slt_int(%4578, 0)::Bool |
|
│ %4580 = Base.ifelse(%4579, 0, %4578)::Int64 |
|
│ %4581 = (getfield)(%4577, 2)::Int64 |
|
│ %4582 = (getfield)(%4577, 3)::Int64 |
|
│ %4583 = (getfield)(%4577, 4)::Int64 |
|
│ %4584 = (getfield)(%4577, 5)::Int64 |
|
│ %4585 = Base.slt_int(%4581, 0)::Bool |
|
│ %4586 = Base.ifelse(%4585, 0, %4581)::Int64 |
|
│ %4587 = Base.slt_int(%4582, 0)::Bool |
|
│ %4588 = Base.ifelse(%4587, 0, %4582)::Int64 |
|
│ %4589 = Base.slt_int(%4583, 0)::Bool |
|
│ %4590 = Base.ifelse(%4589, 0, %4583)::Int64 |
|
│ %4591 = Base.slt_int(%4584, 0)::Bool |
|
│ %4592 = Base.ifelse(%4591, 0, %4584)::Int64 |
|
│ %4593 = Base.sle_int(1, %34)::Bool |
|
│ %4594 = Base.sle_int(%34, %4580)::Bool |
|
│ %4595 = Base.and_int(%4593, %4594)::Bool |
|
│ %4596 = Base.sle_int(1, %28)::Bool |
|
│ %4597 = Base.sle_int(%28, %4586)::Bool |
|
│ %4598 = Base.and_int(%4596, %4597)::Bool |
|
│ %4599 = Base.sle_int(1, %3995)::Bool |
|
│ %4600 = Base.sle_int(%3995, %4588)::Bool |
|
│ %4601 = Base.and_int(%4599, %4600)::Bool |
|
│ %4602 = Base.sle_int(1, 4)::Bool |
|
│ %4603 = Base.sle_int(4, %4590)::Bool |
|
│ %4604 = Base.and_int(%4602, %4603)::Bool |
|
│ %4605 = Base.sle_int(1, %18)::Bool |
|
│ %4606 = Base.sle_int(%18, %4592)::Bool |
|
│ %4607 = Base.and_int(%4605, %4606)::Bool |
|
│ %4608 = Base.and_int(%4607, true)::Bool |
|
│ %4609 = Base.and_int(%4604, %4608)::Bool |
|
│ %4610 = Base.and_int(%4601, %4609)::Bool |
|
│ %4611 = Base.and_int(%4598, %4610)::Bool |
|
│ %4612 = Base.and_int(%4595, %4611)::Bool |
|
└──── goto #861 if not %4612 |
|
860 ─ goto #862 |
|
861 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4576::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
862 ┄ nothing::Nothing |
|
863 ┄ %4618 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4619 = Base.getfield(%4618, 1, true)::Int64 |
|
│ %4620 = Base.slt_int(%4619, 0)::Bool |
|
│ %4621 = Base.ifelse(%4620, 0, %4619)::Int64 |
|
│ %4622 = (getfield)(%4618, 2)::Int64 |
|
│ %4623 = (getfield)(%4618, 3)::Int64 |
|
│ %4624 = (getfield)(%4618, 4)::Int64 |
|
│ %4625 = Base.slt_int(%4622, 0)::Bool |
|
│ %4626 = Base.ifelse(%4625, 0, %4622)::Int64 |
|
│ %4627 = Base.slt_int(%4623, 0)::Bool |
|
│ %4628 = Base.ifelse(%4627, 0, %4623)::Int64 |
|
│ %4629 = Base.slt_int(%4624, 0)::Bool |
|
│ %4630 = Base.ifelse(%4629, 0, %4624)::Int64 |
|
│ %4631 = Base.sub_int(%4621, 0)::Int64 |
|
│ %4632 = Base.mul_int(1, %4631)::Int64 |
|
│ %4633 = Base.sub_int(%34, 1)::Int64 |
|
│ %4634 = Base.mul_int(%4633, 1)::Int64 |
|
│ %4635 = Base.add_int(1, %4634)::Int64 |
|
│ %4636 = Base.sub_int(%4626, 0)::Int64 |
|
│ %4637 = Base.mul_int(%4632, %4636)::Int64 |
|
│ %4638 = Base.sub_int(%28, 1)::Int64 |
|
│ %4639 = Base.mul_int(%4638, %4632)::Int64 |
|
│ %4640 = Base.add_int(%4635, %4639)::Int64 |
|
│ %4641 = Base.sub_int(%4628, 0)::Int64 |
|
│ %4642 = Base.mul_int(%4637, %4641)::Int64 |
|
│ %4643 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4644 = Base.mul_int(%4643, %4637)::Int64 |
|
│ %4645 = Base.add_int(%4640, %4644)::Int64 |
|
│ %4646 = Base.sub_int(%4630, 0)::Int64 |
|
│ %4647 = Base.mul_int(%4642, %4646)::Int64 |
|
│ %4648 = Base.sub_int(4, 1)::Int64 |
|
│ %4649 = Base.mul_int(%4648, %4642)::Int64 |
|
│ %4650 = Base.add_int(%4645, %4649)::Int64 |
|
│ %4651 = Base.sub_int(%18, 1)::Int64 |
|
│ %4652 = Base.mul_int(%4651, %4647)::Int64 |
|
│ %4653 = Base.add_int(%4650, %4652)::Int64 |
|
└──── goto #868 if not false |
|
864 ─ %4655 = Core.tuple(%4653)::Tuple{Int64} |
|
│ %4656 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4657 = (getfield)(%4656, 1)::Int64 |
|
│ %4658 = (getfield)(%4656, 2)::Int64 |
|
│ %4659 = (getfield)(%4656, 3)::Int64 |
|
│ %4660 = (getfield)(%4656, 4)::Int64 |
|
│ %4661 = (getfield)(%4656, 5)::Int64 |
|
│ %4662 = Base.mul_int(%4657, %4658)::Int64 |
|
│ %4663 = Base.mul_int(%4662, %4659)::Int64 |
|
│ %4664 = Base.mul_int(%4663, %4660)::Int64 |
|
│ %4665 = Base.mul_int(%4664, %4661)::Int64 |
|
│ %4666 = Base.slt_int(%4665, 0)::Bool |
|
│ %4667 = Base.ifelse(%4666, 0, %4665)::Int64 |
|
│ %4668 = Base.sle_int(1, %4653)::Bool |
|
│ %4669 = Base.sle_int(%4653, %4667)::Bool |
|
│ %4670 = Base.and_int(%4668, %4669)::Bool |
|
└──── goto #866 if not %4670 |
|
865 ─ goto #867 |
|
866 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4655::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
867 ┄ nothing::Nothing |
|
868 ┄ %4676 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4677 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4678 = Base.sub_int(%4653, 1)::Int64 |
|
│ %4679 = (%4677)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %4676, %4678)::Float32 |
|
└──── goto #869 |
|
869 ─ goto #870 |
|
870 ─ goto #871 |
|
871 ─ goto #876 if not false |
|
872 ─ %4684 = Core.tuple(%3995)::Tuple{Int64} |
|
│ %4685 = Base.sle_int(1, %3995)::Bool |
|
│ %4686 = Base.sle_int(%3995, 5)::Bool |
|
│ %4687 = Base.and_int(%4685, %4686)::Bool |
|
└──── goto #874 if not %4687 |
|
873 ─ goto #875 |
|
874 ─ invoke Base.throw_boundserror(%13::MArray{Tuple{5},Float32,1,5}, %4684::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
875 ┄ nothing::Nothing |
|
876 ┄ %4693 = $(Expr(:gc_preserve_begin, :(%13))) |
|
│ %4694 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%13)))::Ptr{Nothing} |
|
│ %4695 = Base.bitcast(Ptr{Float32}, %4694)::Ptr{Float32} |
|
│ %4696 = Base.pointerref(%4695, %3995, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%4693))) |
|
└──── goto #877 |
|
877 ─ %4699 = Base.mul_float(%4101, %4696)::Float32 |
|
│ %4700 = Base.add_float(%4679, %4699)::Float32 |
|
│ %4701 = Main._W::Core.Compiler.Const(4, false) |
|
└──── goto #882 if not false |
|
878 ─ %4703 = Core.tuple(%34, %28, %3995, %4701, %18)::NTuple{5,Int64} |
|
│ %4704 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4705 = Base.getfield(%4704, 1, true)::Int64 |
|
│ %4706 = Base.slt_int(%4705, 0)::Bool |
|
│ %4707 = Base.ifelse(%4706, 0, %4705)::Int64 |
|
│ %4708 = (getfield)(%4704, 2)::Int64 |
|
│ %4709 = (getfield)(%4704, 3)::Int64 |
|
│ %4710 = (getfield)(%4704, 4)::Int64 |
|
│ %4711 = (getfield)(%4704, 5)::Int64 |
|
│ %4712 = Base.slt_int(%4708, 0)::Bool |
|
│ %4713 = Base.ifelse(%4712, 0, %4708)::Int64 |
|
│ %4714 = Base.slt_int(%4709, 0)::Bool |
|
│ %4715 = Base.ifelse(%4714, 0, %4709)::Int64 |
|
│ %4716 = Base.slt_int(%4710, 0)::Bool |
|
│ %4717 = Base.ifelse(%4716, 0, %4710)::Int64 |
|
│ %4718 = Base.slt_int(%4711, 0)::Bool |
|
│ %4719 = Base.ifelse(%4718, 0, %4711)::Int64 |
|
│ %4720 = Base.sle_int(1, %34)::Bool |
|
│ %4721 = Base.sle_int(%34, %4707)::Bool |
|
│ %4722 = Base.and_int(%4720, %4721)::Bool |
|
│ %4723 = Base.sle_int(1, %28)::Bool |
|
│ %4724 = Base.sle_int(%28, %4713)::Bool |
|
│ %4725 = Base.and_int(%4723, %4724)::Bool |
|
│ %4726 = Base.sle_int(1, %3995)::Bool |
|
│ %4727 = Base.sle_int(%3995, %4715)::Bool |
|
│ %4728 = Base.and_int(%4726, %4727)::Bool |
|
│ %4729 = Base.sle_int(1, %4701)::Bool |
|
│ %4730 = Base.sle_int(%4701, %4717)::Bool |
|
│ %4731 = Base.and_int(%4729, %4730)::Bool |
|
│ %4732 = Base.sle_int(1, %18)::Bool |
|
│ %4733 = Base.sle_int(%18, %4719)::Bool |
|
│ %4734 = Base.and_int(%4732, %4733)::Bool |
|
│ %4735 = Base.and_int(%4734, true)::Bool |
|
│ %4736 = Base.and_int(%4731, %4735)::Bool |
|
│ %4737 = Base.and_int(%4728, %4736)::Bool |
|
│ %4738 = Base.and_int(%4725, %4737)::Bool |
|
│ %4739 = Base.and_int(%4722, %4738)::Bool |
|
└──── goto #880 if not %4739 |
|
879 ─ goto #881 |
|
880 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4703::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
881 ┄ nothing::Nothing |
|
882 ┄ %4745 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4746 = Base.getfield(%4745, 1, true)::Int64 |
|
│ %4747 = Base.slt_int(%4746, 0)::Bool |
|
│ %4748 = Base.ifelse(%4747, 0, %4746)::Int64 |
|
│ %4749 = (getfield)(%4745, 2)::Int64 |
|
│ %4750 = (getfield)(%4745, 3)::Int64 |
|
│ %4751 = (getfield)(%4745, 4)::Int64 |
|
│ %4752 = Base.slt_int(%4749, 0)::Bool |
|
│ %4753 = Base.ifelse(%4752, 0, %4749)::Int64 |
|
│ %4754 = Base.slt_int(%4750, 0)::Bool |
|
│ %4755 = Base.ifelse(%4754, 0, %4750)::Int64 |
|
│ %4756 = Base.slt_int(%4751, 0)::Bool |
|
│ %4757 = Base.ifelse(%4756, 0, %4751)::Int64 |
|
│ %4758 = Base.sub_int(%4748, 0)::Int64 |
|
│ %4759 = Base.mul_int(1, %4758)::Int64 |
|
│ %4760 = Base.sub_int(%34, 1)::Int64 |
|
│ %4761 = Base.mul_int(%4760, 1)::Int64 |
|
│ %4762 = Base.add_int(1, %4761)::Int64 |
|
│ %4763 = Base.sub_int(%4753, 0)::Int64 |
|
│ %4764 = Base.mul_int(%4759, %4763)::Int64 |
|
│ %4765 = Base.sub_int(%28, 1)::Int64 |
|
│ %4766 = Base.mul_int(%4765, %4759)::Int64 |
|
│ %4767 = Base.add_int(%4762, %4766)::Int64 |
|
│ %4768 = Base.sub_int(%4755, 0)::Int64 |
|
│ %4769 = Base.mul_int(%4764, %4768)::Int64 |
|
│ %4770 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4771 = Base.mul_int(%4770, %4764)::Int64 |
|
│ %4772 = Base.add_int(%4767, %4771)::Int64 |
|
│ %4773 = Base.sub_int(%4757, 0)::Int64 |
|
│ %4774 = Base.mul_int(%4769, %4773)::Int64 |
|
│ %4775 = Base.sub_int(%4701, 1)::Int64 |
|
│ %4776 = Base.mul_int(%4775, %4769)::Int64 |
|
│ %4777 = Base.add_int(%4772, %4776)::Int64 |
|
│ %4778 = Base.sub_int(%18, 1)::Int64 |
|
│ %4779 = Base.mul_int(%4778, %4774)::Int64 |
|
│ %4780 = Base.add_int(%4777, %4779)::Int64 |
|
└──── goto #887 if not false |
|
883 ─ %4782 = Core.tuple(%4780)::Tuple{Int64} |
|
│ %4783 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4784 = (getfield)(%4783, 1)::Int64 |
|
│ %4785 = (getfield)(%4783, 2)::Int64 |
|
│ %4786 = (getfield)(%4783, 3)::Int64 |
|
│ %4787 = (getfield)(%4783, 4)::Int64 |
|
│ %4788 = (getfield)(%4783, 5)::Int64 |
|
│ %4789 = Base.mul_int(%4784, %4785)::Int64 |
|
│ %4790 = Base.mul_int(%4789, %4786)::Int64 |
|
│ %4791 = Base.mul_int(%4790, %4787)::Int64 |
|
│ %4792 = Base.mul_int(%4791, %4788)::Int64 |
|
│ %4793 = Base.slt_int(%4792, 0)::Bool |
|
│ %4794 = Base.ifelse(%4793, 0, %4792)::Int64 |
|
│ %4795 = Base.sle_int(1, %4780)::Bool |
|
│ %4796 = Base.sle_int(%4780, %4794)::Bool |
|
│ %4797 = Base.and_int(%4795, %4796)::Bool |
|
└──── goto #885 if not %4797 |
|
884 ─ goto #886 |
|
885 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4782::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
886 ┄ nothing::Nothing |
|
887 ┄ %4803 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4804 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4805 = Base.sub_int(%4780, 1)::Int64 |
|
│ (%4804)($(QuoteNode(Ptr{Nothing} @0x0000000002ffdd58)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Float32,Int64}, %4803, %4700, %4805)::Nothing |
|
└──── goto #888 |
|
888 ─ goto #889 |
|
889 ─ goto #890 |
|
890 ─ goto #895 if not false |
|
891 ─ %4811 = Core.tuple(%34, %28, %3995, 1, %18)::NTuple{5,Int64} |
|
│ %4812 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4813 = Base.getfield(%4812, 1, true)::Int64 |
|
│ %4814 = Base.slt_int(%4813, 0)::Bool |
|
│ %4815 = Base.ifelse(%4814, 0, %4813)::Int64 |
|
│ %4816 = (getfield)(%4812, 2)::Int64 |
|
│ %4817 = (getfield)(%4812, 3)::Int64 |
|
│ %4818 = (getfield)(%4812, 4)::Int64 |
|
│ %4819 = (getfield)(%4812, 5)::Int64 |
|
│ %4820 = Base.slt_int(%4816, 0)::Bool |
|
│ %4821 = Base.ifelse(%4820, 0, %4816)::Int64 |
|
│ %4822 = Base.slt_int(%4817, 0)::Bool |
|
│ %4823 = Base.ifelse(%4822, 0, %4817)::Int64 |
|
│ %4824 = Base.slt_int(%4818, 0)::Bool |
|
│ %4825 = Base.ifelse(%4824, 0, %4818)::Int64 |
|
│ %4826 = Base.slt_int(%4819, 0)::Bool |
|
│ %4827 = Base.ifelse(%4826, 0, %4819)::Int64 |
|
│ %4828 = Base.sle_int(1, %34)::Bool |
|
│ %4829 = Base.sle_int(%34, %4815)::Bool |
|
│ %4830 = Base.and_int(%4828, %4829)::Bool |
|
│ %4831 = Base.sle_int(1, %28)::Bool |
|
│ %4832 = Base.sle_int(%28, %4821)::Bool |
|
│ %4833 = Base.and_int(%4831, %4832)::Bool |
|
│ %4834 = Base.sle_int(1, %3995)::Bool |
|
│ %4835 = Base.sle_int(%3995, %4823)::Bool |
|
│ %4836 = Base.and_int(%4834, %4835)::Bool |
|
│ %4837 = Base.sle_int(1, 1)::Bool |
|
│ %4838 = Base.sle_int(1, %4825)::Bool |
|
│ %4839 = Base.and_int(%4837, %4838)::Bool |
|
│ %4840 = Base.sle_int(1, %18)::Bool |
|
│ %4841 = Base.sle_int(%18, %4827)::Bool |
|
│ %4842 = Base.and_int(%4840, %4841)::Bool |
|
│ %4843 = Base.and_int(%4842, true)::Bool |
|
│ %4844 = Base.and_int(%4839, %4843)::Bool |
|
│ %4845 = Base.and_int(%4836, %4844)::Bool |
|
│ %4846 = Base.and_int(%4833, %4845)::Bool |
|
│ %4847 = Base.and_int(%4830, %4846)::Bool |
|
└──── goto #893 if not %4847 |
|
892 ─ goto #894 |
|
893 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4811::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
894 ┄ nothing::Nothing |
|
895 ┄ %4853 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4854 = Base.getfield(%4853, 1, true)::Int64 |
|
│ %4855 = Base.slt_int(%4854, 0)::Bool |
|
│ %4856 = Base.ifelse(%4855, 0, %4854)::Int64 |
|
│ %4857 = (getfield)(%4853, 2)::Int64 |
|
│ %4858 = (getfield)(%4853, 3)::Int64 |
|
│ %4859 = (getfield)(%4853, 4)::Int64 |
|
│ %4860 = Base.slt_int(%4857, 0)::Bool |
|
│ %4861 = Base.ifelse(%4860, 0, %4857)::Int64 |
|
│ %4862 = Base.slt_int(%4858, 0)::Bool |
|
│ %4863 = Base.ifelse(%4862, 0, %4858)::Int64 |
|
│ %4864 = Base.slt_int(%4859, 0)::Bool |
|
│ %4865 = Base.ifelse(%4864, 0, %4859)::Int64 |
|
│ %4866 = Base.sub_int(%4856, 0)::Int64 |
|
│ %4867 = Base.mul_int(1, %4866)::Int64 |
|
│ %4868 = Base.sub_int(%34, 1)::Int64 |
|
│ %4869 = Base.mul_int(%4868, 1)::Int64 |
|
│ %4870 = Base.add_int(1, %4869)::Int64 |
|
│ %4871 = Base.sub_int(%4861, 0)::Int64 |
|
│ %4872 = Base.mul_int(%4867, %4871)::Int64 |
|
│ %4873 = Base.sub_int(%28, 1)::Int64 |
|
│ %4874 = Base.mul_int(%4873, %4867)::Int64 |
|
│ %4875 = Base.add_int(%4870, %4874)::Int64 |
|
│ %4876 = Base.sub_int(%4863, 0)::Int64 |
|
│ %4877 = Base.mul_int(%4872, %4876)::Int64 |
|
│ %4878 = Base.sub_int(%3995, 1)::Int64 |
|
│ %4879 = Base.mul_int(%4878, %4872)::Int64 |
|
│ %4880 = Base.add_int(%4875, %4879)::Int64 |
|
│ %4881 = Base.sub_int(%4865, 0)::Int64 |
|
│ %4882 = Base.mul_int(%4877, %4881)::Int64 |
|
│ %4883 = Base.sub_int(1, 1)::Int64 |
|
│ %4884 = Base.mul_int(%4883, %4877)::Int64 |
|
│ %4885 = Base.add_int(%4880, %4884)::Int64 |
|
│ %4886 = Base.sub_int(%18, 1)::Int64 |
|
│ %4887 = Base.mul_int(%4886, %4882)::Int64 |
|
│ %4888 = Base.add_int(%4885, %4887)::Int64 |
|
└──── goto #900 if not false |
|
896 ─ %4890 = Core.tuple(%4888)::Tuple{Int64} |
|
│ %4891 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4892 = (getfield)(%4891, 1)::Int64 |
|
│ %4893 = (getfield)(%4891, 2)::Int64 |
|
│ %4894 = (getfield)(%4891, 3)::Int64 |
|
│ %4895 = (getfield)(%4891, 4)::Int64 |
|
│ %4896 = (getfield)(%4891, 5)::Int64 |
|
│ %4897 = Base.mul_int(%4892, %4893)::Int64 |
|
│ %4898 = Base.mul_int(%4897, %4894)::Int64 |
|
│ %4899 = Base.mul_int(%4898, %4895)::Int64 |
|
│ %4900 = Base.mul_int(%4899, %4896)::Int64 |
|
│ %4901 = Base.slt_int(%4900, 0)::Bool |
|
│ %4902 = Base.ifelse(%4901, 0, %4900)::Int64 |
|
│ %4903 = Base.sle_int(1, %4888)::Bool |
|
│ %4904 = Base.sle_int(%4888, %4902)::Bool |
|
│ %4905 = Base.and_int(%4903, %4904)::Bool |
|
└──── goto #898 if not %4905 |
|
897 ─ goto #899 |
|
898 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4890::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
899 ┄ nothing::Nothing |
|
900 ┄ %4911 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %4912 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %4913 = Base.sub_int(%4888, 1)::Int64 |
|
│ %4914 = (%4912)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %4911, %4913)::Float32 |
|
└──── goto #901 |
|
901 ─ goto #902 |
|
902 ─ goto #903 |
|
903 ─ goto #908 if not false |
|
904 ─ %4919 = Core.tuple(%3995)::Tuple{Int64} |
|
│ %4920 = Base.sle_int(1, %3995)::Bool |
|
│ %4921 = Base.sle_int(%3995, 5)::Bool |
|
│ %4922 = Base.and_int(%4920, %4921)::Bool |
|
└──── goto #906 if not %4922 |
|
905 ─ goto #907 |
|
906 ─ invoke Base.throw_boundserror(%10::MArray{Tuple{5},Float32,1,5}, %4919::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
907 ┄ nothing::Nothing |
|
908 ┄ %4928 = $(Expr(:gc_preserve_begin, :(%10))) |
|
│ %4929 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%10)))::Ptr{Nothing} |
|
│ %4930 = Base.bitcast(Ptr{Float32}, %4929)::Ptr{Float32} |
|
│ %4931 = Base.pointerref(%4930, %3995, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%4928))) |
|
└──── goto #909 |
|
909 ─ %4934 = Base.mul_float(%4101, %4931)::Float32 |
|
│ %4935 = Base.add_float(%4914, %4934)::Float32 |
|
│ %4936 = Main._ρ::Core.Compiler.Const(1, false) |
|
└──── goto #914 if not false |
|
910 ─ %4938 = Core.tuple(%34, %28, %3995, %4936, %18)::NTuple{5,Int64} |
|
│ %4939 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4940 = Base.getfield(%4939, 1, true)::Int64 |
|
│ %4941 = Base.slt_int(%4940, 0)::Bool |
|
│ %4942 = Base.ifelse(%4941, 0, %4940)::Int64 |
|
│ %4943 = (getfield)(%4939, 2)::Int64 |
|
│ %4944 = (getfield)(%4939, 3)::Int64 |
|
│ %4945 = (getfield)(%4939, 4)::Int64 |
|
│ %4946 = (getfield)(%4939, 5)::Int64 |
|
│ %4947 = Base.slt_int(%4943, 0)::Bool |
|
│ %4948 = Base.ifelse(%4947, 0, %4943)::Int64 |
|
│ %4949 = Base.slt_int(%4944, 0)::Bool |
|
│ %4950 = Base.ifelse(%4949, 0, %4944)::Int64 |
|
│ %4951 = Base.slt_int(%4945, 0)::Bool |
|
│ %4952 = Base.ifelse(%4951, 0, %4945)::Int64 |
|
│ %4953 = Base.slt_int(%4946, 0)::Bool |
|
│ %4954 = Base.ifelse(%4953, 0, %4946)::Int64 |
|
│ %4955 = Base.sle_int(1, %34)::Bool |
|
│ %4956 = Base.sle_int(%34, %4942)::Bool |
|
│ %4957 = Base.and_int(%4955, %4956)::Bool |
|
│ %4958 = Base.sle_int(1, %28)::Bool |
|
│ %4959 = Base.sle_int(%28, %4948)::Bool |
|
│ %4960 = Base.and_int(%4958, %4959)::Bool |
|
│ %4961 = Base.sle_int(1, %3995)::Bool |
|
│ %4962 = Base.sle_int(%3995, %4950)::Bool |
|
│ %4963 = Base.and_int(%4961, %4962)::Bool |
|
│ %4964 = Base.sle_int(1, %4936)::Bool |
|
│ %4965 = Base.sle_int(%4936, %4952)::Bool |
|
│ %4966 = Base.and_int(%4964, %4965)::Bool |
|
│ %4967 = Base.sle_int(1, %18)::Bool |
|
│ %4968 = Base.sle_int(%18, %4954)::Bool |
|
│ %4969 = Base.and_int(%4967, %4968)::Bool |
|
│ %4970 = Base.and_int(%4969, true)::Bool |
|
│ %4971 = Base.and_int(%4966, %4970)::Bool |
|
│ %4972 = Base.and_int(%4963, %4971)::Bool |
|
│ %4973 = Base.and_int(%4960, %4972)::Bool |
|
│ %4974 = Base.and_int(%4957, %4973)::Bool |
|
└──── goto #912 if not %4974 |
|
911 ─ goto #913 |
|
912 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %4938::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
913 ┄ nothing::Nothing |
|
914 ┄ %4980 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %4981 = Base.getfield(%4980, 1, true)::Int64 |
|
│ %4982 = Base.slt_int(%4981, 0)::Bool |
|
│ %4983 = Base.ifelse(%4982, 0, %4981)::Int64 |
|
│ %4984 = (getfield)(%4980, 2)::Int64 |
|
│ %4985 = (getfield)(%4980, 3)::Int64 |
|
│ %4986 = (getfield)(%4980, 4)::Int64 |
|
│ %4987 = Base.slt_int(%4984, 0)::Bool |
|
│ %4988 = Base.ifelse(%4987, 0, %4984)::Int64 |
|
│ %4989 = Base.slt_int(%4985, 0)::Bool |
|
│ %4990 = Base.ifelse(%4989, 0, %4985)::Int64 |
|
│ %4991 = Base.slt_int(%4986, 0)::Bool |
|
│ %4992 = Base.ifelse(%4991, 0, %4986)::Int64 |
|
│ %4993 = Base.sub_int(%4983, 0)::Int64 |
|
│ %4994 = Base.mul_int(1, %4993)::Int64 |
|
│ %4995 = Base.sub_int(%34, 1)::Int64 |
|
│ %4996 = Base.mul_int(%4995, 1)::Int64 |
|
│ %4997 = Base.add_int(1, %4996)::Int64 |
|
│ %4998 = Base.sub_int(%4988, 0)::Int64 |
|
│ %4999 = Base.mul_int(%4994, %4998)::Int64 |
|
│ %5000 = Base.sub_int(%28, 1)::Int64 |
|
│ %5001 = Base.mul_int(%5000, %4994)::Int64 |
|
│ %5002 = Base.add_int(%4997, %5001)::Int64 |
|
│ %5003 = Base.sub_int(%4990, 0)::Int64 |
|
│ %5004 = Base.mul_int(%4999, %5003)::Int64 |
|
│ %5005 = Base.sub_int(%3995, 1)::Int64 |
|
│ %5006 = Base.mul_int(%5005, %4999)::Int64 |
|
│ %5007 = Base.add_int(%5002, %5006)::Int64 |
|
│ %5008 = Base.sub_int(%4992, 0)::Int64 |
|
│ %5009 = Base.mul_int(%5004, %5008)::Int64 |
|
│ %5010 = Base.sub_int(%4936, 1)::Int64 |
|
│ %5011 = Base.mul_int(%5010, %5004)::Int64 |
|
│ %5012 = Base.add_int(%5007, %5011)::Int64 |
|
│ %5013 = Base.sub_int(%18, 1)::Int64 |
|
│ %5014 = Base.mul_int(%5013, %5009)::Int64 |
|
│ %5015 = Base.add_int(%5012, %5014)::Int64 |
|
└──── goto #919 if not false |
|
915 ─ %5017 = Core.tuple(%5015)::Tuple{Int64} |
|
│ %5018 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5019 = (getfield)(%5018, 1)::Int64 |
|
│ %5020 = (getfield)(%5018, 2)::Int64 |
|
│ %5021 = (getfield)(%5018, 3)::Int64 |
|
│ %5022 = (getfield)(%5018, 4)::Int64 |
|
│ %5023 = (getfield)(%5018, 5)::Int64 |
|
│ %5024 = Base.mul_int(%5019, %5020)::Int64 |
|
│ %5025 = Base.mul_int(%5024, %5021)::Int64 |
|
│ %5026 = Base.mul_int(%5025, %5022)::Int64 |
|
│ %5027 = Base.mul_int(%5026, %5023)::Int64 |
|
│ %5028 = Base.slt_int(%5027, 0)::Bool |
|
│ %5029 = Base.ifelse(%5028, 0, %5027)::Int64 |
|
│ %5030 = Base.sle_int(1, %5015)::Bool |
|
│ %5031 = Base.sle_int(%5015, %5029)::Bool |
|
│ %5032 = Base.and_int(%5030, %5031)::Bool |
|
└──── goto #917 if not %5032 |
|
916 ─ goto #918 |
|
917 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %5017::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
918 ┄ nothing::Nothing |
|
919 ┄ %5038 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %5039 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %5040 = Base.sub_int(%5015, 1)::Int64 |
|
│ (%5039)($(QuoteNode(Ptr{Nothing} @0x0000000002ffdd58)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Float32,Int64}, %5038, %4935, %5040)::Nothing |
|
└──── goto #920 |
|
920 ─ goto #921 |
|
921 ─ goto #922 |
|
922 ─ goto #927 if not false |
|
923 ─ %5046 = Core.tuple(%34, %28, %3995, 5, %18)::NTuple{5,Int64} |
|
│ %5047 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5048 = Base.getfield(%5047, 1, true)::Int64 |
|
│ %5049 = Base.slt_int(%5048, 0)::Bool |
|
│ %5050 = Base.ifelse(%5049, 0, %5048)::Int64 |
|
│ %5051 = (getfield)(%5047, 2)::Int64 |
|
│ %5052 = (getfield)(%5047, 3)::Int64 |
|
│ %5053 = (getfield)(%5047, 4)::Int64 |
|
│ %5054 = (getfield)(%5047, 5)::Int64 |
|
│ %5055 = Base.slt_int(%5051, 0)::Bool |
|
│ %5056 = Base.ifelse(%5055, 0, %5051)::Int64 |
|
│ %5057 = Base.slt_int(%5052, 0)::Bool |
|
│ %5058 = Base.ifelse(%5057, 0, %5052)::Int64 |
|
│ %5059 = Base.slt_int(%5053, 0)::Bool |
|
│ %5060 = Base.ifelse(%5059, 0, %5053)::Int64 |
|
│ %5061 = Base.slt_int(%5054, 0)::Bool |
|
│ %5062 = Base.ifelse(%5061, 0, %5054)::Int64 |
|
│ %5063 = Base.sle_int(1, %34)::Bool |
|
│ %5064 = Base.sle_int(%34, %5050)::Bool |
|
│ %5065 = Base.and_int(%5063, %5064)::Bool |
|
│ %5066 = Base.sle_int(1, %28)::Bool |
|
│ %5067 = Base.sle_int(%28, %5056)::Bool |
|
│ %5068 = Base.and_int(%5066, %5067)::Bool |
|
│ %5069 = Base.sle_int(1, %3995)::Bool |
|
│ %5070 = Base.sle_int(%3995, %5058)::Bool |
|
│ %5071 = Base.and_int(%5069, %5070)::Bool |
|
│ %5072 = Base.sle_int(1, 5)::Bool |
|
│ %5073 = Base.sle_int(5, %5060)::Bool |
|
│ %5074 = Base.and_int(%5072, %5073)::Bool |
|
│ %5075 = Base.sle_int(1, %18)::Bool |
|
│ %5076 = Base.sle_int(%18, %5062)::Bool |
|
│ %5077 = Base.and_int(%5075, %5076)::Bool |
|
│ %5078 = Base.and_int(%5077, true)::Bool |
|
│ %5079 = Base.and_int(%5074, %5078)::Bool |
|
│ %5080 = Base.and_int(%5071, %5079)::Bool |
|
│ %5081 = Base.and_int(%5068, %5080)::Bool |
|
│ %5082 = Base.and_int(%5065, %5081)::Bool |
|
└──── goto #925 if not %5082 |
|
924 ─ goto #926 |
|
925 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %5046::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
926 ┄ nothing::Nothing |
|
927 ┄ %5088 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5089 = Base.getfield(%5088, 1, true)::Int64 |
|
│ %5090 = Base.slt_int(%5089, 0)::Bool |
|
│ %5091 = Base.ifelse(%5090, 0, %5089)::Int64 |
|
│ %5092 = (getfield)(%5088, 2)::Int64 |
|
│ %5093 = (getfield)(%5088, 3)::Int64 |
|
│ %5094 = (getfield)(%5088, 4)::Int64 |
|
│ %5095 = Base.slt_int(%5092, 0)::Bool |
|
│ %5096 = Base.ifelse(%5095, 0, %5092)::Int64 |
|
│ %5097 = Base.slt_int(%5093, 0)::Bool |
|
│ %5098 = Base.ifelse(%5097, 0, %5093)::Int64 |
|
│ %5099 = Base.slt_int(%5094, 0)::Bool |
|
│ %5100 = Base.ifelse(%5099, 0, %5094)::Int64 |
|
│ %5101 = Base.sub_int(%5091, 0)::Int64 |
|
│ %5102 = Base.mul_int(1, %5101)::Int64 |
|
│ %5103 = Base.sub_int(%34, 1)::Int64 |
|
│ %5104 = Base.mul_int(%5103, 1)::Int64 |
|
│ %5105 = Base.add_int(1, %5104)::Int64 |
|
│ %5106 = Base.sub_int(%5096, 0)::Int64 |
|
│ %5107 = Base.mul_int(%5102, %5106)::Int64 |
|
│ %5108 = Base.sub_int(%28, 1)::Int64 |
|
│ %5109 = Base.mul_int(%5108, %5102)::Int64 |
|
│ %5110 = Base.add_int(%5105, %5109)::Int64 |
|
│ %5111 = Base.sub_int(%5098, 0)::Int64 |
|
│ %5112 = Base.mul_int(%5107, %5111)::Int64 |
|
│ %5113 = Base.sub_int(%3995, 1)::Int64 |
|
│ %5114 = Base.mul_int(%5113, %5107)::Int64 |
|
│ %5115 = Base.add_int(%5110, %5114)::Int64 |
|
│ %5116 = Base.sub_int(%5100, 0)::Int64 |
|
│ %5117 = Base.mul_int(%5112, %5116)::Int64 |
|
│ %5118 = Base.sub_int(5, 1)::Int64 |
|
│ %5119 = Base.mul_int(%5118, %5112)::Int64 |
|
│ %5120 = Base.add_int(%5115, %5119)::Int64 |
|
│ %5121 = Base.sub_int(%18, 1)::Int64 |
|
│ %5122 = Base.mul_int(%5121, %5117)::Int64 |
|
│ %5123 = Base.add_int(%5120, %5122)::Int64 |
|
└──── goto #932 if not false |
|
928 ─ %5125 = Core.tuple(%5123)::Tuple{Int64} |
|
│ %5126 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5127 = (getfield)(%5126, 1)::Int64 |
|
│ %5128 = (getfield)(%5126, 2)::Int64 |
|
│ %5129 = (getfield)(%5126, 3)::Int64 |
|
│ %5130 = (getfield)(%5126, 4)::Int64 |
|
│ %5131 = (getfield)(%5126, 5)::Int64 |
|
│ %5132 = Base.mul_int(%5127, %5128)::Int64 |
|
│ %5133 = Base.mul_int(%5132, %5129)::Int64 |
|
│ %5134 = Base.mul_int(%5133, %5130)::Int64 |
|
│ %5135 = Base.mul_int(%5134, %5131)::Int64 |
|
│ %5136 = Base.slt_int(%5135, 0)::Bool |
|
│ %5137 = Base.ifelse(%5136, 0, %5135)::Int64 |
|
│ %5138 = Base.sle_int(1, %5123)::Bool |
|
│ %5139 = Base.sle_int(%5123, %5137)::Bool |
|
│ %5140 = Base.and_int(%5138, %5139)::Bool |
|
└──── goto #930 if not %5140 |
|
929 ─ goto #931 |
|
930 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %5125::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
931 ┄ nothing::Nothing |
|
932 ┄ %5146 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %5147 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %5148 = Base.sub_int(%5123, 1)::Int64 |
|
│ %5149 = (%5147)($(QuoteNode(Ptr{Nothing} @0x0000000002b06f68)), Float32, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Int64}, %5146, %5148)::Float32 |
|
└──── goto #933 |
|
933 ─ goto #934 |
|
934 ─ goto #935 |
|
935 ─ goto #940 if not false |
|
936 ─ %5154 = Core.tuple(%3995)::Tuple{Int64} |
|
│ %5155 = Base.sle_int(1, %3995)::Bool |
|
│ %5156 = Base.sle_int(%3995, 5)::Bool |
|
│ %5157 = Base.and_int(%5155, %5156)::Bool |
|
└──── goto #938 if not %5157 |
|
937 ─ goto #939 |
|
938 ─ invoke Base.throw_boundserror(%14::MArray{Tuple{5},Float32,1,5}, %5154::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
939 ┄ nothing::Nothing |
|
940 ┄ %5163 = $(Expr(:gc_preserve_begin, :(%14))) |
|
│ %5164 = $(Expr(:foreigncall, :(:jl_value_ptr), Ptr{Nothing}, svec(Any), :(:ccall), 1, :(%14)))::Ptr{Nothing} |
|
│ %5165 = Base.bitcast(Ptr{Float32}, %5164)::Ptr{Float32} |
|
│ %5166 = Base.pointerref(%5165, %3995, 1)::Float32 |
|
│ $(Expr(:gc_preserve_end, :(%5163))) |
|
└──── goto #941 |
|
941 ─ %5169 = Base.mul_float(%4101, %5166)::Float32 |
|
│ %5170 = Base.add_float(%5149, %5169)::Float32 |
|
│ %5171 = Main._E::Core.Compiler.Const(5, false) |
|
└──── goto #946 if not false |
|
942 ─ %5173 = Core.tuple(%34, %28, %3995, %5171, %18)::NTuple{5,Int64} |
|
│ %5174 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5175 = Base.getfield(%5174, 1, true)::Int64 |
|
│ %5176 = Base.slt_int(%5175, 0)::Bool |
|
│ %5177 = Base.ifelse(%5176, 0, %5175)::Int64 |
|
│ %5178 = (getfield)(%5174, 2)::Int64 |
|
│ %5179 = (getfield)(%5174, 3)::Int64 |
|
│ %5180 = (getfield)(%5174, 4)::Int64 |
|
│ %5181 = (getfield)(%5174, 5)::Int64 |
|
│ %5182 = Base.slt_int(%5178, 0)::Bool |
|
│ %5183 = Base.ifelse(%5182, 0, %5178)::Int64 |
|
│ %5184 = Base.slt_int(%5179, 0)::Bool |
|
│ %5185 = Base.ifelse(%5184, 0, %5179)::Int64 |
|
│ %5186 = Base.slt_int(%5180, 0)::Bool |
|
│ %5187 = Base.ifelse(%5186, 0, %5180)::Int64 |
|
│ %5188 = Base.slt_int(%5181, 0)::Bool |
|
│ %5189 = Base.ifelse(%5188, 0, %5181)::Int64 |
|
│ %5190 = Base.sle_int(1, %34)::Bool |
|
│ %5191 = Base.sle_int(%34, %5177)::Bool |
|
│ %5192 = Base.and_int(%5190, %5191)::Bool |
|
│ %5193 = Base.sle_int(1, %28)::Bool |
|
│ %5194 = Base.sle_int(%28, %5183)::Bool |
|
│ %5195 = Base.and_int(%5193, %5194)::Bool |
|
│ %5196 = Base.sle_int(1, %3995)::Bool |
|
│ %5197 = Base.sle_int(%3995, %5185)::Bool |
|
│ %5198 = Base.and_int(%5196, %5197)::Bool |
|
│ %5199 = Base.sle_int(1, %5171)::Bool |
|
│ %5200 = Base.sle_int(%5171, %5187)::Bool |
|
│ %5201 = Base.and_int(%5199, %5200)::Bool |
|
│ %5202 = Base.sle_int(1, %18)::Bool |
|
│ %5203 = Base.sle_int(%18, %5189)::Bool |
|
│ %5204 = Base.and_int(%5202, %5203)::Bool |
|
│ %5205 = Base.and_int(%5204, true)::Bool |
|
│ %5206 = Base.and_int(%5201, %5205)::Bool |
|
│ %5207 = Base.and_int(%5198, %5206)::Bool |
|
│ %5208 = Base.and_int(%5195, %5207)::Bool |
|
│ %5209 = Base.and_int(%5192, %5208)::Bool |
|
└──── goto #944 if not %5209 |
|
943 ─ goto #945 |
|
944 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %5173::NTuple{5,Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
945 ┄ nothing::Nothing |
|
946 ┄ %5215 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5216 = Base.getfield(%5215, 1, true)::Int64 |
|
│ %5217 = Base.slt_int(%5216, 0)::Bool |
|
│ %5218 = Base.ifelse(%5217, 0, %5216)::Int64 |
|
│ %5219 = (getfield)(%5215, 2)::Int64 |
|
│ %5220 = (getfield)(%5215, 3)::Int64 |
|
│ %5221 = (getfield)(%5215, 4)::Int64 |
|
│ %5222 = Base.slt_int(%5219, 0)::Bool |
|
│ %5223 = Base.ifelse(%5222, 0, %5219)::Int64 |
|
│ %5224 = Base.slt_int(%5220, 0)::Bool |
|
│ %5225 = Base.ifelse(%5224, 0, %5220)::Int64 |
|
│ %5226 = Base.slt_int(%5221, 0)::Bool |
|
│ %5227 = Base.ifelse(%5226, 0, %5221)::Int64 |
|
│ %5228 = Base.sub_int(%5218, 0)::Int64 |
|
│ %5229 = Base.mul_int(1, %5228)::Int64 |
|
│ %5230 = Base.sub_int(%34, 1)::Int64 |
|
│ %5231 = Base.mul_int(%5230, 1)::Int64 |
|
│ %5232 = Base.add_int(1, %5231)::Int64 |
|
│ %5233 = Base.sub_int(%5223, 0)::Int64 |
|
│ %5234 = Base.mul_int(%5229, %5233)::Int64 |
|
│ %5235 = Base.sub_int(%28, 1)::Int64 |
|
│ %5236 = Base.mul_int(%5235, %5229)::Int64 |
|
│ %5237 = Base.add_int(%5232, %5236)::Int64 |
|
│ %5238 = Base.sub_int(%5225, 0)::Int64 |
|
│ %5239 = Base.mul_int(%5234, %5238)::Int64 |
|
│ %5240 = Base.sub_int(%3995, 1)::Int64 |
|
│ %5241 = Base.mul_int(%5240, %5234)::Int64 |
|
│ %5242 = Base.add_int(%5237, %5241)::Int64 |
|
│ %5243 = Base.sub_int(%5227, 0)::Int64 |
|
│ %5244 = Base.mul_int(%5239, %5243)::Int64 |
|
│ %5245 = Base.sub_int(%5171, 1)::Int64 |
|
│ %5246 = Base.mul_int(%5245, %5239)::Int64 |
|
│ %5247 = Base.add_int(%5242, %5246)::Int64 |
|
│ %5248 = Base.sub_int(%18, 1)::Int64 |
|
│ %5249 = Base.mul_int(%5248, %5244)::Int64 |
|
│ %5250 = Base.add_int(%5247, %5249)::Int64 |
|
└──── goto #951 if not false |
|
947 ─ %5252 = Core.tuple(%5250)::Tuple{Int64} |
|
│ %5253 = Base.getfield(rhs, :shape)::NTuple{5,Int64} |
|
│ %5254 = (getfield)(%5253, 1)::Int64 |
|
│ %5255 = (getfield)(%5253, 2)::Int64 |
|
│ %5256 = (getfield)(%5253, 3)::Int64 |
|
│ %5257 = (getfield)(%5253, 4)::Int64 |
|
│ %5258 = (getfield)(%5253, 5)::Int64 |
|
│ %5259 = Base.mul_int(%5254, %5255)::Int64 |
|
│ %5260 = Base.mul_int(%5259, %5256)::Int64 |
|
│ %5261 = Base.mul_int(%5260, %5257)::Int64 |
|
│ %5262 = Base.mul_int(%5261, %5258)::Int64 |
|
│ %5263 = Base.slt_int(%5262, 0)::Bool |
|
│ %5264 = Base.ifelse(%5263, 0, %5262)::Int64 |
|
│ %5265 = Base.sle_int(1, %5250)::Bool |
|
│ %5266 = Base.sle_int(%5250, %5264)::Bool |
|
│ %5267 = Base.and_int(%5265, %5266)::Bool |
|
└──── goto #949 if not %5267 |
|
948 ─ goto #950 |
|
949 ─ invoke Base.throw_boundserror(_3::CuDeviceArray{Float32,5,CUDAnative.AS.Global}, %5252::Tuple{Int64})::Union{} |
|
└──── $(Expr(:unreachable))::Union{} |
|
950 ┄ nothing::Nothing |
|
951 ┄ %5273 = Base.getfield(rhs, :ptr)::CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global} |
|
│ %5274 = Base.llvmcall::Core.IntrinsicFunction |
|
│ %5275 = Base.sub_int(%5250, 1)::Int64 |
|
│ (%5274)($(QuoteNode(Ptr{Nothing} @0x0000000002ffdd58)), Nothing, Tuple{CUDAnative.DevicePtr{Float32,CUDAnative.AS.Global},Float32,Int64}, %5273, %5170, %5275)::Nothing |
|
└──── goto #952 |
|
952 ─ goto #953 |
|
953 ─ goto #954 |
|
954 ─ $(Expr(:loopinfo, (Symbol("llvm.loop.unroll.full"), 1)))::Any |
|
│ %5281 = (%3996 === 5)::Bool |
|
└──── goto #956 if not %5281 |
|
955 ─ goto #957 |
|
956 ─ %5284 = Base.add_int(%3996, 1)::Int64 |
|
└──── goto #957 |
|
957 ┄ %5286 = φ (#956 => %5284)::Int64 |
|
│ %5287 = φ (#956 => %5284)::Int64 |
|
│ %5288 = φ (#955 => true, #956 => false)::Bool |
|
│ %5289 = Base.not_int(%5288)::Bool |
|
└──── goto #959 if not %5289 |
|
958 ─ goto #781 |
|
959 ┄ return Main.nothing |
|
) => Nothing |