Skip to content

Instantly share code, notes, and snippets.

@Birch-san

Birch-san/test.mlir

Created June 25, 2022 23:21
Show Gist options
  • Save Birch-san/758c67c23b135381340f1dbe9b10a4ae to your computer and use it in GitHub Desktop.
Save Birch-san/758c67c23b135381340f1dbe9b10a4ae to your computer and use it in GitHub Desktop.
Download ZIP
failed to legalize operation 'arith.cmpi'
Raw
test.mlir
This file has been truncated, but you can view the full file.
#loc0 = loc(unknown)
module @pmap_p_generate.14 {
func.func public @main(%arg0: tensor<1x64xi32> loc(unknown), %arg1: tensor<1x64xi32> loc(unknown), %arg2: tensor<1x64xi32> loc(unknown), %arg3: tensor<1x64xi32> loc(unknown), %arg4: tensor<2xui32> loc(unknown), %arg5: tensor<2048x16416xf32> loc(unknown), %arg6: tensor<256x2048xf32> loc(unknown), %arg7: tensor<16416x2048xf32> loc(unknown), %arg8: tensor<2048xf32> loc(unknown), %arg9: tensor<2048xf32> loc(unknown), %arg10: tensor<2048xf32> loc(unknown), %arg11: tensor<24x2048x2048xf32> loc(unknown), %arg12: tensor<24x2048x2048xf32> loc(unknown), %arg13: tensor<24x2048x2048xf32> loc(unknown), %arg14: tensor<24x2048x2048xf32> loc(unknown), %arg15: tensor<24x2048x2048xf32> loc(unknown), %arg16: tensor<24x2048x2048xf32> loc(unknown), %arg17: tensor<24x2048x2048xf32> loc(unknown), %arg18: tensor<24x2048x2048xf32> loc(unknown), %arg19: tensor<24x2048x4096xf32> loc(unknown), %arg20: tensor<24x2048x4096xf32> loc(unknown), %arg21: tensor<24x4096x2048xf32> loc(unknown), %arg22: tensor<24x2048xf32> loc(unknown), %arg23: tensor<24x4096xf32> loc(unknown), %arg24: tensor<24x2048xf32> loc(unknown), %arg25: tensor<24x2048xf32> loc(unknown), %arg26: tensor<24x2048xf32> loc(unknown), %arg27: tensor<24x2048xf32> loc(unknown), %arg28: tensor<24x2048xf32> loc(unknown), %arg29: tensor<24x2048xf32> loc(unknown), %arg30: tensor<64x2048xf32> loc(unknown), %arg31: tensor<50272x2048xf32> loc(unknown), %arg32: tensor<2048xf32> loc(unknown), %arg33: tensor<2048xf32> loc(unknown), %arg34: tensor<2048xf32> loc(unknown), %arg35: tensor<24x2048x2048xf32> loc(unknown), %arg36: tensor<24x2048x2048xf32> loc(unknown), %arg37: tensor<24x2048x2048xf32> loc(unknown), %arg38: tensor<24x2048x2048xf32> loc(unknown), %arg39: tensor<24x2048x4096xf32> loc(unknown), %arg40: tensor<24x2048x4096xf32> loc(unknown), %arg41: tensor<24x4096x2048xf32> loc(unknown), %arg42: tensor<24x2048xf32> loc(unknown), %arg43: tensor<24x4096xf32> loc(unknown), %arg44: tensor<24x2048xf32> loc(unknown), %arg45: tensor<24x2048xf32> loc(unknown), %arg46: tensor<24x2048xf32> loc(unknown)) -> tensor<1x257xi32> {
%0 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<64xi32> loc(#loc1)
%1 = "mhlo.broadcast_in_dim"(%0) {broadcast_dimensions = dense<1> : tensor<1xi64>} : (tensor<64xi32>) -> tensor<1x64xi32> loc(#loc2)
%2 = call @_take(%arg31, %arg2) : (tensor<50272x2048xf32>, tensor<1x64xi32>) -> tensor<1x64x2048xf32> loc(#loc3)
%3 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%4 = "mhlo.broadcast_in_dim"(%3) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x2048xf32> loc(#loc4)
%5 = mhlo.multiply %2, %4 : tensor<1x64x2048xf32> loc(#loc4)
%6 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%7 = "mhlo.broadcast_in_dim"(%6) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x64xi32> loc(#loc5)
%8 = mhlo.add %1, %7 : tensor<1x64xi32> loc(#loc5)
%9 = call @_take_0(%arg30, %8) : (tensor<64x2048xf32>, tensor<1x64xi32>) -> tensor<1x64x2048xf32> loc(#loc6)
%10 = mhlo.add %5, %9 : tensor<1x64x2048xf32> loc(#loc7)
%11 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc8)
%12 = mhlo.reduce(%10 init: %11) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc8)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc8)
} loc(#loc8)
%13 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%14 = "mhlo.broadcast_in_dim"(%13) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc9)
%15 = mhlo.divide %12, %14 : tensor<1x64xf32> loc(#loc9)
%16 = mhlo.multiply %10, %10 : tensor<1x64x2048xf32> loc(#loc10)
%17 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc11)
%18 = mhlo.reduce(%16 init: %17) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc11)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc11)
} loc(#loc11)
%19 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%20 = "mhlo.broadcast_in_dim"(%19) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc12)
%21 = mhlo.divide %18, %20 : tensor<1x64xf32> loc(#loc12)
%22 = mhlo.multiply %15, %15 : tensor<1x64xf32> loc(#loc10)
%23 = mhlo.subtract %21, %22 : tensor<1x64xf32> loc(#loc13)
%24 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%25 = "mhlo.broadcast_in_dim"(%24) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc14)
%26 = mhlo.maximum %25, %23 : tensor<1x64xf32> loc(#loc14)
%27 = "mhlo.reshape"(%15) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc15)
%28 = "mhlo.reshape"(%26) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc16)
%29 = "mhlo.broadcast_in_dim"(%27) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc17)
%30 = mhlo.subtract %10, %29 : tensor<1x64x2048xf32> loc(#loc17)
%31 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc0)
%32 = "mhlo.broadcast_in_dim"(%31) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc18)
%33 = mhlo.add %28, %32 : tensor<1x64x1xf32> loc(#loc18)
%34 = mhlo.rsqrt %33 : tensor<1x64x1xf32> loc(#loc19)
%35 = "mhlo.reshape"(%arg34) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc20)
%36 = "mhlo.broadcast_in_dim"(%34) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc21)
%37 = "mhlo.broadcast_in_dim"(%35) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc21)
%38 = mhlo.multiply %36, %37 : tensor<1x64x2048xf32> loc(#loc21)
%39 = mhlo.multiply %30, %38 : tensor<1x64x2048xf32> loc(#loc22)
%40 = "mhlo.reshape"(%arg33) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc23)
%41 = "mhlo.broadcast_in_dim"(%40) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc24)
%42 = mhlo.add %39, %41 : tensor<1x64x2048xf32> loc(#loc24)
%43 = mhlo.convert(%42) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc25)
%44 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%45 = "mhlo.broadcast_in_dim"(%44) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc27)
%46 = mhlo.convert(%45) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc28)
%47 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc26)
%48 = "mhlo.broadcast_in_dim"(%47) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc29)
%49 = mhlo.convert(%48) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc30)
%50 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc26)
%51 = mhlo.sqrt %50 : tensor<f32> loc(#loc31)
%52 = mhlo.convert(%51) : (tensor<f32>) -> tensor<f16> loc(#loc32)
call @_einsum() : () -> () loc(#loc33)
call @_einsum_2() : () -> () loc(#loc34)
%53 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%54 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%55 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%56 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%57 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%58 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%59 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%60 = mhlo.constant dense<0> : tensor<i32> loc(#loc26)
%61 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%62 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%63 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%64 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc26)
%65 = mhlo.constant dense<2.000000e+00> : tensor<f16> loc(#loc26)
%66 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%67 = mhlo.constant dense<1.414060e+00> : tensor<f16> loc(#loc26)
%68 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%69 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%70 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%71 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%72 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%73 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%74 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc26)
%75 = mhlo.constant dense<0> : tensor<i32> loc(#loc35)
%76:15 = mhlo.while(%iterArg = %arg35, %iterArg_0 = %arg36, %iterArg_1 = %arg37, %iterArg_2 = %arg38, %iterArg_3 = %arg39, %iterArg_4 = %arg40, %iterArg_5 = %arg41, %iterArg_6 = %arg42, %iterArg_7 = %arg43, %iterArg_8 = %arg44, %iterArg_9 = %arg45, %iterArg_10 = %arg46, %iterArg_11 = %arg0, %iterArg_12 = %75, %iterArg_13 = %43) : tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x4096xf32>, tensor<24x2048x4096xf32>, tensor<24x4096x2048xf32>, tensor<24x2048xf32>, tensor<24x4096xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<1x64xi32>, tensor<i32>, tensor<1x64x2048xf16>
cond {
%5188 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5189 = "mhlo.compare"(%iterArg_12, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc37)
"mhlo.return"(%5189) : (tensor<i1>) -> () loc(#loc36)
} do {
%5188 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5189 = "mhlo.compare"(%iterArg_12, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5190 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5191 = mhlo.add %iterArg_12, %5190 : tensor<i32> loc(#loc39)
%5192 = "mhlo.select"(%5189, %5191, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5193 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5194 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5195 = "mhlo.compare"(%5193, %5194) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5196 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5197 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5198 = mhlo.add %5196, %5197 : tensor<i32> loc(#loc39)
%5199 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5200 = "mhlo.select"(%5195, %5198, %5199) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5201 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5202 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5203 = "mhlo.compare"(%5201, %5202) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5204 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5205 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5206 = mhlo.add %5204, %5205 : tensor<i32> loc(#loc39)
%5207 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5208 = "mhlo.select"(%5203, %5206, %5207) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5209 = "mhlo.dynamic-slice"(%iterArg, %5192, %5200, %5208) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5210 = "mhlo.reshape"(%5209) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5211 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5212 = "mhlo.compare"(%iterArg_12, %5211) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5213 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5214 = mhlo.add %iterArg_12, %5213 : tensor<i32> loc(#loc39)
%5215 = "mhlo.select"(%5212, %5214, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5216 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5217 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5218 = "mhlo.compare"(%5216, %5217) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5219 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5220 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5221 = mhlo.add %5219, %5220 : tensor<i32> loc(#loc39)
%5222 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5223 = "mhlo.select"(%5218, %5221, %5222) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5224 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5225 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5226 = "mhlo.compare"(%5224, %5225) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5227 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5228 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5229 = mhlo.add %5227, %5228 : tensor<i32> loc(#loc39)
%5230 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5231 = "mhlo.select"(%5226, %5229, %5230) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5232 = "mhlo.dynamic-slice"(%iterArg_0, %5215, %5223, %5231) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5233 = "mhlo.reshape"(%5232) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5234 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5235 = "mhlo.compare"(%iterArg_12, %5234) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5236 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5237 = mhlo.add %iterArg_12, %5236 : tensor<i32> loc(#loc39)
%5238 = "mhlo.select"(%5235, %5237, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5239 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5240 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5241 = "mhlo.compare"(%5239, %5240) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5242 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5243 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5244 = mhlo.add %5242, %5243 : tensor<i32> loc(#loc39)
%5245 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5246 = "mhlo.select"(%5241, %5244, %5245) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5247 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5248 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5249 = "mhlo.compare"(%5247, %5248) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5250 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5251 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5252 = mhlo.add %5250, %5251 : tensor<i32> loc(#loc39)
%5253 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5254 = "mhlo.select"(%5249, %5252, %5253) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5255 = "mhlo.dynamic-slice"(%iterArg_1, %5238, %5246, %5254) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5256 = "mhlo.reshape"(%5255) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5257 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5258 = "mhlo.compare"(%iterArg_12, %5257) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5259 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5260 = mhlo.add %iterArg_12, %5259 : tensor<i32> loc(#loc39)
%5261 = "mhlo.select"(%5258, %5260, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5262 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5263 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5264 = "mhlo.compare"(%5262, %5263) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5265 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5266 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5267 = mhlo.add %5265, %5266 : tensor<i32> loc(#loc39)
%5268 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5269 = "mhlo.select"(%5264, %5267, %5268) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5270 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5271 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5272 = "mhlo.compare"(%5270, %5271) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5273 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5274 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5275 = mhlo.add %5273, %5274 : tensor<i32> loc(#loc39)
%5276 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5277 = "mhlo.select"(%5272, %5275, %5276) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5278 = "mhlo.dynamic-slice"(%iterArg_2, %5261, %5269, %5277) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5279 = "mhlo.reshape"(%5278) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5280 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5281 = "mhlo.compare"(%iterArg_12, %5280) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5282 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5283 = mhlo.add %iterArg_12, %5282 : tensor<i32> loc(#loc39)
%5284 = "mhlo.select"(%5281, %5283, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5285 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5286 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5287 = "mhlo.compare"(%5285, %5286) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5288 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5289 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5290 = mhlo.add %5288, %5289 : tensor<i32> loc(#loc39)
%5291 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5292 = "mhlo.select"(%5287, %5290, %5291) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5293 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5294 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5295 = "mhlo.compare"(%5293, %5294) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5296 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5297 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5298 = mhlo.add %5296, %5297 : tensor<i32> loc(#loc39)
%5299 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5300 = "mhlo.select"(%5295, %5298, %5299) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5301 = "mhlo.dynamic-slice"(%iterArg_3, %5284, %5292, %5300) {slice_sizes = dense<[1, 2048, 4096]> : tensor<3xi64>} : (tensor<24x2048x4096xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x4096xf32> loc(#loc43)
%5302 = "mhlo.reshape"(%5301) : (tensor<1x2048x4096xf32>) -> tensor<2048x4096xf32> loc(#loc42)
%5303 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5304 = "mhlo.compare"(%iterArg_12, %5303) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5305 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5306 = mhlo.add %iterArg_12, %5305 : tensor<i32> loc(#loc39)
%5307 = "mhlo.select"(%5304, %5306, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5308 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5309 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5310 = "mhlo.compare"(%5308, %5309) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5311 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5312 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5313 = mhlo.add %5311, %5312 : tensor<i32> loc(#loc39)
%5314 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5315 = "mhlo.select"(%5310, %5313, %5314) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5316 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5317 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5318 = "mhlo.compare"(%5316, %5317) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5319 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5320 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5321 = mhlo.add %5319, %5320 : tensor<i32> loc(#loc39)
%5322 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5323 = "mhlo.select"(%5318, %5321, %5322) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5324 = "mhlo.dynamic-slice"(%iterArg_4, %5307, %5315, %5323) {slice_sizes = dense<[1, 2048, 4096]> : tensor<3xi64>} : (tensor<24x2048x4096xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x4096xf32> loc(#loc43)
%5325 = "mhlo.reshape"(%5324) : (tensor<1x2048x4096xf32>) -> tensor<2048x4096xf32> loc(#loc42)
%5326 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5327 = "mhlo.compare"(%iterArg_12, %5326) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5328 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5329 = mhlo.add %iterArg_12, %5328 : tensor<i32> loc(#loc39)
%5330 = "mhlo.select"(%5327, %5329, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5331 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5332 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5333 = "mhlo.compare"(%5331, %5332) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5334 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5335 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5336 = mhlo.add %5334, %5335 : tensor<i32> loc(#loc39)
%5337 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5338 = "mhlo.select"(%5333, %5336, %5337) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5339 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5340 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5341 = "mhlo.compare"(%5339, %5340) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5342 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5343 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5344 = mhlo.add %5342, %5343 : tensor<i32> loc(#loc39)
%5345 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5346 = "mhlo.select"(%5341, %5344, %5345) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5347 = "mhlo.dynamic-slice"(%iterArg_5, %5330, %5338, %5346) {slice_sizes = dense<[1, 4096, 2048]> : tensor<3xi64>} : (tensor<24x4096x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x4096x2048xf32> loc(#loc44)
%5348 = "mhlo.reshape"(%5347) : (tensor<1x4096x2048xf32>) -> tensor<4096x2048xf32> loc(#loc42)
%5349 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5350 = "mhlo.compare"(%iterArg_12, %5349) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5351 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5352 = mhlo.add %iterArg_12, %5351 : tensor<i32> loc(#loc39)
%5353 = "mhlo.select"(%5350, %5352, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5354 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5355 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5356 = "mhlo.compare"(%5354, %5355) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5357 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5358 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5359 = mhlo.add %5357, %5358 : tensor<i32> loc(#loc39)
%5360 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5361 = "mhlo.select"(%5356, %5359, %5360) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5362 = "mhlo.dynamic-slice"(%iterArg_6, %5353, %5361) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5363 = "mhlo.reshape"(%5362) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5364 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5365 = "mhlo.compare"(%iterArg_12, %5364) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5366 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5367 = mhlo.add %iterArg_12, %5366 : tensor<i32> loc(#loc39)
%5368 = "mhlo.select"(%5365, %5367, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5369 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5370 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5371 = "mhlo.compare"(%5369, %5370) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5372 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5373 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5374 = mhlo.add %5372, %5373 : tensor<i32> loc(#loc39)
%5375 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5376 = "mhlo.select"(%5371, %5374, %5375) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5377 = "mhlo.dynamic-slice"(%iterArg_7, %5368, %5376) {slice_sizes = dense<[1, 4096]> : tensor<2xi64>} : (tensor<24x4096xf32>, tensor<i32>, tensor<i32>) -> tensor<1x4096xf32> loc(#loc46)
%5378 = "mhlo.reshape"(%5377) : (tensor<1x4096xf32>) -> tensor<4096xf32> loc(#loc42)
%5379 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5380 = "mhlo.compare"(%iterArg_12, %5379) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5381 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5382 = mhlo.add %iterArg_12, %5381 : tensor<i32> loc(#loc39)
%5383 = "mhlo.select"(%5380, %5382, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5384 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5385 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5386 = "mhlo.compare"(%5384, %5385) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5387 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5388 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5389 = mhlo.add %5387, %5388 : tensor<i32> loc(#loc39)
%5390 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5391 = "mhlo.select"(%5386, %5389, %5390) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5392 = "mhlo.dynamic-slice"(%iterArg_8, %5383, %5391) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5393 = "mhlo.reshape"(%5392) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5394 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5395 = "mhlo.compare"(%iterArg_12, %5394) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5396 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5397 = mhlo.add %iterArg_12, %5396 : tensor<i32> loc(#loc39)
%5398 = "mhlo.select"(%5395, %5397, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5399 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5400 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5401 = "mhlo.compare"(%5399, %5400) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5402 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5403 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5404 = mhlo.add %5402, %5403 : tensor<i32> loc(#loc39)
%5405 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5406 = "mhlo.select"(%5401, %5404, %5405) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5407 = "mhlo.dynamic-slice"(%iterArg_9, %5398, %5406) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5408 = "mhlo.reshape"(%5407) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5409 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5410 = "mhlo.compare"(%iterArg_12, %5409) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5411 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5412 = mhlo.add %iterArg_12, %5411 : tensor<i32> loc(#loc39)
%5413 = "mhlo.select"(%5410, %5412, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5414 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5415 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5416 = "mhlo.compare"(%5414, %5415) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5417 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5418 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5419 = mhlo.add %5417, %5418 : tensor<i32> loc(#loc39)
%5420 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5421 = "mhlo.select"(%5416, %5419, %5420) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5422 = "mhlo.dynamic-slice"(%iterArg_10, %5413, %5421) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5423 = "mhlo.reshape"(%5422) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5424 = mhlo.convert(%iterArg_13) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc47)
%5425 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc48)
%5426 = mhlo.reduce(%5424 init: %5425) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc48)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc48)
} loc(#loc48)
%5427 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5428 = "mhlo.broadcast_in_dim"(%5427) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc50)
%5429 = mhlo.divide %5426, %5428 : tensor<1x64xf32> loc(#loc50)
%5430 = mhlo.multiply %5424, %5424 : tensor<1x64x2048xf32> loc(#loc51)
%5431 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc52)
%5432 = mhlo.reduce(%5430 init: %5431) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc52)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc52)
} loc(#loc52)
%5433 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5434 = "mhlo.broadcast_in_dim"(%5433) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc53)
%5435 = mhlo.divide %5432, %5434 : tensor<1x64xf32> loc(#loc53)
%5436 = mhlo.multiply %5429, %5429 : tensor<1x64xf32> loc(#loc51)
%5437 = mhlo.subtract %5435, %5436 : tensor<1x64xf32> loc(#loc54)
%5438 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5439 = "mhlo.broadcast_in_dim"(%5438) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc55)
%5440 = mhlo.maximum %5439, %5437 : tensor<1x64xf32> loc(#loc55)
%5441 = "mhlo.reshape"(%5429) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc56)
%5442 = "mhlo.reshape"(%5440) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc57)
%5443 = mhlo.convert(%iterArg_13) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc58)
%5444 = "mhlo.broadcast_in_dim"(%5441) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc59)
%5445 = mhlo.subtract %5443, %5444 : tensor<1x64x2048xf32> loc(#loc59)
%5446 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5447 = "mhlo.broadcast_in_dim"(%5446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc60)
%5448 = mhlo.add %5442, %5447 : tensor<1x64x1xf32> loc(#loc60)
%5449 = mhlo.rsqrt %5448 : tensor<1x64x1xf32> loc(#loc61)
%5450 = "mhlo.broadcast_in_dim"(%5449) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc62)
%5451 = mhlo.multiply %5445, %5450 : tensor<1x64x2048xf32> loc(#loc62)
%5452 = "mhlo.reshape"(%5393) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc63)
%5453 = "mhlo.broadcast_in_dim"(%5452) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc64)
%5454 = mhlo.add %5451, %5453 : tensor<1x64x2048xf32> loc(#loc64)
%5455 = mhlo.convert(%5454) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc65)
%5456 = mhlo.convert(%5256) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc66)
%5457 = "mhlo.dot_general"(%5455, %5456) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc67)
%5458 = mhlo.convert(%5210) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc68)
%5459 = "mhlo.dot_general"(%5455, %5458) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc69)
%5460 = mhlo.convert(%5279) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc70)
%5461 = "mhlo.dot_general"(%5455, %5460) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc71)
%5462 = "mhlo.reshape"(%5457) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5463 = "mhlo.reshape"(%5459) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5464 = "mhlo.reshape"(%5461) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5465 = "mhlo.broadcast_in_dim"(%iterArg_11) {broadcast_dimensions = dense<[0, 3]> : tensor<2xi64>} : (tensor<1x64xi32>) -> tensor<1x1x1x64xi32> loc(#loc73)
%5466 = mhlo.constant dense<0> : tensor<i32> loc(#loc49)
%5467 = "mhlo.broadcast_in_dim"(%5466) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x1x1x64xi32> loc(#loc74)
%5468 = "mhlo.compare"(%5465, %5467) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction GT">} : (tensor<1x1x1x64xi32>, tensor<1x1x1x64xi32>) -> tensor<1x1x1x64xi1> loc(#loc74)
%5469 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5470 = "mhlo.broadcast_in_dim"(%5469) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc75)
%5471 = mhlo.convert(%5470) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc76)
%5472 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc49)
%5473 = "mhlo.broadcast_in_dim"(%5472) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc77)
%5474 = mhlo.convert(%5473) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc78)
%5475 = "mhlo.select"(%5468, %5471, %5474) : (tensor<1x1x1x64xi1>, tensor<1x1x1x64xf16>, tensor<1x1x1x64xf16>) -> tensor<1x1x1x64xf16> loc(#loc79)
%5476 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc49)
%5477 = mhlo.sqrt %5476 : tensor<f32> loc(#loc80)
%5478 = mhlo.convert(%5477) : (tensor<f32>) -> tensor<f16> loc(#loc81)
%5479 = "mhlo.broadcast_in_dim"(%5478) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x32x64xf16> loc(#loc82)
%5480 = mhlo.divide %5462, %5479 : tensor<1x64x32x64xf16> loc(#loc82)
%5481 = func.call @_einsum_3(%5480, %5463) : (tensor<1x64x32x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x32x64x64xf16> loc(#loc83)
%5482 = "mhlo.broadcast_in_dim"(%5475) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x1x1x64xf16>) -> tensor<1x32x64x64xf16> loc(#loc84)
%5483 = mhlo.add %5481, %5482 : tensor<1x32x64x64xf16> loc(#loc84)
%5484 = mhlo.constant dense<0xFC00> : tensor<f16> loc(#loc85)
%5485 = mhlo.reduce(%5483 init: %5484) across dimensions = [3] : (tensor<1x32x64x64xf16>, tensor<f16>) -> tensor<1x32x64xf16>
reducer(%arg47: tensor<f16> loc(unknown), %arg48: tensor<f16> loc(unknown)) {
%5628 = mhlo.maximum %arg47, %arg48 : tensor<f16> loc(#loc85)
"mhlo.return"(%5628) : (tensor<f16>) -> () loc(#loc85)
} loc(#loc85)
%5486 = "mhlo.broadcast_in_dim"(%5485) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x64xf16>) -> tensor<1x32x64x1xf16> loc(#loc86)
%5487 = "mhlo.broadcast_in_dim"(%5486) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x64x1xf16>) -> tensor<1x32x64x64xf16> loc(#loc87)
%5488 = mhlo.subtract %5483, %5487 : tensor<1x32x64x64xf16> loc(#loc87)
%5489 = mhlo.exponential %5488 : tensor<1x32x64x64xf16> loc(#loc88)
%5490 = mhlo.convert(%5489) : (tensor<1x32x64x64xf16>) -> tensor<1x32x64x64xf32> loc(#loc89)
%5491 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc90)
%5492 = mhlo.reduce(%5490 init: %5491) across dimensions = [3] : (tensor<1x32x64x64xf32>, tensor<f32>) -> tensor<1x32x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc90)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc90)
} loc(#loc90)
%5493 = "mhlo.broadcast_in_dim"(%5492) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x64xf32>) -> tensor<1x32x64x1xf32> loc(#loc86)
%5494 = mhlo.convert(%5493) : (tensor<1x32x64x1xf32>) -> tensor<1x32x64x1xf16> loc(#loc91)
%5495 = "mhlo.broadcast_in_dim"(%5494) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x64x1xf16>) -> tensor<1x32x64x64xf16> loc(#loc92)
%5496 = mhlo.divide %5489, %5495 : tensor<1x32x64x64xf16> loc(#loc92)
%5497 = func.call @_einsum_4(%5496, %5464) : (tensor<1x32x64x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x64x32x64xf16> loc(#loc93)
%5498 = "mhlo.reshape"(%5497) : (tensor<1x64x32x64xf16>) -> tensor<1x64x2048xf16> loc(#loc94)
%5499 = mhlo.convert(%5233) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc95)
%5500 = "mhlo.dot_general"(%5498, %5499) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc96)
%5501 = mhlo.convert(%5500) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc97)
%5502 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc98)
%5503 = mhlo.reduce(%5501 init: %5502) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc98)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc98)
} loc(#loc98)
%5504 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5505 = "mhlo.broadcast_in_dim"(%5504) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc99)
%5506 = mhlo.divide %5503, %5505 : tensor<1x64xf32> loc(#loc99)
%5507 = mhlo.multiply %5501, %5501 : tensor<1x64x2048xf32> loc(#loc100)
%5508 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc101)
%5509 = mhlo.reduce(%5507 init: %5508) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc101)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc101)
} loc(#loc101)
%5510 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5511 = "mhlo.broadcast_in_dim"(%5510) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc102)
%5512 = mhlo.divide %5509, %5511 : tensor<1x64xf32> loc(#loc102)
%5513 = mhlo.multiply %5506, %5506 : tensor<1x64xf32> loc(#loc100)
%5514 = mhlo.subtract %5512, %5513 : tensor<1x64xf32> loc(#loc103)
%5515 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5516 = "mhlo.broadcast_in_dim"(%5515) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc104)
%5517 = mhlo.maximum %5516, %5514 : tensor<1x64xf32> loc(#loc104)
%5518 = "mhlo.reshape"(%5506) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc105)
%5519 = "mhlo.reshape"(%5517) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc106)
%5520 = mhlo.convert(%5500) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc107)
%5521 = "mhlo.broadcast_in_dim"(%5518) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc108)
%5522 = mhlo.subtract %5520, %5521 : tensor<1x64x2048xf32> loc(#loc108)
%5523 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5524 = "mhlo.broadcast_in_dim"(%5523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc109)
%5525 = mhlo.add %5519, %5524 : tensor<1x64x1xf32> loc(#loc109)
%5526 = mhlo.rsqrt %5525 : tensor<1x64x1xf32> loc(#loc110)
%5527 = "mhlo.reshape"(%5423) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc111)
%5528 = "mhlo.broadcast_in_dim"(%5526) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc112)
%5529 = "mhlo.broadcast_in_dim"(%5527) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc112)
%5530 = mhlo.multiply %5528, %5529 : tensor<1x64x2048xf32> loc(#loc112)
%5531 = mhlo.multiply %5522, %5530 : tensor<1x64x2048xf32> loc(#loc113)
%5532 = "mhlo.reshape"(%5408) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc114)
%5533 = "mhlo.broadcast_in_dim"(%5532) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc115)
%5534 = mhlo.add %5531, %5533 : tensor<1x64x2048xf32> loc(#loc115)
%5535 = mhlo.convert(%5534) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc116)
%5536 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5537 = "mhlo.broadcast_in_dim"(%5536) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x2048xf16> loc(#loc117)
%5538 = mhlo.multiply %iterArg_13, %5537 : tensor<1x64x2048xf16> loc(#loc117)
%5539 = mhlo.add %5538, %5535 : tensor<1x64x2048xf16> loc(#loc118)
%5540 = mhlo.convert(%5539) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc119)
%5541 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc120)
%5542 = mhlo.reduce(%5540 init: %5541) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc120)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc120)
} loc(#loc120)
%5543 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5544 = "mhlo.broadcast_in_dim"(%5543) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc121)
%5545 = mhlo.divide %5542, %5544 : tensor<1x64xf32> loc(#loc121)
%5546 = mhlo.multiply %5540, %5540 : tensor<1x64x2048xf32> loc(#loc122)
%5547 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc123)
%5548 = mhlo.reduce(%5546 init: %5547) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc123)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc123)
} loc(#loc123)
%5549 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5550 = "mhlo.broadcast_in_dim"(%5549) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc124)
%5551 = mhlo.divide %5548, %5550 : tensor<1x64xf32> loc(#loc124)
%5552 = mhlo.multiply %5545, %5545 : tensor<1x64xf32> loc(#loc122)
%5553 = mhlo.subtract %5551, %5552 : tensor<1x64xf32> loc(#loc125)
%5554 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5555 = "mhlo.broadcast_in_dim"(%5554) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc126)
%5556 = mhlo.maximum %5555, %5553 : tensor<1x64xf32> loc(#loc126)
%5557 = "mhlo.reshape"(%5545) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc127)
%5558 = "mhlo.reshape"(%5556) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc128)
%5559 = mhlo.convert(%5539) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc129)
%5560 = "mhlo.broadcast_in_dim"(%5557) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc130)
%5561 = mhlo.subtract %5559, %5560 : tensor<1x64x2048xf32> loc(#loc130)
%5562 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5563 = "mhlo.broadcast_in_dim"(%5562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc131)
%5564 = mhlo.add %5558, %5563 : tensor<1x64x1xf32> loc(#loc131)
%5565 = mhlo.rsqrt %5564 : tensor<1x64x1xf32> loc(#loc132)
%5566 = "mhlo.broadcast_in_dim"(%5565) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc133)
%5567 = mhlo.multiply %5561, %5566 : tensor<1x64x2048xf32> loc(#loc133)
%5568 = "mhlo.reshape"(%5363) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc134)
%5569 = "mhlo.broadcast_in_dim"(%5568) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc135)
%5570 = mhlo.add %5567, %5569 : tensor<1x64x2048xf32> loc(#loc135)
%5571 = mhlo.convert(%5570) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc136)
%5572 = mhlo.convert(%5302) : (tensor<2048x4096xf32>) -> tensor<2048x4096xf16> loc(#loc137)
%5573 = "mhlo.dot_general"(%5571, %5572) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x4096xf16>) -> tensor<1x64x4096xf16> loc(#loc138)
%5574 = mhlo.constant dense<1.414060e+00> : tensor<f16> loc(#loc49)
%5575 = "mhlo.broadcast_in_dim"(%5574) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc139)
%5576 = mhlo.divide %5573, %5575 : tensor<1x64x4096xf16> loc(#loc139)
%5577 = chlo.erf %5576 : tensor<1x64x4096xf16> -> tensor<1x64x4096xf16> loc(#loc140)
%5578 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5579 = "mhlo.broadcast_in_dim"(%5578) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc141)
%5580 = mhlo.add %5577, %5579 : tensor<1x64x4096xf16> loc(#loc141)
%5581 = mhlo.multiply %5573, %5580 : tensor<1x64x4096xf16> loc(#loc142)
%5582 = mhlo.constant dense<2.000000e+00> : tensor<f16> loc(#loc49)
%5583 = "mhlo.broadcast_in_dim"(%5582) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc139)
%5584 = mhlo.divide %5581, %5583 : tensor<1x64x4096xf16> loc(#loc139)
%5585 = mhlo.convert(%5325) : (tensor<2048x4096xf32>) -> tensor<2048x4096xf16> loc(#loc143)
%5586 = "mhlo.dot_general"(%5571, %5585) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x4096xf16>) -> tensor<1x64x4096xf16> loc(#loc144)
%5587 = mhlo.multiply %5584, %5586 : tensor<1x64x4096xf16> loc(#loc145)
%5588 = mhlo.convert(%5587) : (tensor<1x64x4096xf16>) -> tensor<1x64x4096xf32> loc(#loc146)
%5589 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc147)
%5590 = mhlo.reduce(%5588 init: %5589) across dimensions = [2] : (tensor<1x64x4096xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc147)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc147)
} loc(#loc147)
%5591 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc49)
%5592 = "mhlo.broadcast_in_dim"(%5591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc148)
%5593 = mhlo.divide %5590, %5592 : tensor<1x64xf32> loc(#loc148)
%5594 = mhlo.multiply %5588, %5588 : tensor<1x64x4096xf32> loc(#loc149)
%5595 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc150)
%5596 = mhlo.reduce(%5594 init: %5595) across dimensions = [2] : (tensor<1x64x4096xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc150)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc150)
} loc(#loc150)
%5597 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc49)
%5598 = "mhlo.broadcast_in_dim"(%5597) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc151)
%5599 = mhlo.divide %5596, %5598 : tensor<1x64xf32> loc(#loc151)
%5600 = mhlo.multiply %5593, %5593 : tensor<1x64xf32> loc(#loc149)
%5601 = mhlo.subtract %5599, %5600 : tensor<1x64xf32> loc(#loc152)
%5602 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5603 = "mhlo.broadcast_in_dim"(%5602) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc153)
%5604 = mhlo.maximum %5603, %5601 : tensor<1x64xf32> loc(#loc153)
%5605 = "mhlo.reshape"(%5593) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc154)
%5606 = "mhlo.reshape"(%5604) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc155)
%5607 = mhlo.convert(%5587) : (tensor<1x64x4096xf16>) -> tensor<1x64x4096xf32> loc(#loc156)
%5608 = "mhlo.broadcast_in_dim"(%5605) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x4096xf32> loc(#loc157)
%5609 = mhlo.subtract %5607, %5608 : tensor<1x64x4096xf32> loc(#loc157)
%5610 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5611 = "mhlo.broadcast_in_dim"(%5610) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc158)
%5612 = mhlo.add %5606, %5611 : tensor<1x64x1xf32> loc(#loc158)
%5613 = mhlo.rsqrt %5612 : tensor<1x64x1xf32> loc(#loc159)
%5614 = "mhlo.broadcast_in_dim"(%5613) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x4096xf32> loc(#loc160)
%5615 = mhlo.multiply %5609, %5614 : tensor<1x64x4096xf32> loc(#loc160)
%5616 = "mhlo.reshape"(%5378) : (tensor<4096xf32>) -> tensor<1x1x4096xf32> loc(#loc161)
%5617 = "mhlo.broadcast_in_dim"(%5616) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x4096xf32>) -> tensor<1x64x4096xf32> loc(#loc162)
%5618 = mhlo.add %5615, %5617 : tensor<1x64x4096xf32> loc(#loc162)
%5619 = mhlo.convert(%5618) : (tensor<1x64x4096xf32>) -> tensor<1x64x4096xf16> loc(#loc163)
%5620 = mhlo.convert(%5348) : (tensor<4096x2048xf32>) -> tensor<4096x2048xf16> loc(#loc164)
%5621 = "mhlo.dot_general"(%5619, %5620) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x4096xf16>, tensor<4096x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc165)
%5622 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5623 = "mhlo.broadcast_in_dim"(%5622) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x2048xf16> loc(#loc166)
%5624 = mhlo.multiply %5539, %5623 : tensor<1x64x2048xf16> loc(#loc166)
%5625 = mhlo.add %5624, %5621 : tensor<1x64x2048xf16> loc(#loc167)
%5626 = mhlo.constant dense<1> : tensor<i32> loc(#loc36)
%5627 = mhlo.add %iterArg_12, %5626 : tensor<i32> loc(#loc39)
"mhlo.return"(%iterArg, %iterArg_0, %iterArg_1, %iterArg_2, %iterArg_3, %iterArg_4, %iterArg_5, %iterArg_6, %iterArg_7, %iterArg_8, %iterArg_9, %iterArg_10, %iterArg_11, %5627, %5625) : (tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x4096xf32>, tensor<24x2048x4096xf32>, tensor<24x4096x2048xf32>, tensor<24x2048xf32>, tensor<24x4096xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<1x64xi32>, tensor<i32>, tensor<1x64x2048xf16>) -> () loc(#loc36)
} loc(#loc36)
%77 = mhlo.convert(%76#14) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc168)
%78 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc169)
%79 = mhlo.reduce(%77 init: %78) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc169)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc169)
} loc(#loc169)
%80 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%81 = "mhlo.broadcast_in_dim"(%80) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc170)
%82 = mhlo.divide %79, %81 : tensor<1x64xf32> loc(#loc170)
%83 = mhlo.multiply %77, %77 : tensor<1x64x2048xf32> loc(#loc171)
%84 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc172)
%85 = mhlo.reduce(%83 init: %84) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc172)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc172)
} loc(#loc172)
%86 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%87 = "mhlo.broadcast_in_dim"(%86) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc173)
%88 = mhlo.divide %85, %87 : tensor<1x64xf32> loc(#loc173)
%89 = mhlo.multiply %82, %82 : tensor<1x64xf32> loc(#loc171)
%90 = mhlo.subtract %88, %89 : tensor<1x64xf32> loc(#loc174)
%91 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%92 = "mhlo.broadcast_in_dim"(%91) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc175)
%93 = mhlo.maximum %92, %90 : tensor<1x64xf32> loc(#loc175)
%94 = "mhlo.reshape"(%82) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc176)
%95 = "mhlo.reshape"(%93) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc177)
%96 = mhlo.convert(%76#14) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc178)
%97 = "mhlo.broadcast_in_dim"(%94) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc179)
%98 = mhlo.subtract %96, %97 : tensor<1x64x2048xf32> loc(#loc179)
%99 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc0)
%100 = "mhlo.broadcast_in_dim"(%99) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc180)
%101 = mhlo.add %95, %100 : tensor<1x64x1xf32> loc(#loc180)
%102 = mhlo.rsqrt %101 : tensor<1x64x1xf32> loc(#loc181)
%103 = "mhlo.broadcast_in_dim"(%102) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc182)
%104 = mhlo.multiply %98, %103 : tensor<1x64x2048xf32> loc(#loc182)
%105 = "mhlo.reshape"(%arg32) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc183)
%106 = "mhlo.broadcast_in_dim"(%105) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc184)
%107 = mhlo.add %104, %106 : tensor<1x64x2048xf32> loc(#loc184)
%108 = mhlo.convert(%107) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc185)
%109 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<64xi32> loc(#loc1)
%110 = "mhlo.broadcast_in_dim"(%109) {broadcast_dimensions = dense<1> : tensor<1xi64>} : (tensor<64xi32>) -> tensor<1x64xi32> loc(#loc2)
%111 = call @_take_5(%arg31, %arg3) : (tensor<50272x2048xf32>, tensor<1x64xi32>) -> tensor<1x64x2048xf32> loc(#loc3)
%112 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%113 = "mhlo.broadcast_in_dim"(%112) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x2048xf32> loc(#loc4)
%114 = mhlo.multiply %111, %113 : tensor<1x64x2048xf32> loc(#loc4)
%115 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%116 = "mhlo.broadcast_in_dim"(%115) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x64xi32> loc(#loc5)
%117 = mhlo.add %110, %116 : tensor<1x64xi32> loc(#loc5)
%118 = call @_take_7(%arg30, %117) : (tensor<64x2048xf32>, tensor<1x64xi32>) -> tensor<1x64x2048xf32> loc(#loc6)
%119 = mhlo.add %114, %118 : tensor<1x64x2048xf32> loc(#loc7)
%120 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc8)
%121 = mhlo.reduce(%119 init: %120) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc8)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc8)
} loc(#loc8)
%122 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%123 = "mhlo.broadcast_in_dim"(%122) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc9)
%124 = mhlo.divide %121, %123 : tensor<1x64xf32> loc(#loc9)
%125 = mhlo.multiply %119, %119 : tensor<1x64x2048xf32> loc(#loc10)
%126 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc11)
%127 = mhlo.reduce(%125 init: %126) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc11)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc11)
} loc(#loc11)
%128 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%129 = "mhlo.broadcast_in_dim"(%128) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc12)
%130 = mhlo.divide %127, %129 : tensor<1x64xf32> loc(#loc12)
%131 = mhlo.multiply %124, %124 : tensor<1x64xf32> loc(#loc10)
%132 = mhlo.subtract %130, %131 : tensor<1x64xf32> loc(#loc13)
%133 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%134 = "mhlo.broadcast_in_dim"(%133) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc14)
%135 = mhlo.maximum %134, %132 : tensor<1x64xf32> loc(#loc14)
%136 = "mhlo.reshape"(%124) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc15)
%137 = "mhlo.reshape"(%135) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc16)
%138 = "mhlo.broadcast_in_dim"(%136) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc17)
%139 = mhlo.subtract %119, %138 : tensor<1x64x2048xf32> loc(#loc17)
%140 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc0)
%141 = "mhlo.broadcast_in_dim"(%140) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc18)
%142 = mhlo.add %137, %141 : tensor<1x64x1xf32> loc(#loc18)
%143 = mhlo.rsqrt %142 : tensor<1x64x1xf32> loc(#loc19)
%144 = "mhlo.reshape"(%arg34) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc20)
%145 = "mhlo.broadcast_in_dim"(%143) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc21)
%146 = "mhlo.broadcast_in_dim"(%144) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc21)
%147 = mhlo.multiply %145, %146 : tensor<1x64x2048xf32> loc(#loc21)
%148 = mhlo.multiply %139, %147 : tensor<1x64x2048xf32> loc(#loc22)
%149 = "mhlo.reshape"(%arg33) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc23)
%150 = "mhlo.broadcast_in_dim"(%149) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc24)
%151 = mhlo.add %148, %150 : tensor<1x64x2048xf32> loc(#loc24)
%152 = mhlo.convert(%151) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc25)
%153 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%154 = "mhlo.broadcast_in_dim"(%153) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc27)
%155 = mhlo.convert(%154) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc28)
%156 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc26)
%157 = "mhlo.broadcast_in_dim"(%156) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc29)
%158 = mhlo.convert(%157) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc30)
%159 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc26)
%160 = mhlo.sqrt %159 : tensor<f32> loc(#loc31)
%161 = mhlo.convert(%160) : (tensor<f32>) -> tensor<f16> loc(#loc32)
call @_einsum_9() : () -> () loc(#loc33)
call @_einsum_10() : () -> () loc(#loc34)
%162 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%163 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%164 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%165 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%166 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%167 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%168 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%169 = mhlo.constant dense<0> : tensor<i32> loc(#loc26)
%170 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%171 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%172 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%173 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc26)
%174 = mhlo.constant dense<2.000000e+00> : tensor<f16> loc(#loc26)
%175 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc26)
%176 = mhlo.constant dense<1.414060e+00> : tensor<f16> loc(#loc26)
%177 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%178 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%179 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%180 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc26)
%181 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc26)
%182 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc26)
%183 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc26)
%184 = mhlo.constant dense<0> : tensor<i32> loc(#loc35)
%185:15 = mhlo.while(%iterArg = %arg35, %iterArg_0 = %arg36, %iterArg_1 = %arg37, %iterArg_2 = %arg38, %iterArg_3 = %arg39, %iterArg_4 = %arg40, %iterArg_5 = %arg41, %iterArg_6 = %arg42, %iterArg_7 = %arg43, %iterArg_8 = %arg44, %iterArg_9 = %arg45, %iterArg_10 = %arg46, %iterArg_11 = %arg1, %iterArg_12 = %184, %iterArg_13 = %152) : tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x4096xf32>, tensor<24x2048x4096xf32>, tensor<24x4096x2048xf32>, tensor<24x2048xf32>, tensor<24x4096xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<1x64xi32>, tensor<i32>, tensor<1x64x2048xf16>
cond {
%5188 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5189 = "mhlo.compare"(%iterArg_12, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc37)
"mhlo.return"(%5189) : (tensor<i1>) -> () loc(#loc36)
} do {
%5188 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5189 = "mhlo.compare"(%iterArg_12, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5190 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5191 = mhlo.add %iterArg_12, %5190 : tensor<i32> loc(#loc39)
%5192 = "mhlo.select"(%5189, %5191, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5193 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5194 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5195 = "mhlo.compare"(%5193, %5194) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5196 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5197 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5198 = mhlo.add %5196, %5197 : tensor<i32> loc(#loc39)
%5199 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5200 = "mhlo.select"(%5195, %5198, %5199) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5201 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5202 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5203 = "mhlo.compare"(%5201, %5202) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5204 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5205 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5206 = mhlo.add %5204, %5205 : tensor<i32> loc(#loc39)
%5207 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5208 = "mhlo.select"(%5203, %5206, %5207) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5209 = "mhlo.dynamic-slice"(%iterArg, %5192, %5200, %5208) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5210 = "mhlo.reshape"(%5209) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5211 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5212 = "mhlo.compare"(%iterArg_12, %5211) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5213 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5214 = mhlo.add %iterArg_12, %5213 : tensor<i32> loc(#loc39)
%5215 = "mhlo.select"(%5212, %5214, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5216 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5217 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5218 = "mhlo.compare"(%5216, %5217) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5219 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5220 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5221 = mhlo.add %5219, %5220 : tensor<i32> loc(#loc39)
%5222 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5223 = "mhlo.select"(%5218, %5221, %5222) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5224 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5225 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5226 = "mhlo.compare"(%5224, %5225) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5227 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5228 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5229 = mhlo.add %5227, %5228 : tensor<i32> loc(#loc39)
%5230 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5231 = "mhlo.select"(%5226, %5229, %5230) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5232 = "mhlo.dynamic-slice"(%iterArg_0, %5215, %5223, %5231) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5233 = "mhlo.reshape"(%5232) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5234 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5235 = "mhlo.compare"(%iterArg_12, %5234) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5236 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5237 = mhlo.add %iterArg_12, %5236 : tensor<i32> loc(#loc39)
%5238 = "mhlo.select"(%5235, %5237, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5239 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5240 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5241 = "mhlo.compare"(%5239, %5240) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5242 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5243 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5244 = mhlo.add %5242, %5243 : tensor<i32> loc(#loc39)
%5245 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5246 = "mhlo.select"(%5241, %5244, %5245) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5247 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5248 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5249 = "mhlo.compare"(%5247, %5248) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5250 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5251 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5252 = mhlo.add %5250, %5251 : tensor<i32> loc(#loc39)
%5253 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5254 = "mhlo.select"(%5249, %5252, %5253) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5255 = "mhlo.dynamic-slice"(%iterArg_1, %5238, %5246, %5254) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5256 = "mhlo.reshape"(%5255) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5257 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5258 = "mhlo.compare"(%iterArg_12, %5257) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5259 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5260 = mhlo.add %iterArg_12, %5259 : tensor<i32> loc(#loc39)
%5261 = "mhlo.select"(%5258, %5260, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5262 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5263 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5264 = "mhlo.compare"(%5262, %5263) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5265 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5266 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5267 = mhlo.add %5265, %5266 : tensor<i32> loc(#loc39)
%5268 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5269 = "mhlo.select"(%5264, %5267, %5268) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5270 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5271 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5272 = "mhlo.compare"(%5270, %5271) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5273 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5274 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5275 = mhlo.add %5273, %5274 : tensor<i32> loc(#loc39)
%5276 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5277 = "mhlo.select"(%5272, %5275, %5276) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5278 = "mhlo.dynamic-slice"(%iterArg_2, %5261, %5269, %5277) {slice_sizes = dense<[1, 2048, 2048]> : tensor<3xi64>} : (tensor<24x2048x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x2048xf32> loc(#loc41)
%5279 = "mhlo.reshape"(%5278) : (tensor<1x2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc42)
%5280 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5281 = "mhlo.compare"(%iterArg_12, %5280) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5282 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5283 = mhlo.add %iterArg_12, %5282 : tensor<i32> loc(#loc39)
%5284 = "mhlo.select"(%5281, %5283, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5285 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5286 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5287 = "mhlo.compare"(%5285, %5286) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5288 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5289 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5290 = mhlo.add %5288, %5289 : tensor<i32> loc(#loc39)
%5291 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5292 = "mhlo.select"(%5287, %5290, %5291) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5293 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5294 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5295 = "mhlo.compare"(%5293, %5294) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5296 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5297 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5298 = mhlo.add %5296, %5297 : tensor<i32> loc(#loc39)
%5299 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5300 = "mhlo.select"(%5295, %5298, %5299) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5301 = "mhlo.dynamic-slice"(%iterArg_3, %5284, %5292, %5300) {slice_sizes = dense<[1, 2048, 4096]> : tensor<3xi64>} : (tensor<24x2048x4096xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x4096xf32> loc(#loc43)
%5302 = "mhlo.reshape"(%5301) : (tensor<1x2048x4096xf32>) -> tensor<2048x4096xf32> loc(#loc42)
%5303 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5304 = "mhlo.compare"(%iterArg_12, %5303) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5305 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5306 = mhlo.add %iterArg_12, %5305 : tensor<i32> loc(#loc39)
%5307 = "mhlo.select"(%5304, %5306, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5308 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5309 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5310 = "mhlo.compare"(%5308, %5309) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5311 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5312 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5313 = mhlo.add %5311, %5312 : tensor<i32> loc(#loc39)
%5314 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5315 = "mhlo.select"(%5310, %5313, %5314) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5316 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5317 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5318 = "mhlo.compare"(%5316, %5317) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5319 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5320 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5321 = mhlo.add %5319, %5320 : tensor<i32> loc(#loc39)
%5322 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5323 = "mhlo.select"(%5318, %5321, %5322) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5324 = "mhlo.dynamic-slice"(%iterArg_4, %5307, %5315, %5323) {slice_sizes = dense<[1, 2048, 4096]> : tensor<3xi64>} : (tensor<24x2048x4096xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x2048x4096xf32> loc(#loc43)
%5325 = "mhlo.reshape"(%5324) : (tensor<1x2048x4096xf32>) -> tensor<2048x4096xf32> loc(#loc42)
%5326 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5327 = "mhlo.compare"(%iterArg_12, %5326) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5328 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5329 = mhlo.add %iterArg_12, %5328 : tensor<i32> loc(#loc39)
%5330 = "mhlo.select"(%5327, %5329, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5331 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5332 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5333 = "mhlo.compare"(%5331, %5332) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5334 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5335 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5336 = mhlo.add %5334, %5335 : tensor<i32> loc(#loc39)
%5337 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5338 = "mhlo.select"(%5333, %5336, %5337) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5339 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5340 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5341 = "mhlo.compare"(%5339, %5340) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5342 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5343 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5344 = mhlo.add %5342, %5343 : tensor<i32> loc(#loc39)
%5345 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5346 = "mhlo.select"(%5341, %5344, %5345) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5347 = "mhlo.dynamic-slice"(%iterArg_5, %5330, %5338, %5346) {slice_sizes = dense<[1, 4096, 2048]> : tensor<3xi64>} : (tensor<24x4096x2048xf32>, tensor<i32>, tensor<i32>, tensor<i32>) -> tensor<1x4096x2048xf32> loc(#loc44)
%5348 = "mhlo.reshape"(%5347) : (tensor<1x4096x2048xf32>) -> tensor<4096x2048xf32> loc(#loc42)
%5349 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5350 = "mhlo.compare"(%iterArg_12, %5349) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5351 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5352 = mhlo.add %iterArg_12, %5351 : tensor<i32> loc(#loc39)
%5353 = "mhlo.select"(%5350, %5352, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5354 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5355 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5356 = "mhlo.compare"(%5354, %5355) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5357 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5358 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5359 = mhlo.add %5357, %5358 : tensor<i32> loc(#loc39)
%5360 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5361 = "mhlo.select"(%5356, %5359, %5360) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5362 = "mhlo.dynamic-slice"(%iterArg_6, %5353, %5361) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5363 = "mhlo.reshape"(%5362) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5364 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5365 = "mhlo.compare"(%iterArg_12, %5364) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5366 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5367 = mhlo.add %iterArg_12, %5366 : tensor<i32> loc(#loc39)
%5368 = "mhlo.select"(%5365, %5367, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5369 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5370 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5371 = "mhlo.compare"(%5369, %5370) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5372 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5373 = mhlo.constant dense<4096> : tensor<i32> loc(#loc36)
%5374 = mhlo.add %5372, %5373 : tensor<i32> loc(#loc39)
%5375 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5376 = "mhlo.select"(%5371, %5374, %5375) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5377 = "mhlo.dynamic-slice"(%iterArg_7, %5368, %5376) {slice_sizes = dense<[1, 4096]> : tensor<2xi64>} : (tensor<24x4096xf32>, tensor<i32>, tensor<i32>) -> tensor<1x4096xf32> loc(#loc46)
%5378 = "mhlo.reshape"(%5377) : (tensor<1x4096xf32>) -> tensor<4096xf32> loc(#loc42)
%5379 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5380 = "mhlo.compare"(%iterArg_12, %5379) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5381 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5382 = mhlo.add %iterArg_12, %5381 : tensor<i32> loc(#loc39)
%5383 = "mhlo.select"(%5380, %5382, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5384 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5385 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5386 = "mhlo.compare"(%5384, %5385) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5387 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5388 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5389 = mhlo.add %5387, %5388 : tensor<i32> loc(#loc39)
%5390 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5391 = "mhlo.select"(%5386, %5389, %5390) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5392 = "mhlo.dynamic-slice"(%iterArg_8, %5383, %5391) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5393 = "mhlo.reshape"(%5392) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5394 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5395 = "mhlo.compare"(%iterArg_12, %5394) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5396 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5397 = mhlo.add %iterArg_12, %5396 : tensor<i32> loc(#loc39)
%5398 = "mhlo.select"(%5395, %5397, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5399 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5400 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5401 = "mhlo.compare"(%5399, %5400) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5402 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5403 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5404 = mhlo.add %5402, %5403 : tensor<i32> loc(#loc39)
%5405 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5406 = "mhlo.select"(%5401, %5404, %5405) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5407 = "mhlo.dynamic-slice"(%iterArg_9, %5398, %5406) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5408 = "mhlo.reshape"(%5407) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5409 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5410 = "mhlo.compare"(%iterArg_12, %5409) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5411 = mhlo.constant dense<24> : tensor<i32> loc(#loc36)
%5412 = mhlo.add %iterArg_12, %5411 : tensor<i32> loc(#loc39)
%5413 = "mhlo.select"(%5410, %5412, %iterArg_12) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5414 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5415 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5416 = "mhlo.compare"(%5414, %5415) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc38)
%5417 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5418 = mhlo.constant dense<2048> : tensor<i32> loc(#loc36)
%5419 = mhlo.add %5417, %5418 : tensor<i32> loc(#loc39)
%5420 = mhlo.constant dense<0> : tensor<i32> loc(#loc36)
%5421 = "mhlo.select"(%5416, %5419, %5420) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc40)
%5422 = "mhlo.dynamic-slice"(%iterArg_10, %5413, %5421) {slice_sizes = dense<[1, 2048]> : tensor<2xi64>} : (tensor<24x2048xf32>, tensor<i32>, tensor<i32>) -> tensor<1x2048xf32> loc(#loc45)
%5423 = "mhlo.reshape"(%5422) : (tensor<1x2048xf32>) -> tensor<2048xf32> loc(#loc42)
%5424 = mhlo.convert(%iterArg_13) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc47)
%5425 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc48)
%5426 = mhlo.reduce(%5424 init: %5425) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc48)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc48)
} loc(#loc48)
%5427 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5428 = "mhlo.broadcast_in_dim"(%5427) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc50)
%5429 = mhlo.divide %5426, %5428 : tensor<1x64xf32> loc(#loc50)
%5430 = mhlo.multiply %5424, %5424 : tensor<1x64x2048xf32> loc(#loc51)
%5431 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc52)
%5432 = mhlo.reduce(%5430 init: %5431) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc52)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc52)
} loc(#loc52)
%5433 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5434 = "mhlo.broadcast_in_dim"(%5433) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc53)
%5435 = mhlo.divide %5432, %5434 : tensor<1x64xf32> loc(#loc53)
%5436 = mhlo.multiply %5429, %5429 : tensor<1x64xf32> loc(#loc51)
%5437 = mhlo.subtract %5435, %5436 : tensor<1x64xf32> loc(#loc54)
%5438 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5439 = "mhlo.broadcast_in_dim"(%5438) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc55)
%5440 = mhlo.maximum %5439, %5437 : tensor<1x64xf32> loc(#loc55)
%5441 = "mhlo.reshape"(%5429) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc56)
%5442 = "mhlo.reshape"(%5440) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc57)
%5443 = mhlo.convert(%iterArg_13) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc58)
%5444 = "mhlo.broadcast_in_dim"(%5441) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc59)
%5445 = mhlo.subtract %5443, %5444 : tensor<1x64x2048xf32> loc(#loc59)
%5446 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5447 = "mhlo.broadcast_in_dim"(%5446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc60)
%5448 = mhlo.add %5442, %5447 : tensor<1x64x1xf32> loc(#loc60)
%5449 = mhlo.rsqrt %5448 : tensor<1x64x1xf32> loc(#loc61)
%5450 = "mhlo.broadcast_in_dim"(%5449) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc62)
%5451 = mhlo.multiply %5445, %5450 : tensor<1x64x2048xf32> loc(#loc62)
%5452 = "mhlo.reshape"(%5393) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc63)
%5453 = "mhlo.broadcast_in_dim"(%5452) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc64)
%5454 = mhlo.add %5451, %5453 : tensor<1x64x2048xf32> loc(#loc64)
%5455 = mhlo.convert(%5454) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc65)
%5456 = mhlo.convert(%5256) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc66)
%5457 = "mhlo.dot_general"(%5455, %5456) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc67)
%5458 = mhlo.convert(%5210) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc68)
%5459 = "mhlo.dot_general"(%5455, %5458) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc69)
%5460 = mhlo.convert(%5279) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc70)
%5461 = "mhlo.dot_general"(%5455, %5460) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc71)
%5462 = "mhlo.reshape"(%5457) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5463 = "mhlo.reshape"(%5459) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5464 = "mhlo.reshape"(%5461) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc72)
%5465 = "mhlo.broadcast_in_dim"(%iterArg_11) {broadcast_dimensions = dense<[0, 3]> : tensor<2xi64>} : (tensor<1x64xi32>) -> tensor<1x1x1x64xi32> loc(#loc73)
%5466 = mhlo.constant dense<0> : tensor<i32> loc(#loc49)
%5467 = "mhlo.broadcast_in_dim"(%5466) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x1x1x64xi32> loc(#loc74)
%5468 = "mhlo.compare"(%5465, %5467) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction GT">} : (tensor<1x1x1x64xi32>, tensor<1x1x1x64xi32>) -> tensor<1x1x1x64xi1> loc(#loc74)
%5469 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5470 = "mhlo.broadcast_in_dim"(%5469) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc75)
%5471 = mhlo.convert(%5470) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc76)
%5472 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc49)
%5473 = "mhlo.broadcast_in_dim"(%5472) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x1x64xf32> loc(#loc77)
%5474 = mhlo.convert(%5473) : (tensor<1x1x1x64xf32>) -> tensor<1x1x1x64xf16> loc(#loc78)
%5475 = "mhlo.select"(%5468, %5471, %5474) : (tensor<1x1x1x64xi1>, tensor<1x1x1x64xf16>, tensor<1x1x1x64xf16>) -> tensor<1x1x1x64xf16> loc(#loc79)
%5476 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc49)
%5477 = mhlo.sqrt %5476 : tensor<f32> loc(#loc80)
%5478 = mhlo.convert(%5477) : (tensor<f32>) -> tensor<f16> loc(#loc81)
%5479 = "mhlo.broadcast_in_dim"(%5478) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x32x64xf16> loc(#loc82)
%5480 = mhlo.divide %5462, %5479 : tensor<1x64x32x64xf16> loc(#loc82)
%5481 = func.call @_einsum_11(%5480, %5463) : (tensor<1x64x32x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x32x64x64xf16> loc(#loc83)
%5482 = "mhlo.broadcast_in_dim"(%5475) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x1x1x64xf16>) -> tensor<1x32x64x64xf16> loc(#loc84)
%5483 = mhlo.add %5481, %5482 : tensor<1x32x64x64xf16> loc(#loc84)
%5484 = mhlo.constant dense<0xFC00> : tensor<f16> loc(#loc85)
%5485 = mhlo.reduce(%5483 init: %5484) across dimensions = [3] : (tensor<1x32x64x64xf16>, tensor<f16>) -> tensor<1x32x64xf16>
reducer(%arg47: tensor<f16> loc(unknown), %arg48: tensor<f16> loc(unknown)) {
%5628 = mhlo.maximum %arg47, %arg48 : tensor<f16> loc(#loc85)
"mhlo.return"(%5628) : (tensor<f16>) -> () loc(#loc85)
} loc(#loc85)
%5486 = "mhlo.broadcast_in_dim"(%5485) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x64xf16>) -> tensor<1x32x64x1xf16> loc(#loc86)
%5487 = "mhlo.broadcast_in_dim"(%5486) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x64x1xf16>) -> tensor<1x32x64x64xf16> loc(#loc87)
%5488 = mhlo.subtract %5483, %5487 : tensor<1x32x64x64xf16> loc(#loc87)
%5489 = mhlo.exponential %5488 : tensor<1x32x64x64xf16> loc(#loc88)
%5490 = mhlo.convert(%5489) : (tensor<1x32x64x64xf16>) -> tensor<1x32x64x64xf32> loc(#loc89)
%5491 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc90)
%5492 = mhlo.reduce(%5490 init: %5491) across dimensions = [3] : (tensor<1x32x64x64xf32>, tensor<f32>) -> tensor<1x32x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc90)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc90)
} loc(#loc90)
%5493 = "mhlo.broadcast_in_dim"(%5492) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x64xf32>) -> tensor<1x32x64x1xf32> loc(#loc86)
%5494 = mhlo.convert(%5493) : (tensor<1x32x64x1xf32>) -> tensor<1x32x64x1xf16> loc(#loc91)
%5495 = "mhlo.broadcast_in_dim"(%5494) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x64x1xf16>) -> tensor<1x32x64x64xf16> loc(#loc92)
%5496 = mhlo.divide %5489, %5495 : tensor<1x32x64x64xf16> loc(#loc92)
%5497 = func.call @_einsum_12(%5496, %5464) : (tensor<1x32x64x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x64x32x64xf16> loc(#loc93)
%5498 = "mhlo.reshape"(%5497) : (tensor<1x64x32x64xf16>) -> tensor<1x64x2048xf16> loc(#loc94)
%5499 = mhlo.convert(%5233) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc95)
%5500 = "mhlo.dot_general"(%5498, %5499) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc96)
%5501 = mhlo.convert(%5500) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc97)
%5502 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc98)
%5503 = mhlo.reduce(%5501 init: %5502) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc98)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc98)
} loc(#loc98)
%5504 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5505 = "mhlo.broadcast_in_dim"(%5504) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc99)
%5506 = mhlo.divide %5503, %5505 : tensor<1x64xf32> loc(#loc99)
%5507 = mhlo.multiply %5501, %5501 : tensor<1x64x2048xf32> loc(#loc100)
%5508 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc101)
%5509 = mhlo.reduce(%5507 init: %5508) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc101)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc101)
} loc(#loc101)
%5510 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5511 = "mhlo.broadcast_in_dim"(%5510) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc102)
%5512 = mhlo.divide %5509, %5511 : tensor<1x64xf32> loc(#loc102)
%5513 = mhlo.multiply %5506, %5506 : tensor<1x64xf32> loc(#loc100)
%5514 = mhlo.subtract %5512, %5513 : tensor<1x64xf32> loc(#loc103)
%5515 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5516 = "mhlo.broadcast_in_dim"(%5515) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc104)
%5517 = mhlo.maximum %5516, %5514 : tensor<1x64xf32> loc(#loc104)
%5518 = "mhlo.reshape"(%5506) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc105)
%5519 = "mhlo.reshape"(%5517) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc106)
%5520 = mhlo.convert(%5500) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc107)
%5521 = "mhlo.broadcast_in_dim"(%5518) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc108)
%5522 = mhlo.subtract %5520, %5521 : tensor<1x64x2048xf32> loc(#loc108)
%5523 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5524 = "mhlo.broadcast_in_dim"(%5523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc109)
%5525 = mhlo.add %5519, %5524 : tensor<1x64x1xf32> loc(#loc109)
%5526 = mhlo.rsqrt %5525 : tensor<1x64x1xf32> loc(#loc110)
%5527 = "mhlo.reshape"(%5423) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc111)
%5528 = "mhlo.broadcast_in_dim"(%5526) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc112)
%5529 = "mhlo.broadcast_in_dim"(%5527) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc112)
%5530 = mhlo.multiply %5528, %5529 : tensor<1x64x2048xf32> loc(#loc112)
%5531 = mhlo.multiply %5522, %5530 : tensor<1x64x2048xf32> loc(#loc113)
%5532 = "mhlo.reshape"(%5408) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc114)
%5533 = "mhlo.broadcast_in_dim"(%5532) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc115)
%5534 = mhlo.add %5531, %5533 : tensor<1x64x2048xf32> loc(#loc115)
%5535 = mhlo.convert(%5534) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc116)
%5536 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5537 = "mhlo.broadcast_in_dim"(%5536) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x2048xf16> loc(#loc117)
%5538 = mhlo.multiply %iterArg_13, %5537 : tensor<1x64x2048xf16> loc(#loc117)
%5539 = mhlo.add %5538, %5535 : tensor<1x64x2048xf16> loc(#loc118)
%5540 = mhlo.convert(%5539) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc119)
%5541 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc120)
%5542 = mhlo.reduce(%5540 init: %5541) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc120)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc120)
} loc(#loc120)
%5543 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5544 = "mhlo.broadcast_in_dim"(%5543) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc121)
%5545 = mhlo.divide %5542, %5544 : tensor<1x64xf32> loc(#loc121)
%5546 = mhlo.multiply %5540, %5540 : tensor<1x64x2048xf32> loc(#loc122)
%5547 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc123)
%5548 = mhlo.reduce(%5546 init: %5547) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc123)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc123)
} loc(#loc123)
%5549 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc49)
%5550 = "mhlo.broadcast_in_dim"(%5549) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc124)
%5551 = mhlo.divide %5548, %5550 : tensor<1x64xf32> loc(#loc124)
%5552 = mhlo.multiply %5545, %5545 : tensor<1x64xf32> loc(#loc122)
%5553 = mhlo.subtract %5551, %5552 : tensor<1x64xf32> loc(#loc125)
%5554 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5555 = "mhlo.broadcast_in_dim"(%5554) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc126)
%5556 = mhlo.maximum %5555, %5553 : tensor<1x64xf32> loc(#loc126)
%5557 = "mhlo.reshape"(%5545) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc127)
%5558 = "mhlo.reshape"(%5556) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc128)
%5559 = mhlo.convert(%5539) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc129)
%5560 = "mhlo.broadcast_in_dim"(%5557) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc130)
%5561 = mhlo.subtract %5559, %5560 : tensor<1x64x2048xf32> loc(#loc130)
%5562 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5563 = "mhlo.broadcast_in_dim"(%5562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc131)
%5564 = mhlo.add %5558, %5563 : tensor<1x64x1xf32> loc(#loc131)
%5565 = mhlo.rsqrt %5564 : tensor<1x64x1xf32> loc(#loc132)
%5566 = "mhlo.broadcast_in_dim"(%5565) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc133)
%5567 = mhlo.multiply %5561, %5566 : tensor<1x64x2048xf32> loc(#loc133)
%5568 = "mhlo.reshape"(%5363) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc134)
%5569 = "mhlo.broadcast_in_dim"(%5568) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc135)
%5570 = mhlo.add %5567, %5569 : tensor<1x64x2048xf32> loc(#loc135)
%5571 = mhlo.convert(%5570) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc136)
%5572 = mhlo.convert(%5302) : (tensor<2048x4096xf32>) -> tensor<2048x4096xf16> loc(#loc137)
%5573 = "mhlo.dot_general"(%5571, %5572) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x4096xf16>) -> tensor<1x64x4096xf16> loc(#loc138)
%5574 = mhlo.constant dense<1.414060e+00> : tensor<f16> loc(#loc49)
%5575 = "mhlo.broadcast_in_dim"(%5574) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc139)
%5576 = mhlo.divide %5573, %5575 : tensor<1x64x4096xf16> loc(#loc139)
%5577 = chlo.erf %5576 : tensor<1x64x4096xf16> -> tensor<1x64x4096xf16> loc(#loc140)
%5578 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5579 = "mhlo.broadcast_in_dim"(%5578) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc141)
%5580 = mhlo.add %5577, %5579 : tensor<1x64x4096xf16> loc(#loc141)
%5581 = mhlo.multiply %5573, %5580 : tensor<1x64x4096xf16> loc(#loc142)
%5582 = mhlo.constant dense<2.000000e+00> : tensor<f16> loc(#loc49)
%5583 = "mhlo.broadcast_in_dim"(%5582) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x4096xf16> loc(#loc139)
%5584 = mhlo.divide %5581, %5583 : tensor<1x64x4096xf16> loc(#loc139)
%5585 = mhlo.convert(%5325) : (tensor<2048x4096xf32>) -> tensor<2048x4096xf16> loc(#loc143)
%5586 = "mhlo.dot_general"(%5571, %5585) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x4096xf16>) -> tensor<1x64x4096xf16> loc(#loc144)
%5587 = mhlo.multiply %5584, %5586 : tensor<1x64x4096xf16> loc(#loc145)
%5588 = mhlo.convert(%5587) : (tensor<1x64x4096xf16>) -> tensor<1x64x4096xf32> loc(#loc146)
%5589 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc147)
%5590 = mhlo.reduce(%5588 init: %5589) across dimensions = [2] : (tensor<1x64x4096xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc147)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc147)
} loc(#loc147)
%5591 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc49)
%5592 = "mhlo.broadcast_in_dim"(%5591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc148)
%5593 = mhlo.divide %5590, %5592 : tensor<1x64xf32> loc(#loc148)
%5594 = mhlo.multiply %5588, %5588 : tensor<1x64x4096xf32> loc(#loc149)
%5595 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc150)
%5596 = mhlo.reduce(%5594 init: %5595) across dimensions = [2] : (tensor<1x64x4096xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5628 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc150)
"mhlo.return"(%5628) : (tensor<f32>) -> () loc(#loc150)
} loc(#loc150)
%5597 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc49)
%5598 = "mhlo.broadcast_in_dim"(%5597) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc151)
%5599 = mhlo.divide %5596, %5598 : tensor<1x64xf32> loc(#loc151)
%5600 = mhlo.multiply %5593, %5593 : tensor<1x64xf32> loc(#loc149)
%5601 = mhlo.subtract %5599, %5600 : tensor<1x64xf32> loc(#loc152)
%5602 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc49)
%5603 = "mhlo.broadcast_in_dim"(%5602) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc153)
%5604 = mhlo.maximum %5603, %5601 : tensor<1x64xf32> loc(#loc153)
%5605 = "mhlo.reshape"(%5593) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc154)
%5606 = "mhlo.reshape"(%5604) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc155)
%5607 = mhlo.convert(%5587) : (tensor<1x64x4096xf16>) -> tensor<1x64x4096xf32> loc(#loc156)
%5608 = "mhlo.broadcast_in_dim"(%5605) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x4096xf32> loc(#loc157)
%5609 = mhlo.subtract %5607, %5608 : tensor<1x64x4096xf32> loc(#loc157)
%5610 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc49)
%5611 = "mhlo.broadcast_in_dim"(%5610) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc158)
%5612 = mhlo.add %5606, %5611 : tensor<1x64x1xf32> loc(#loc158)
%5613 = mhlo.rsqrt %5612 : tensor<1x64x1xf32> loc(#loc159)
%5614 = "mhlo.broadcast_in_dim"(%5613) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x4096xf32> loc(#loc160)
%5615 = mhlo.multiply %5609, %5614 : tensor<1x64x4096xf32> loc(#loc160)
%5616 = "mhlo.reshape"(%5378) : (tensor<4096xf32>) -> tensor<1x1x4096xf32> loc(#loc161)
%5617 = "mhlo.broadcast_in_dim"(%5616) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x4096xf32>) -> tensor<1x64x4096xf32> loc(#loc162)
%5618 = mhlo.add %5615, %5617 : tensor<1x64x4096xf32> loc(#loc162)
%5619 = mhlo.convert(%5618) : (tensor<1x64x4096xf32>) -> tensor<1x64x4096xf16> loc(#loc163)
%5620 = mhlo.convert(%5348) : (tensor<4096x2048xf32>) -> tensor<4096x2048xf16> loc(#loc164)
%5621 = "mhlo.dot_general"(%5619, %5620) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x4096xf16>, tensor<4096x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc165)
%5622 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc49)
%5623 = "mhlo.broadcast_in_dim"(%5622) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x64x2048xf16> loc(#loc166)
%5624 = mhlo.multiply %5539, %5623 : tensor<1x64x2048xf16> loc(#loc166)
%5625 = mhlo.add %5624, %5621 : tensor<1x64x2048xf16> loc(#loc167)
%5626 = mhlo.constant dense<1> : tensor<i32> loc(#loc36)
%5627 = mhlo.add %iterArg_12, %5626 : tensor<i32> loc(#loc39)
"mhlo.return"(%iterArg, %iterArg_0, %iterArg_1, %iterArg_2, %iterArg_3, %iterArg_4, %iterArg_5, %iterArg_6, %iterArg_7, %iterArg_8, %iterArg_9, %iterArg_10, %iterArg_11, %5627, %5625) : (tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x4096xf32>, tensor<24x2048x4096xf32>, tensor<24x4096x2048xf32>, tensor<24x2048xf32>, tensor<24x4096xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<1x64xi32>, tensor<i32>, tensor<1x64x2048xf16>) -> () loc(#loc36)
} loc(#loc36)
%186 = mhlo.convert(%185#14) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc168)
%187 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc169)
%188 = mhlo.reduce(%186 init: %187) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc169)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc169)
} loc(#loc169)
%189 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%190 = "mhlo.broadcast_in_dim"(%189) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc170)
%191 = mhlo.divide %188, %190 : tensor<1x64xf32> loc(#loc170)
%192 = mhlo.multiply %186, %186 : tensor<1x64x2048xf32> loc(#loc171)
%193 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc172)
%194 = mhlo.reduce(%192 init: %193) across dimensions = [2] : (tensor<1x64x2048xf32>, tensor<f32>) -> tensor<1x64xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc172)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc172)
} loc(#loc172)
%195 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%196 = "mhlo.broadcast_in_dim"(%195) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc173)
%197 = mhlo.divide %194, %196 : tensor<1x64xf32> loc(#loc173)
%198 = mhlo.multiply %191, %191 : tensor<1x64xf32> loc(#loc171)
%199 = mhlo.subtract %197, %198 : tensor<1x64xf32> loc(#loc174)
%200 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%201 = "mhlo.broadcast_in_dim"(%200) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64xf32> loc(#loc175)
%202 = mhlo.maximum %201, %199 : tensor<1x64xf32> loc(#loc175)
%203 = "mhlo.reshape"(%191) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc176)
%204 = "mhlo.reshape"(%202) : (tensor<1x64xf32>) -> tensor<1x64x1xf32> loc(#loc177)
%205 = mhlo.convert(%185#14) : (tensor<1x64x2048xf16>) -> tensor<1x64x2048xf32> loc(#loc178)
%206 = "mhlo.broadcast_in_dim"(%203) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc179)
%207 = mhlo.subtract %205, %206 : tensor<1x64x2048xf32> loc(#loc179)
%208 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc0)
%209 = "mhlo.broadcast_in_dim"(%208) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x64x1xf32> loc(#loc180)
%210 = mhlo.add %204, %209 : tensor<1x64x1xf32> loc(#loc180)
%211 = mhlo.rsqrt %210 : tensor<1x64x1xf32> loc(#loc181)
%212 = "mhlo.broadcast_in_dim"(%211) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x64x1xf32>) -> tensor<1x64x2048xf32> loc(#loc182)
%213 = mhlo.multiply %207, %212 : tensor<1x64x2048xf32> loc(#loc182)
%214 = "mhlo.reshape"(%arg32) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc183)
%215 = "mhlo.broadcast_in_dim"(%214) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x64x2048xf32> loc(#loc184)
%216 = mhlo.add %213, %215 : tensor<1x64x2048xf32> loc(#loc184)
%217 = mhlo.convert(%216) : (tensor<1x64x2048xf32>) -> tensor<1x64x2048xf16> loc(#loc185)
%218 = mhlo.constant dense<1> : tensor<i32> loc(#loc0)
%219 = "mhlo.broadcast_in_dim"(%218) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x1xi32> loc(#loc186)
%220 = mhlo.constant dense<16384> : tensor<i32> loc(#loc0)
%221 = "mhlo.broadcast_in_dim"(%220) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x1xi32> loc(#loc187)
%222 = mhlo.multiply %219, %221 : tensor<1x1xi32> loc(#loc187)
%223 = mhlo.constant dense<16385> : tensor<i32> loc(#loc0)
%224 = "mhlo.broadcast_in_dim"(%223) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x257xi32> loc(#loc188)
%225 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%226 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%227 = "mhlo.dynamic-update-slice"(%224, %222, %225, %226) : (tensor<1x257xi32>, tensor<1x1xi32>, tensor<i32>, tensor<i32>) -> tensor<1x257xi32> loc(#loc189)
%228 = mhlo.constant dense<false> : tensor<i1> loc(#loc0)
%229 = "mhlo.broadcast_in_dim"(%228) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i1>) -> tensor<1xi1> loc(#loc190)
%230 = mhlo.constant dense<1> : tensor<i32> loc(#loc0)
%231 = "mhlo.broadcast_in_dim"(%230) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x256xi32> loc(#loc191)
%232 = mhlo.constant dense<1> : tensor<i32> loc(#loc0)
%233 = "mhlo.broadcast_in_dim"(%232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x256xi32> loc(#loc192)
%234 = call @atleast_2d(%231) : (tensor<1x256xi32>) -> tensor<1x256xi32> loc(#loc193)
%235 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<256xi32> loc(#loc194)
%236 = "mhlo.broadcast_in_dim"(%235) {broadcast_dimensions = dense<1> : tensor<1xi64>} : (tensor<256xi32>) -> tensor<1x256xi32> loc(#loc195)
%237 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%238 = mhlo.constant dense<32> : tensor<i32> loc(#loc0)
%239 = mhlo.shift_right_logical %237, %238 : tensor<i32> loc(#loc196)
%240 = mhlo.convert(%239) : (tensor<i32>) -> tensor<ui32> loc(#loc197)
%241 = "mhlo.reshape"(%240) : (tensor<ui32>) -> tensor<1xui32> loc(#loc198)
%242 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc0)
%243 = mhlo.convert(%242) : (tensor<ui32>) -> tensor<i32> loc(#loc199)
%244 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%245 = mhlo.and %244, %243 : tensor<i32> loc(#loc200)
%246 = mhlo.convert(%245) : (tensor<i32>) -> tensor<ui32> loc(#loc197)
%247 = "mhlo.reshape"(%246) : (tensor<ui32>) -> tensor<1xui32> loc(#loc198)
%248 = "mhlo.concatenate"(%241, %247) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc201)
%249 = mhlo.constant dense<661413802> : tensor<ui32> loc(#loc0)
%250 = mhlo.constant dense<32> : tensor<ui32> loc(#loc0)
%251 = mhlo.shift_right_logical %249, %250 : tensor<ui32> loc(#loc202)
%252 = "mhlo.reshape"(%251) : (tensor<ui32>) -> tensor<1xui32> loc(#loc203)
%253 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc0)
%254 = mhlo.and %249, %253 : tensor<ui32> loc(#loc204)
%255 = "mhlo.reshape"(%254) : (tensor<ui32>) -> tensor<1xui32> loc(#loc203)
%256 = "mhlo.concatenate"(%252, %255) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc205)
%257 = "mhlo.slice"(%248) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc206)
%258 = "mhlo.reshape"(%257) : (tensor<1xui32>) -> tensor<ui32> loc(#loc207)
%259 = "mhlo.slice"(%248) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc208)
%260 = "mhlo.reshape"(%259) : (tensor<1xui32>) -> tensor<ui32> loc(#loc207)
%261 = "mhlo.slice"(%256) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc209)
%262 = "mhlo.slice"(%256) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc210)
%263 = mhlo.xor %258, %260 : tensor<ui32> loc(#loc211)
%264 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc212)
%265 = mhlo.xor %263, %264 : tensor<ui32> loc(#loc211)
%266 = "mhlo.broadcast_in_dim"(%258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%267 = mhlo.add %261, %266 : tensor<1xui32> loc(#loc213)
%268 = "mhlo.broadcast_in_dim"(%260) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%269 = mhlo.add %262, %268 : tensor<1xui32> loc(#loc213)
%270 = mhlo.add %267, %269 : tensor<1xui32> loc(#loc213)
%271 = mhlo.constant dense<13> : tensor<ui32> loc(#loc212)
%272 = "mhlo.broadcast_in_dim"(%271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%273 = mhlo.shift_left %269, %272 : tensor<1xui32> loc(#loc214)
%274 = mhlo.constant dense<19> : tensor<ui32> loc(#loc212)
%275 = "mhlo.broadcast_in_dim"(%274) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%276 = mhlo.shift_right_logical %269, %275 : tensor<1xui32> loc(#loc202)
%277 = mhlo.or %273, %276 : tensor<1xui32> loc(#loc215)
%278 = mhlo.xor %270, %277 : tensor<1xui32> loc(#loc211)
%279 = mhlo.add %270, %278 : tensor<1xui32> loc(#loc213)
%280 = mhlo.constant dense<15> : tensor<ui32> loc(#loc212)
%281 = "mhlo.broadcast_in_dim"(%280) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%282 = mhlo.shift_left %278, %281 : tensor<1xui32> loc(#loc214)
%283 = mhlo.constant dense<17> : tensor<ui32> loc(#loc212)
%284 = "mhlo.broadcast_in_dim"(%283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%285 = mhlo.shift_right_logical %278, %284 : tensor<1xui32> loc(#loc202)
%286 = mhlo.or %282, %285 : tensor<1xui32> loc(#loc215)
%287 = mhlo.xor %279, %286 : tensor<1xui32> loc(#loc211)
%288 = mhlo.add %279, %287 : tensor<1xui32> loc(#loc213)
%289 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%290 = "mhlo.broadcast_in_dim"(%289) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%291 = mhlo.shift_left %287, %290 : tensor<1xui32> loc(#loc214)
%292 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%293 = "mhlo.broadcast_in_dim"(%292) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%294 = mhlo.shift_right_logical %287, %293 : tensor<1xui32> loc(#loc202)
%295 = mhlo.or %291, %294 : tensor<1xui32> loc(#loc215)
%296 = mhlo.xor %288, %295 : tensor<1xui32> loc(#loc211)
%297 = mhlo.add %288, %296 : tensor<1xui32> loc(#loc213)
%298 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%299 = "mhlo.broadcast_in_dim"(%298) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%300 = mhlo.shift_left %296, %299 : tensor<1xui32> loc(#loc214)
%301 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%302 = "mhlo.broadcast_in_dim"(%301) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%303 = mhlo.shift_right_logical %296, %302 : tensor<1xui32> loc(#loc202)
%304 = mhlo.or %300, %303 : tensor<1xui32> loc(#loc215)
%305 = mhlo.xor %297, %304 : tensor<1xui32> loc(#loc211)
%306 = "mhlo.broadcast_in_dim"(%260) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%307 = mhlo.add %297, %306 : tensor<1xui32> loc(#loc213)
%308 = "mhlo.broadcast_in_dim"(%265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%309 = mhlo.add %305, %308 : tensor<1xui32> loc(#loc213)
%310 = mhlo.constant dense<1> : tensor<ui32> loc(#loc212)
%311 = "mhlo.broadcast_in_dim"(%310) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%312 = mhlo.add %309, %311 : tensor<1xui32> loc(#loc213)
%313 = mhlo.add %307, %312 : tensor<1xui32> loc(#loc213)
%314 = mhlo.constant dense<17> : tensor<ui32> loc(#loc212)
%315 = "mhlo.broadcast_in_dim"(%314) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%316 = mhlo.shift_left %312, %315 : tensor<1xui32> loc(#loc214)
%317 = mhlo.constant dense<15> : tensor<ui32> loc(#loc212)
%318 = "mhlo.broadcast_in_dim"(%317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%319 = mhlo.shift_right_logical %312, %318 : tensor<1xui32> loc(#loc202)
%320 = mhlo.or %316, %319 : tensor<1xui32> loc(#loc215)
%321 = mhlo.xor %313, %320 : tensor<1xui32> loc(#loc211)
%322 = mhlo.add %313, %321 : tensor<1xui32> loc(#loc213)
%323 = mhlo.constant dense<29> : tensor<ui32> loc(#loc212)
%324 = "mhlo.broadcast_in_dim"(%323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%325 = mhlo.shift_left %321, %324 : tensor<1xui32> loc(#loc214)
%326 = mhlo.constant dense<3> : tensor<ui32> loc(#loc212)
%327 = "mhlo.broadcast_in_dim"(%326) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%328 = mhlo.shift_right_logical %321, %327 : tensor<1xui32> loc(#loc202)
%329 = mhlo.or %325, %328 : tensor<1xui32> loc(#loc215)
%330 = mhlo.xor %322, %329 : tensor<1xui32> loc(#loc211)
%331 = mhlo.add %322, %330 : tensor<1xui32> loc(#loc213)
%332 = mhlo.constant dense<16> : tensor<ui32> loc(#loc212)
%333 = "mhlo.broadcast_in_dim"(%332) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%334 = mhlo.shift_left %330, %333 : tensor<1xui32> loc(#loc214)
%335 = mhlo.constant dense<16> : tensor<ui32> loc(#loc212)
%336 = "mhlo.broadcast_in_dim"(%335) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%337 = mhlo.shift_right_logical %330, %336 : tensor<1xui32> loc(#loc202)
%338 = mhlo.or %334, %337 : tensor<1xui32> loc(#loc215)
%339 = mhlo.xor %331, %338 : tensor<1xui32> loc(#loc211)
%340 = mhlo.add %331, %339 : tensor<1xui32> loc(#loc213)
%341 = mhlo.constant dense<24> : tensor<ui32> loc(#loc212)
%342 = "mhlo.broadcast_in_dim"(%341) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%343 = mhlo.shift_left %339, %342 : tensor<1xui32> loc(#loc214)
%344 = mhlo.constant dense<8> : tensor<ui32> loc(#loc212)
%345 = "mhlo.broadcast_in_dim"(%344) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%346 = mhlo.shift_right_logical %339, %345 : tensor<1xui32> loc(#loc202)
%347 = mhlo.or %343, %346 : tensor<1xui32> loc(#loc215)
%348 = mhlo.xor %340, %347 : tensor<1xui32> loc(#loc211)
%349 = "mhlo.broadcast_in_dim"(%265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%350 = mhlo.add %340, %349 : tensor<1xui32> loc(#loc213)
%351 = "mhlo.broadcast_in_dim"(%258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%352 = mhlo.add %348, %351 : tensor<1xui32> loc(#loc213)
%353 = mhlo.constant dense<2> : tensor<ui32> loc(#loc212)
%354 = "mhlo.broadcast_in_dim"(%353) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%355 = mhlo.add %352, %354 : tensor<1xui32> loc(#loc213)
%356 = mhlo.add %350, %355 : tensor<1xui32> loc(#loc213)
%357 = mhlo.constant dense<13> : tensor<ui32> loc(#loc212)
%358 = "mhlo.broadcast_in_dim"(%357) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%359 = mhlo.shift_left %355, %358 : tensor<1xui32> loc(#loc214)
%360 = mhlo.constant dense<19> : tensor<ui32> loc(#loc212)
%361 = "mhlo.broadcast_in_dim"(%360) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%362 = mhlo.shift_right_logical %355, %361 : tensor<1xui32> loc(#loc202)
%363 = mhlo.or %359, %362 : tensor<1xui32> loc(#loc215)
%364 = mhlo.xor %356, %363 : tensor<1xui32> loc(#loc211)
%365 = mhlo.add %356, %364 : tensor<1xui32> loc(#loc213)
%366 = mhlo.constant dense<15> : tensor<ui32> loc(#loc212)
%367 = "mhlo.broadcast_in_dim"(%366) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%368 = mhlo.shift_left %364, %367 : tensor<1xui32> loc(#loc214)
%369 = mhlo.constant dense<17> : tensor<ui32> loc(#loc212)
%370 = "mhlo.broadcast_in_dim"(%369) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%371 = mhlo.shift_right_logical %364, %370 : tensor<1xui32> loc(#loc202)
%372 = mhlo.or %368, %371 : tensor<1xui32> loc(#loc215)
%373 = mhlo.xor %365, %372 : tensor<1xui32> loc(#loc211)
%374 = mhlo.add %365, %373 : tensor<1xui32> loc(#loc213)
%375 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%376 = "mhlo.broadcast_in_dim"(%375) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%377 = mhlo.shift_left %373, %376 : tensor<1xui32> loc(#loc214)
%378 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%379 = "mhlo.broadcast_in_dim"(%378) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%380 = mhlo.shift_right_logical %373, %379 : tensor<1xui32> loc(#loc202)
%381 = mhlo.or %377, %380 : tensor<1xui32> loc(#loc215)
%382 = mhlo.xor %374, %381 : tensor<1xui32> loc(#loc211)
%383 = mhlo.add %374, %382 : tensor<1xui32> loc(#loc213)
%384 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%385 = "mhlo.broadcast_in_dim"(%384) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%386 = mhlo.shift_left %382, %385 : tensor<1xui32> loc(#loc214)
%387 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%388 = "mhlo.broadcast_in_dim"(%387) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%389 = mhlo.shift_right_logical %382, %388 : tensor<1xui32> loc(#loc202)
%390 = mhlo.or %386, %389 : tensor<1xui32> loc(#loc215)
%391 = mhlo.xor %383, %390 : tensor<1xui32> loc(#loc211)
%392 = "mhlo.broadcast_in_dim"(%258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%393 = mhlo.add %383, %392 : tensor<1xui32> loc(#loc213)
%394 = "mhlo.broadcast_in_dim"(%260) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%395 = mhlo.add %391, %394 : tensor<1xui32> loc(#loc213)
%396 = mhlo.constant dense<3> : tensor<ui32> loc(#loc212)
%397 = "mhlo.broadcast_in_dim"(%396) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%398 = mhlo.add %395, %397 : tensor<1xui32> loc(#loc213)
%399 = mhlo.add %393, %398 : tensor<1xui32> loc(#loc213)
%400 = mhlo.constant dense<17> : tensor<ui32> loc(#loc212)
%401 = "mhlo.broadcast_in_dim"(%400) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%402 = mhlo.shift_left %398, %401 : tensor<1xui32> loc(#loc214)
%403 = mhlo.constant dense<15> : tensor<ui32> loc(#loc212)
%404 = "mhlo.broadcast_in_dim"(%403) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%405 = mhlo.shift_right_logical %398, %404 : tensor<1xui32> loc(#loc202)
%406 = mhlo.or %402, %405 : tensor<1xui32> loc(#loc215)
%407 = mhlo.xor %399, %406 : tensor<1xui32> loc(#loc211)
%408 = mhlo.add %399, %407 : tensor<1xui32> loc(#loc213)
%409 = mhlo.constant dense<29> : tensor<ui32> loc(#loc212)
%410 = "mhlo.broadcast_in_dim"(%409) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%411 = mhlo.shift_left %407, %410 : tensor<1xui32> loc(#loc214)
%412 = mhlo.constant dense<3> : tensor<ui32> loc(#loc212)
%413 = "mhlo.broadcast_in_dim"(%412) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%414 = mhlo.shift_right_logical %407, %413 : tensor<1xui32> loc(#loc202)
%415 = mhlo.or %411, %414 : tensor<1xui32> loc(#loc215)
%416 = mhlo.xor %408, %415 : tensor<1xui32> loc(#loc211)
%417 = mhlo.add %408, %416 : tensor<1xui32> loc(#loc213)
%418 = mhlo.constant dense<16> : tensor<ui32> loc(#loc212)
%419 = "mhlo.broadcast_in_dim"(%418) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%420 = mhlo.shift_left %416, %419 : tensor<1xui32> loc(#loc214)
%421 = mhlo.constant dense<16> : tensor<ui32> loc(#loc212)
%422 = "mhlo.broadcast_in_dim"(%421) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%423 = mhlo.shift_right_logical %416, %422 : tensor<1xui32> loc(#loc202)
%424 = mhlo.or %420, %423 : tensor<1xui32> loc(#loc215)
%425 = mhlo.xor %417, %424 : tensor<1xui32> loc(#loc211)
%426 = mhlo.add %417, %425 : tensor<1xui32> loc(#loc213)
%427 = mhlo.constant dense<24> : tensor<ui32> loc(#loc212)
%428 = "mhlo.broadcast_in_dim"(%427) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%429 = mhlo.shift_left %425, %428 : tensor<1xui32> loc(#loc214)
%430 = mhlo.constant dense<8> : tensor<ui32> loc(#loc212)
%431 = "mhlo.broadcast_in_dim"(%430) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%432 = mhlo.shift_right_logical %425, %431 : tensor<1xui32> loc(#loc202)
%433 = mhlo.or %429, %432 : tensor<1xui32> loc(#loc215)
%434 = mhlo.xor %426, %433 : tensor<1xui32> loc(#loc211)
%435 = "mhlo.broadcast_in_dim"(%260) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%436 = mhlo.add %426, %435 : tensor<1xui32> loc(#loc213)
%437 = "mhlo.broadcast_in_dim"(%265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%438 = mhlo.add %434, %437 : tensor<1xui32> loc(#loc213)
%439 = mhlo.constant dense<4> : tensor<ui32> loc(#loc212)
%440 = "mhlo.broadcast_in_dim"(%439) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%441 = mhlo.add %438, %440 : tensor<1xui32> loc(#loc213)
%442 = mhlo.add %436, %441 : tensor<1xui32> loc(#loc213)
%443 = mhlo.constant dense<13> : tensor<ui32> loc(#loc212)
%444 = "mhlo.broadcast_in_dim"(%443) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%445 = mhlo.shift_left %441, %444 : tensor<1xui32> loc(#loc214)
%446 = mhlo.constant dense<19> : tensor<ui32> loc(#loc212)
%447 = "mhlo.broadcast_in_dim"(%446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%448 = mhlo.shift_right_logical %441, %447 : tensor<1xui32> loc(#loc202)
%449 = mhlo.or %445, %448 : tensor<1xui32> loc(#loc215)
%450 = mhlo.xor %442, %449 : tensor<1xui32> loc(#loc211)
%451 = mhlo.add %442, %450 : tensor<1xui32> loc(#loc213)
%452 = mhlo.constant dense<15> : tensor<ui32> loc(#loc212)
%453 = "mhlo.broadcast_in_dim"(%452) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%454 = mhlo.shift_left %450, %453 : tensor<1xui32> loc(#loc214)
%455 = mhlo.constant dense<17> : tensor<ui32> loc(#loc212)
%456 = "mhlo.broadcast_in_dim"(%455) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%457 = mhlo.shift_right_logical %450, %456 : tensor<1xui32> loc(#loc202)
%458 = mhlo.or %454, %457 : tensor<1xui32> loc(#loc215)
%459 = mhlo.xor %451, %458 : tensor<1xui32> loc(#loc211)
%460 = mhlo.add %451, %459 : tensor<1xui32> loc(#loc213)
%461 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%462 = "mhlo.broadcast_in_dim"(%461) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%463 = mhlo.shift_left %459, %462 : tensor<1xui32> loc(#loc214)
%464 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%465 = "mhlo.broadcast_in_dim"(%464) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%466 = mhlo.shift_right_logical %459, %465 : tensor<1xui32> loc(#loc202)
%467 = mhlo.or %463, %466 : tensor<1xui32> loc(#loc215)
%468 = mhlo.xor %460, %467 : tensor<1xui32> loc(#loc211)
%469 = mhlo.add %460, %468 : tensor<1xui32> loc(#loc213)
%470 = mhlo.constant dense<6> : tensor<ui32> loc(#loc212)
%471 = "mhlo.broadcast_in_dim"(%470) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc214)
%472 = mhlo.shift_left %468, %471 : tensor<1xui32> loc(#loc214)
%473 = mhlo.constant dense<26> : tensor<ui32> loc(#loc212)
%474 = "mhlo.broadcast_in_dim"(%473) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc202)
%475 = mhlo.shift_right_logical %468, %474 : tensor<1xui32> loc(#loc202)
%476 = mhlo.or %472, %475 : tensor<1xui32> loc(#loc215)
%477 = mhlo.xor %469, %476 : tensor<1xui32> loc(#loc211)
%478 = "mhlo.broadcast_in_dim"(%265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%479 = mhlo.add %469, %478 : tensor<1xui32> loc(#loc213)
%480 = "mhlo.broadcast_in_dim"(%258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%481 = mhlo.add %477, %480 : tensor<1xui32> loc(#loc213)
%482 = mhlo.constant dense<5> : tensor<ui32> loc(#loc212)
%483 = "mhlo.broadcast_in_dim"(%482) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc213)
%484 = mhlo.add %481, %483 : tensor<1xui32> loc(#loc213)
%485 = "mhlo.concatenate"(%479, %484) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc205)
%486 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc0)
%487 = "mhlo.broadcast_in_dim"(%486) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc216)
%488 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%489 = "mhlo.broadcast_in_dim"(%488) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc216)
%490 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<33619968xui32> loc(#loc217)
%491 = "mhlo.slice"(%485) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc218)
%492 = "mhlo.reshape"(%491) : (tensor<1xui32>) -> tensor<ui32> loc(#loc219)
%493 = "mhlo.slice"(%485) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc220)
%494 = "mhlo.reshape"(%493) : (tensor<1xui32>) -> tensor<ui32> loc(#loc219)
%495 = "mhlo.slice"(%490) {limit_indices = dense<16809984> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<33619968xui32>) -> tensor<16809984xui32> loc(#loc221)
%496 = "mhlo.slice"(%490) {limit_indices = dense<33619968> : tensor<1xi64>, start_indices = dense<16809984> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<33619968xui32>) -> tensor<16809984xui32> loc(#loc222)
%497 = mhlo.xor %492, %494 : tensor<ui32> loc(#loc223)
%498 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc224)
%499 = mhlo.xor %497, %498 : tensor<ui32> loc(#loc223)
%500 = "mhlo.broadcast_in_dim"(%492) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%501 = mhlo.add %495, %500 : tensor<16809984xui32> loc(#loc225)
%502 = "mhlo.broadcast_in_dim"(%494) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%503 = mhlo.add %496, %502 : tensor<16809984xui32> loc(#loc225)
%504 = mhlo.add %501, %503 : tensor<16809984xui32> loc(#loc225)
%505 = mhlo.constant dense<13> : tensor<ui32> loc(#loc224)
%506 = "mhlo.broadcast_in_dim"(%505) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%507 = mhlo.shift_left %503, %506 : tensor<16809984xui32> loc(#loc226)
%508 = mhlo.constant dense<19> : tensor<ui32> loc(#loc224)
%509 = "mhlo.broadcast_in_dim"(%508) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%510 = mhlo.shift_right_logical %503, %509 : tensor<16809984xui32> loc(#loc227)
%511 = mhlo.or %507, %510 : tensor<16809984xui32> loc(#loc228)
%512 = mhlo.xor %504, %511 : tensor<16809984xui32> loc(#loc223)
%513 = mhlo.add %504, %512 : tensor<16809984xui32> loc(#loc225)
%514 = mhlo.constant dense<15> : tensor<ui32> loc(#loc224)
%515 = "mhlo.broadcast_in_dim"(%514) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%516 = mhlo.shift_left %512, %515 : tensor<16809984xui32> loc(#loc226)
%517 = mhlo.constant dense<17> : tensor<ui32> loc(#loc224)
%518 = "mhlo.broadcast_in_dim"(%517) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%519 = mhlo.shift_right_logical %512, %518 : tensor<16809984xui32> loc(#loc227)
%520 = mhlo.or %516, %519 : tensor<16809984xui32> loc(#loc228)
%521 = mhlo.xor %513, %520 : tensor<16809984xui32> loc(#loc223)
%522 = mhlo.add %513, %521 : tensor<16809984xui32> loc(#loc225)
%523 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%524 = "mhlo.broadcast_in_dim"(%523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%525 = mhlo.shift_left %521, %524 : tensor<16809984xui32> loc(#loc226)
%526 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%527 = "mhlo.broadcast_in_dim"(%526) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%528 = mhlo.shift_right_logical %521, %527 : tensor<16809984xui32> loc(#loc227)
%529 = mhlo.or %525, %528 : tensor<16809984xui32> loc(#loc228)
%530 = mhlo.xor %522, %529 : tensor<16809984xui32> loc(#loc223)
%531 = mhlo.add %522, %530 : tensor<16809984xui32> loc(#loc225)
%532 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%533 = "mhlo.broadcast_in_dim"(%532) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%534 = mhlo.shift_left %530, %533 : tensor<16809984xui32> loc(#loc226)
%535 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%536 = "mhlo.broadcast_in_dim"(%535) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%537 = mhlo.shift_right_logical %530, %536 : tensor<16809984xui32> loc(#loc227)
%538 = mhlo.or %534, %537 : tensor<16809984xui32> loc(#loc228)
%539 = mhlo.xor %531, %538 : tensor<16809984xui32> loc(#loc223)
%540 = "mhlo.broadcast_in_dim"(%494) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%541 = mhlo.add %531, %540 : tensor<16809984xui32> loc(#loc225)
%542 = "mhlo.broadcast_in_dim"(%499) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%543 = mhlo.add %539, %542 : tensor<16809984xui32> loc(#loc225)
%544 = mhlo.constant dense<1> : tensor<ui32> loc(#loc224)
%545 = "mhlo.broadcast_in_dim"(%544) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%546 = mhlo.add %543, %545 : tensor<16809984xui32> loc(#loc225)
%547 = mhlo.add %541, %546 : tensor<16809984xui32> loc(#loc225)
%548 = mhlo.constant dense<17> : tensor<ui32> loc(#loc224)
%549 = "mhlo.broadcast_in_dim"(%548) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%550 = mhlo.shift_left %546, %549 : tensor<16809984xui32> loc(#loc226)
%551 = mhlo.constant dense<15> : tensor<ui32> loc(#loc224)
%552 = "mhlo.broadcast_in_dim"(%551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%553 = mhlo.shift_right_logical %546, %552 : tensor<16809984xui32> loc(#loc227)
%554 = mhlo.or %550, %553 : tensor<16809984xui32> loc(#loc228)
%555 = mhlo.xor %547, %554 : tensor<16809984xui32> loc(#loc223)
%556 = mhlo.add %547, %555 : tensor<16809984xui32> loc(#loc225)
%557 = mhlo.constant dense<29> : tensor<ui32> loc(#loc224)
%558 = "mhlo.broadcast_in_dim"(%557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%559 = mhlo.shift_left %555, %558 : tensor<16809984xui32> loc(#loc226)
%560 = mhlo.constant dense<3> : tensor<ui32> loc(#loc224)
%561 = "mhlo.broadcast_in_dim"(%560) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%562 = mhlo.shift_right_logical %555, %561 : tensor<16809984xui32> loc(#loc227)
%563 = mhlo.or %559, %562 : tensor<16809984xui32> loc(#loc228)
%564 = mhlo.xor %556, %563 : tensor<16809984xui32> loc(#loc223)
%565 = mhlo.add %556, %564 : tensor<16809984xui32> loc(#loc225)
%566 = mhlo.constant dense<16> : tensor<ui32> loc(#loc224)
%567 = "mhlo.broadcast_in_dim"(%566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%568 = mhlo.shift_left %564, %567 : tensor<16809984xui32> loc(#loc226)
%569 = mhlo.constant dense<16> : tensor<ui32> loc(#loc224)
%570 = "mhlo.broadcast_in_dim"(%569) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%571 = mhlo.shift_right_logical %564, %570 : tensor<16809984xui32> loc(#loc227)
%572 = mhlo.or %568, %571 : tensor<16809984xui32> loc(#loc228)
%573 = mhlo.xor %565, %572 : tensor<16809984xui32> loc(#loc223)
%574 = mhlo.add %565, %573 : tensor<16809984xui32> loc(#loc225)
%575 = mhlo.constant dense<24> : tensor<ui32> loc(#loc224)
%576 = "mhlo.broadcast_in_dim"(%575) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%577 = mhlo.shift_left %573, %576 : tensor<16809984xui32> loc(#loc226)
%578 = mhlo.constant dense<8> : tensor<ui32> loc(#loc224)
%579 = "mhlo.broadcast_in_dim"(%578) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%580 = mhlo.shift_right_logical %573, %579 : tensor<16809984xui32> loc(#loc227)
%581 = mhlo.or %577, %580 : tensor<16809984xui32> loc(#loc228)
%582 = mhlo.xor %574, %581 : tensor<16809984xui32> loc(#loc223)
%583 = "mhlo.broadcast_in_dim"(%499) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%584 = mhlo.add %574, %583 : tensor<16809984xui32> loc(#loc225)
%585 = "mhlo.broadcast_in_dim"(%492) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%586 = mhlo.add %582, %585 : tensor<16809984xui32> loc(#loc225)
%587 = mhlo.constant dense<2> : tensor<ui32> loc(#loc224)
%588 = "mhlo.broadcast_in_dim"(%587) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%589 = mhlo.add %586, %588 : tensor<16809984xui32> loc(#loc225)
%590 = mhlo.add %584, %589 : tensor<16809984xui32> loc(#loc225)
%591 = mhlo.constant dense<13> : tensor<ui32> loc(#loc224)
%592 = "mhlo.broadcast_in_dim"(%591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%593 = mhlo.shift_left %589, %592 : tensor<16809984xui32> loc(#loc226)
%594 = mhlo.constant dense<19> : tensor<ui32> loc(#loc224)
%595 = "mhlo.broadcast_in_dim"(%594) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%596 = mhlo.shift_right_logical %589, %595 : tensor<16809984xui32> loc(#loc227)
%597 = mhlo.or %593, %596 : tensor<16809984xui32> loc(#loc228)
%598 = mhlo.xor %590, %597 : tensor<16809984xui32> loc(#loc223)
%599 = mhlo.add %590, %598 : tensor<16809984xui32> loc(#loc225)
%600 = mhlo.constant dense<15> : tensor<ui32> loc(#loc224)
%601 = "mhlo.broadcast_in_dim"(%600) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%602 = mhlo.shift_left %598, %601 : tensor<16809984xui32> loc(#loc226)
%603 = mhlo.constant dense<17> : tensor<ui32> loc(#loc224)
%604 = "mhlo.broadcast_in_dim"(%603) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%605 = mhlo.shift_right_logical %598, %604 : tensor<16809984xui32> loc(#loc227)
%606 = mhlo.or %602, %605 : tensor<16809984xui32> loc(#loc228)
%607 = mhlo.xor %599, %606 : tensor<16809984xui32> loc(#loc223)
%608 = mhlo.add %599, %607 : tensor<16809984xui32> loc(#loc225)
%609 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%610 = "mhlo.broadcast_in_dim"(%609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%611 = mhlo.shift_left %607, %610 : tensor<16809984xui32> loc(#loc226)
%612 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%613 = "mhlo.broadcast_in_dim"(%612) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%614 = mhlo.shift_right_logical %607, %613 : tensor<16809984xui32> loc(#loc227)
%615 = mhlo.or %611, %614 : tensor<16809984xui32> loc(#loc228)
%616 = mhlo.xor %608, %615 : tensor<16809984xui32> loc(#loc223)
%617 = mhlo.add %608, %616 : tensor<16809984xui32> loc(#loc225)
%618 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%619 = "mhlo.broadcast_in_dim"(%618) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%620 = mhlo.shift_left %616, %619 : tensor<16809984xui32> loc(#loc226)
%621 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%622 = "mhlo.broadcast_in_dim"(%621) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%623 = mhlo.shift_right_logical %616, %622 : tensor<16809984xui32> loc(#loc227)
%624 = mhlo.or %620, %623 : tensor<16809984xui32> loc(#loc228)
%625 = mhlo.xor %617, %624 : tensor<16809984xui32> loc(#loc223)
%626 = "mhlo.broadcast_in_dim"(%492) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%627 = mhlo.add %617, %626 : tensor<16809984xui32> loc(#loc225)
%628 = "mhlo.broadcast_in_dim"(%494) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%629 = mhlo.add %625, %628 : tensor<16809984xui32> loc(#loc225)
%630 = mhlo.constant dense<3> : tensor<ui32> loc(#loc224)
%631 = "mhlo.broadcast_in_dim"(%630) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%632 = mhlo.add %629, %631 : tensor<16809984xui32> loc(#loc225)
%633 = mhlo.add %627, %632 : tensor<16809984xui32> loc(#loc225)
%634 = mhlo.constant dense<17> : tensor<ui32> loc(#loc224)
%635 = "mhlo.broadcast_in_dim"(%634) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%636 = mhlo.shift_left %632, %635 : tensor<16809984xui32> loc(#loc226)
%637 = mhlo.constant dense<15> : tensor<ui32> loc(#loc224)
%638 = "mhlo.broadcast_in_dim"(%637) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%639 = mhlo.shift_right_logical %632, %638 : tensor<16809984xui32> loc(#loc227)
%640 = mhlo.or %636, %639 : tensor<16809984xui32> loc(#loc228)
%641 = mhlo.xor %633, %640 : tensor<16809984xui32> loc(#loc223)
%642 = mhlo.add %633, %641 : tensor<16809984xui32> loc(#loc225)
%643 = mhlo.constant dense<29> : tensor<ui32> loc(#loc224)
%644 = "mhlo.broadcast_in_dim"(%643) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%645 = mhlo.shift_left %641, %644 : tensor<16809984xui32> loc(#loc226)
%646 = mhlo.constant dense<3> : tensor<ui32> loc(#loc224)
%647 = "mhlo.broadcast_in_dim"(%646) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%648 = mhlo.shift_right_logical %641, %647 : tensor<16809984xui32> loc(#loc227)
%649 = mhlo.or %645, %648 : tensor<16809984xui32> loc(#loc228)
%650 = mhlo.xor %642, %649 : tensor<16809984xui32> loc(#loc223)
%651 = mhlo.add %642, %650 : tensor<16809984xui32> loc(#loc225)
%652 = mhlo.constant dense<16> : tensor<ui32> loc(#loc224)
%653 = "mhlo.broadcast_in_dim"(%652) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%654 = mhlo.shift_left %650, %653 : tensor<16809984xui32> loc(#loc226)
%655 = mhlo.constant dense<16> : tensor<ui32> loc(#loc224)
%656 = "mhlo.broadcast_in_dim"(%655) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%657 = mhlo.shift_right_logical %650, %656 : tensor<16809984xui32> loc(#loc227)
%658 = mhlo.or %654, %657 : tensor<16809984xui32> loc(#loc228)
%659 = mhlo.xor %651, %658 : tensor<16809984xui32> loc(#loc223)
%660 = mhlo.add %651, %659 : tensor<16809984xui32> loc(#loc225)
%661 = mhlo.constant dense<24> : tensor<ui32> loc(#loc224)
%662 = "mhlo.broadcast_in_dim"(%661) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%663 = mhlo.shift_left %659, %662 : tensor<16809984xui32> loc(#loc226)
%664 = mhlo.constant dense<8> : tensor<ui32> loc(#loc224)
%665 = "mhlo.broadcast_in_dim"(%664) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%666 = mhlo.shift_right_logical %659, %665 : tensor<16809984xui32> loc(#loc227)
%667 = mhlo.or %663, %666 : tensor<16809984xui32> loc(#loc228)
%668 = mhlo.xor %660, %667 : tensor<16809984xui32> loc(#loc223)
%669 = "mhlo.broadcast_in_dim"(%494) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%670 = mhlo.add %660, %669 : tensor<16809984xui32> loc(#loc225)
%671 = "mhlo.broadcast_in_dim"(%499) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%672 = mhlo.add %668, %671 : tensor<16809984xui32> loc(#loc225)
%673 = mhlo.constant dense<4> : tensor<ui32> loc(#loc224)
%674 = "mhlo.broadcast_in_dim"(%673) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%675 = mhlo.add %672, %674 : tensor<16809984xui32> loc(#loc225)
%676 = mhlo.add %670, %675 : tensor<16809984xui32> loc(#loc225)
%677 = mhlo.constant dense<13> : tensor<ui32> loc(#loc224)
%678 = "mhlo.broadcast_in_dim"(%677) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%679 = mhlo.shift_left %675, %678 : tensor<16809984xui32> loc(#loc226)
%680 = mhlo.constant dense<19> : tensor<ui32> loc(#loc224)
%681 = "mhlo.broadcast_in_dim"(%680) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%682 = mhlo.shift_right_logical %675, %681 : tensor<16809984xui32> loc(#loc227)
%683 = mhlo.or %679, %682 : tensor<16809984xui32> loc(#loc228)
%684 = mhlo.xor %676, %683 : tensor<16809984xui32> loc(#loc223)
%685 = mhlo.add %676, %684 : tensor<16809984xui32> loc(#loc225)
%686 = mhlo.constant dense<15> : tensor<ui32> loc(#loc224)
%687 = "mhlo.broadcast_in_dim"(%686) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%688 = mhlo.shift_left %684, %687 : tensor<16809984xui32> loc(#loc226)
%689 = mhlo.constant dense<17> : tensor<ui32> loc(#loc224)
%690 = "mhlo.broadcast_in_dim"(%689) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%691 = mhlo.shift_right_logical %684, %690 : tensor<16809984xui32> loc(#loc227)
%692 = mhlo.or %688, %691 : tensor<16809984xui32> loc(#loc228)
%693 = mhlo.xor %685, %692 : tensor<16809984xui32> loc(#loc223)
%694 = mhlo.add %685, %693 : tensor<16809984xui32> loc(#loc225)
%695 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%696 = "mhlo.broadcast_in_dim"(%695) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%697 = mhlo.shift_left %693, %696 : tensor<16809984xui32> loc(#loc226)
%698 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%699 = "mhlo.broadcast_in_dim"(%698) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%700 = mhlo.shift_right_logical %693, %699 : tensor<16809984xui32> loc(#loc227)
%701 = mhlo.or %697, %700 : tensor<16809984xui32> loc(#loc228)
%702 = mhlo.xor %694, %701 : tensor<16809984xui32> loc(#loc223)
%703 = mhlo.add %694, %702 : tensor<16809984xui32> loc(#loc225)
%704 = mhlo.constant dense<6> : tensor<ui32> loc(#loc224)
%705 = "mhlo.broadcast_in_dim"(%704) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc226)
%706 = mhlo.shift_left %702, %705 : tensor<16809984xui32> loc(#loc226)
%707 = mhlo.constant dense<26> : tensor<ui32> loc(#loc224)
%708 = "mhlo.broadcast_in_dim"(%707) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc227)
%709 = mhlo.shift_right_logical %702, %708 : tensor<16809984xui32> loc(#loc227)
%710 = mhlo.or %706, %709 : tensor<16809984xui32> loc(#loc228)
%711 = mhlo.xor %703, %710 : tensor<16809984xui32> loc(#loc223)
%712 = "mhlo.broadcast_in_dim"(%499) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%713 = mhlo.add %703, %712 : tensor<16809984xui32> loc(#loc225)
%714 = "mhlo.broadcast_in_dim"(%492) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%715 = mhlo.add %711, %714 : tensor<16809984xui32> loc(#loc225)
%716 = mhlo.constant dense<5> : tensor<ui32> loc(#loc224)
%717 = "mhlo.broadcast_in_dim"(%716) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16809984xui32> loc(#loc225)
%718 = mhlo.add %715, %717 : tensor<16809984xui32> loc(#loc225)
%719 = "mhlo.concatenate"(%713, %718) {dimension = 0 : i64} : (tensor<16809984xui32>, tensor<16809984xui32>) -> tensor<33619968xui32> loc(#loc229)
%720 = "mhlo.reshape"(%719) : (tensor<33619968xui32>) -> tensor<16416x2048xui32> loc(#loc230)
%721 = mhlo.constant dense<9> : tensor<ui32> loc(#loc0)
%722 = "mhlo.broadcast_in_dim"(%721) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16416x2048xui32> loc(#loc227)
%723 = mhlo.shift_right_logical %720, %722 : tensor<16416x2048xui32> loc(#loc227)
%724 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc0)
%725 = "mhlo.broadcast_in_dim"(%724) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<16416x2048xui32> loc(#loc228)
%726 = mhlo.or %723, %725 : tensor<16416x2048xui32> loc(#loc228)
%727 = "mhlo.bitcast_convert"(%726) : (tensor<16416x2048xui32>) -> tensor<16416x2048xf32> loc(#loc231)
%728 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%729 = "mhlo.broadcast_in_dim"(%728) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<16416x2048xf32> loc(#loc232)
%730 = mhlo.subtract %727, %729 : tensor<16416x2048xf32> loc(#loc232)
%731 = mhlo.subtract %489, %487 : tensor<1x1xf32> loc(#loc232)
%732 = "mhlo.broadcast_in_dim"(%731) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<16416x2048xf32> loc(#loc233)
%733 = mhlo.multiply %730, %732 : tensor<16416x2048xf32> loc(#loc233)
%734 = "mhlo.broadcast_in_dim"(%487) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<16416x2048xf32> loc(#loc225)
%735 = mhlo.add %733, %734 : tensor<16416x2048xf32> loc(#loc225)
%736 = "mhlo.broadcast_in_dim"(%487) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<16416x2048xf32> loc(#loc234)
%737 = mhlo.maximum %736, %735 : tensor<16416x2048xf32> loc(#loc234)
%738 = call @erf_inv(%737) : (tensor<16416x2048xf32>) -> tensor<16416x2048xf32> loc(#loc235)
%739 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc0)
%740 = "mhlo.broadcast_in_dim"(%739) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<16416x2048xf32> loc(#loc233)
%741 = mhlo.multiply %738, %740 : tensor<16416x2048xf32> loc(#loc233)
%742 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc0)
%743 = "mhlo.broadcast_in_dim"(%742) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<16416x2048xf32> loc(#loc233)
%744 = mhlo.multiply %741, %743 : tensor<16416x2048xf32> loc(#loc233)
%745 = call @_take_13(%744, %231) : (tensor<16416x2048xf32>, tensor<1x256xi32>) -> tensor<1x256x2048xf32> loc(#loc236)
%746 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%747 = "mhlo.broadcast_in_dim"(%746) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x2048xf32> loc(#loc237)
%748 = mhlo.multiply %745, %747 : tensor<1x256x2048xf32> loc(#loc237)
%749 = mhlo.constant dense<0> : tensor<i32> loc(#loc0)
%750 = "mhlo.broadcast_in_dim"(%749) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x256xi32> loc(#loc238)
%751 = mhlo.add %236, %750 : tensor<1x256xi32> loc(#loc238)
%752 = mhlo.constant dense<331529253> : tensor<ui32> loc(#loc0)
%753 = mhlo.constant dense<32> : tensor<ui32> loc(#loc0)
%754 = mhlo.shift_right_logical %752, %753 : tensor<ui32> loc(#loc239)
%755 = "mhlo.reshape"(%754) : (tensor<ui32>) -> tensor<1xui32> loc(#loc240)
%756 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc0)
%757 = mhlo.and %752, %756 : tensor<ui32> loc(#loc241)
%758 = "mhlo.reshape"(%757) : (tensor<ui32>) -> tensor<1xui32> loc(#loc240)
%759 = "mhlo.concatenate"(%755, %758) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc242)
%760 = "mhlo.slice"(%248) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc243)
%761 = "mhlo.reshape"(%760) : (tensor<1xui32>) -> tensor<ui32> loc(#loc244)
%762 = "mhlo.slice"(%248) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc245)
%763 = "mhlo.reshape"(%762) : (tensor<1xui32>) -> tensor<ui32> loc(#loc244)
%764 = "mhlo.slice"(%759) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc246)
%765 = "mhlo.slice"(%759) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc247)
%766 = mhlo.xor %761, %763 : tensor<ui32> loc(#loc248)
%767 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc249)
%768 = mhlo.xor %766, %767 : tensor<ui32> loc(#loc248)
%769 = "mhlo.broadcast_in_dim"(%761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%770 = mhlo.add %764, %769 : tensor<1xui32> loc(#loc250)
%771 = "mhlo.broadcast_in_dim"(%763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%772 = mhlo.add %765, %771 : tensor<1xui32> loc(#loc250)
%773 = mhlo.add %770, %772 : tensor<1xui32> loc(#loc250)
%774 = mhlo.constant dense<13> : tensor<ui32> loc(#loc249)
%775 = "mhlo.broadcast_in_dim"(%774) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%776 = mhlo.shift_left %772, %775 : tensor<1xui32> loc(#loc251)
%777 = mhlo.constant dense<19> : tensor<ui32> loc(#loc249)
%778 = "mhlo.broadcast_in_dim"(%777) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%779 = mhlo.shift_right_logical %772, %778 : tensor<1xui32> loc(#loc239)
%780 = mhlo.or %776, %779 : tensor<1xui32> loc(#loc252)
%781 = mhlo.xor %773, %780 : tensor<1xui32> loc(#loc248)
%782 = mhlo.add %773, %781 : tensor<1xui32> loc(#loc250)
%783 = mhlo.constant dense<15> : tensor<ui32> loc(#loc249)
%784 = "mhlo.broadcast_in_dim"(%783) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%785 = mhlo.shift_left %781, %784 : tensor<1xui32> loc(#loc251)
%786 = mhlo.constant dense<17> : tensor<ui32> loc(#loc249)
%787 = "mhlo.broadcast_in_dim"(%786) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%788 = mhlo.shift_right_logical %781, %787 : tensor<1xui32> loc(#loc239)
%789 = mhlo.or %785, %788 : tensor<1xui32> loc(#loc252)
%790 = mhlo.xor %782, %789 : tensor<1xui32> loc(#loc248)
%791 = mhlo.add %782, %790 : tensor<1xui32> loc(#loc250)
%792 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%793 = "mhlo.broadcast_in_dim"(%792) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%794 = mhlo.shift_left %790, %793 : tensor<1xui32> loc(#loc251)
%795 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%796 = "mhlo.broadcast_in_dim"(%795) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%797 = mhlo.shift_right_logical %790, %796 : tensor<1xui32> loc(#loc239)
%798 = mhlo.or %794, %797 : tensor<1xui32> loc(#loc252)
%799 = mhlo.xor %791, %798 : tensor<1xui32> loc(#loc248)
%800 = mhlo.add %791, %799 : tensor<1xui32> loc(#loc250)
%801 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%802 = "mhlo.broadcast_in_dim"(%801) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%803 = mhlo.shift_left %799, %802 : tensor<1xui32> loc(#loc251)
%804 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%805 = "mhlo.broadcast_in_dim"(%804) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%806 = mhlo.shift_right_logical %799, %805 : tensor<1xui32> loc(#loc239)
%807 = mhlo.or %803, %806 : tensor<1xui32> loc(#loc252)
%808 = mhlo.xor %800, %807 : tensor<1xui32> loc(#loc248)
%809 = "mhlo.broadcast_in_dim"(%763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%810 = mhlo.add %800, %809 : tensor<1xui32> loc(#loc250)
%811 = "mhlo.broadcast_in_dim"(%768) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%812 = mhlo.add %808, %811 : tensor<1xui32> loc(#loc250)
%813 = mhlo.constant dense<1> : tensor<ui32> loc(#loc249)
%814 = "mhlo.broadcast_in_dim"(%813) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%815 = mhlo.add %812, %814 : tensor<1xui32> loc(#loc250)
%816 = mhlo.add %810, %815 : tensor<1xui32> loc(#loc250)
%817 = mhlo.constant dense<17> : tensor<ui32> loc(#loc249)
%818 = "mhlo.broadcast_in_dim"(%817) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%819 = mhlo.shift_left %815, %818 : tensor<1xui32> loc(#loc251)
%820 = mhlo.constant dense<15> : tensor<ui32> loc(#loc249)
%821 = "mhlo.broadcast_in_dim"(%820) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%822 = mhlo.shift_right_logical %815, %821 : tensor<1xui32> loc(#loc239)
%823 = mhlo.or %819, %822 : tensor<1xui32> loc(#loc252)
%824 = mhlo.xor %816, %823 : tensor<1xui32> loc(#loc248)
%825 = mhlo.add %816, %824 : tensor<1xui32> loc(#loc250)
%826 = mhlo.constant dense<29> : tensor<ui32> loc(#loc249)
%827 = "mhlo.broadcast_in_dim"(%826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%828 = mhlo.shift_left %824, %827 : tensor<1xui32> loc(#loc251)
%829 = mhlo.constant dense<3> : tensor<ui32> loc(#loc249)
%830 = "mhlo.broadcast_in_dim"(%829) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%831 = mhlo.shift_right_logical %824, %830 : tensor<1xui32> loc(#loc239)
%832 = mhlo.or %828, %831 : tensor<1xui32> loc(#loc252)
%833 = mhlo.xor %825, %832 : tensor<1xui32> loc(#loc248)
%834 = mhlo.add %825, %833 : tensor<1xui32> loc(#loc250)
%835 = mhlo.constant dense<16> : tensor<ui32> loc(#loc249)
%836 = "mhlo.broadcast_in_dim"(%835) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%837 = mhlo.shift_left %833, %836 : tensor<1xui32> loc(#loc251)
%838 = mhlo.constant dense<16> : tensor<ui32> loc(#loc249)
%839 = "mhlo.broadcast_in_dim"(%838) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%840 = mhlo.shift_right_logical %833, %839 : tensor<1xui32> loc(#loc239)
%841 = mhlo.or %837, %840 : tensor<1xui32> loc(#loc252)
%842 = mhlo.xor %834, %841 : tensor<1xui32> loc(#loc248)
%843 = mhlo.add %834, %842 : tensor<1xui32> loc(#loc250)
%844 = mhlo.constant dense<24> : tensor<ui32> loc(#loc249)
%845 = "mhlo.broadcast_in_dim"(%844) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%846 = mhlo.shift_left %842, %845 : tensor<1xui32> loc(#loc251)
%847 = mhlo.constant dense<8> : tensor<ui32> loc(#loc249)
%848 = "mhlo.broadcast_in_dim"(%847) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%849 = mhlo.shift_right_logical %842, %848 : tensor<1xui32> loc(#loc239)
%850 = mhlo.or %846, %849 : tensor<1xui32> loc(#loc252)
%851 = mhlo.xor %843, %850 : tensor<1xui32> loc(#loc248)
%852 = "mhlo.broadcast_in_dim"(%768) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%853 = mhlo.add %843, %852 : tensor<1xui32> loc(#loc250)
%854 = "mhlo.broadcast_in_dim"(%761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%855 = mhlo.add %851, %854 : tensor<1xui32> loc(#loc250)
%856 = mhlo.constant dense<2> : tensor<ui32> loc(#loc249)
%857 = "mhlo.broadcast_in_dim"(%856) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%858 = mhlo.add %855, %857 : tensor<1xui32> loc(#loc250)
%859 = mhlo.add %853, %858 : tensor<1xui32> loc(#loc250)
%860 = mhlo.constant dense<13> : tensor<ui32> loc(#loc249)
%861 = "mhlo.broadcast_in_dim"(%860) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%862 = mhlo.shift_left %858, %861 : tensor<1xui32> loc(#loc251)
%863 = mhlo.constant dense<19> : tensor<ui32> loc(#loc249)
%864 = "mhlo.broadcast_in_dim"(%863) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%865 = mhlo.shift_right_logical %858, %864 : tensor<1xui32> loc(#loc239)
%866 = mhlo.or %862, %865 : tensor<1xui32> loc(#loc252)
%867 = mhlo.xor %859, %866 : tensor<1xui32> loc(#loc248)
%868 = mhlo.add %859, %867 : tensor<1xui32> loc(#loc250)
%869 = mhlo.constant dense<15> : tensor<ui32> loc(#loc249)
%870 = "mhlo.broadcast_in_dim"(%869) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%871 = mhlo.shift_left %867, %870 : tensor<1xui32> loc(#loc251)
%872 = mhlo.constant dense<17> : tensor<ui32> loc(#loc249)
%873 = "mhlo.broadcast_in_dim"(%872) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%874 = mhlo.shift_right_logical %867, %873 : tensor<1xui32> loc(#loc239)
%875 = mhlo.or %871, %874 : tensor<1xui32> loc(#loc252)
%876 = mhlo.xor %868, %875 : tensor<1xui32> loc(#loc248)
%877 = mhlo.add %868, %876 : tensor<1xui32> loc(#loc250)
%878 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%879 = "mhlo.broadcast_in_dim"(%878) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%880 = mhlo.shift_left %876, %879 : tensor<1xui32> loc(#loc251)
%881 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%882 = "mhlo.broadcast_in_dim"(%881) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%883 = mhlo.shift_right_logical %876, %882 : tensor<1xui32> loc(#loc239)
%884 = mhlo.or %880, %883 : tensor<1xui32> loc(#loc252)
%885 = mhlo.xor %877, %884 : tensor<1xui32> loc(#loc248)
%886 = mhlo.add %877, %885 : tensor<1xui32> loc(#loc250)
%887 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%888 = "mhlo.broadcast_in_dim"(%887) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%889 = mhlo.shift_left %885, %888 : tensor<1xui32> loc(#loc251)
%890 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%891 = "mhlo.broadcast_in_dim"(%890) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%892 = mhlo.shift_right_logical %885, %891 : tensor<1xui32> loc(#loc239)
%893 = mhlo.or %889, %892 : tensor<1xui32> loc(#loc252)
%894 = mhlo.xor %886, %893 : tensor<1xui32> loc(#loc248)
%895 = "mhlo.broadcast_in_dim"(%761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%896 = mhlo.add %886, %895 : tensor<1xui32> loc(#loc250)
%897 = "mhlo.broadcast_in_dim"(%763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%898 = mhlo.add %894, %897 : tensor<1xui32> loc(#loc250)
%899 = mhlo.constant dense<3> : tensor<ui32> loc(#loc249)
%900 = "mhlo.broadcast_in_dim"(%899) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%901 = mhlo.add %898, %900 : tensor<1xui32> loc(#loc250)
%902 = mhlo.add %896, %901 : tensor<1xui32> loc(#loc250)
%903 = mhlo.constant dense<17> : tensor<ui32> loc(#loc249)
%904 = "mhlo.broadcast_in_dim"(%903) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%905 = mhlo.shift_left %901, %904 : tensor<1xui32> loc(#loc251)
%906 = mhlo.constant dense<15> : tensor<ui32> loc(#loc249)
%907 = "mhlo.broadcast_in_dim"(%906) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%908 = mhlo.shift_right_logical %901, %907 : tensor<1xui32> loc(#loc239)
%909 = mhlo.or %905, %908 : tensor<1xui32> loc(#loc252)
%910 = mhlo.xor %902, %909 : tensor<1xui32> loc(#loc248)
%911 = mhlo.add %902, %910 : tensor<1xui32> loc(#loc250)
%912 = mhlo.constant dense<29> : tensor<ui32> loc(#loc249)
%913 = "mhlo.broadcast_in_dim"(%912) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%914 = mhlo.shift_left %910, %913 : tensor<1xui32> loc(#loc251)
%915 = mhlo.constant dense<3> : tensor<ui32> loc(#loc249)
%916 = "mhlo.broadcast_in_dim"(%915) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%917 = mhlo.shift_right_logical %910, %916 : tensor<1xui32> loc(#loc239)
%918 = mhlo.or %914, %917 : tensor<1xui32> loc(#loc252)
%919 = mhlo.xor %911, %918 : tensor<1xui32> loc(#loc248)
%920 = mhlo.add %911, %919 : tensor<1xui32> loc(#loc250)
%921 = mhlo.constant dense<16> : tensor<ui32> loc(#loc249)
%922 = "mhlo.broadcast_in_dim"(%921) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%923 = mhlo.shift_left %919, %922 : tensor<1xui32> loc(#loc251)
%924 = mhlo.constant dense<16> : tensor<ui32> loc(#loc249)
%925 = "mhlo.broadcast_in_dim"(%924) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%926 = mhlo.shift_right_logical %919, %925 : tensor<1xui32> loc(#loc239)
%927 = mhlo.or %923, %926 : tensor<1xui32> loc(#loc252)
%928 = mhlo.xor %920, %927 : tensor<1xui32> loc(#loc248)
%929 = mhlo.add %920, %928 : tensor<1xui32> loc(#loc250)
%930 = mhlo.constant dense<24> : tensor<ui32> loc(#loc249)
%931 = "mhlo.broadcast_in_dim"(%930) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%932 = mhlo.shift_left %928, %931 : tensor<1xui32> loc(#loc251)
%933 = mhlo.constant dense<8> : tensor<ui32> loc(#loc249)
%934 = "mhlo.broadcast_in_dim"(%933) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%935 = mhlo.shift_right_logical %928, %934 : tensor<1xui32> loc(#loc239)
%936 = mhlo.or %932, %935 : tensor<1xui32> loc(#loc252)
%937 = mhlo.xor %929, %936 : tensor<1xui32> loc(#loc248)
%938 = "mhlo.broadcast_in_dim"(%763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%939 = mhlo.add %929, %938 : tensor<1xui32> loc(#loc250)
%940 = "mhlo.broadcast_in_dim"(%768) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%941 = mhlo.add %937, %940 : tensor<1xui32> loc(#loc250)
%942 = mhlo.constant dense<4> : tensor<ui32> loc(#loc249)
%943 = "mhlo.broadcast_in_dim"(%942) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%944 = mhlo.add %941, %943 : tensor<1xui32> loc(#loc250)
%945 = mhlo.add %939, %944 : tensor<1xui32> loc(#loc250)
%946 = mhlo.constant dense<13> : tensor<ui32> loc(#loc249)
%947 = "mhlo.broadcast_in_dim"(%946) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%948 = mhlo.shift_left %944, %947 : tensor<1xui32> loc(#loc251)
%949 = mhlo.constant dense<19> : tensor<ui32> loc(#loc249)
%950 = "mhlo.broadcast_in_dim"(%949) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%951 = mhlo.shift_right_logical %944, %950 : tensor<1xui32> loc(#loc239)
%952 = mhlo.or %948, %951 : tensor<1xui32> loc(#loc252)
%953 = mhlo.xor %945, %952 : tensor<1xui32> loc(#loc248)
%954 = mhlo.add %945, %953 : tensor<1xui32> loc(#loc250)
%955 = mhlo.constant dense<15> : tensor<ui32> loc(#loc249)
%956 = "mhlo.broadcast_in_dim"(%955) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%957 = mhlo.shift_left %953, %956 : tensor<1xui32> loc(#loc251)
%958 = mhlo.constant dense<17> : tensor<ui32> loc(#loc249)
%959 = "mhlo.broadcast_in_dim"(%958) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%960 = mhlo.shift_right_logical %953, %959 : tensor<1xui32> loc(#loc239)
%961 = mhlo.or %957, %960 : tensor<1xui32> loc(#loc252)
%962 = mhlo.xor %954, %961 : tensor<1xui32> loc(#loc248)
%963 = mhlo.add %954, %962 : tensor<1xui32> loc(#loc250)
%964 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%965 = "mhlo.broadcast_in_dim"(%964) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%966 = mhlo.shift_left %962, %965 : tensor<1xui32> loc(#loc251)
%967 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%968 = "mhlo.broadcast_in_dim"(%967) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%969 = mhlo.shift_right_logical %962, %968 : tensor<1xui32> loc(#loc239)
%970 = mhlo.or %966, %969 : tensor<1xui32> loc(#loc252)
%971 = mhlo.xor %963, %970 : tensor<1xui32> loc(#loc248)
%972 = mhlo.add %963, %971 : tensor<1xui32> loc(#loc250)
%973 = mhlo.constant dense<6> : tensor<ui32> loc(#loc249)
%974 = "mhlo.broadcast_in_dim"(%973) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc251)
%975 = mhlo.shift_left %971, %974 : tensor<1xui32> loc(#loc251)
%976 = mhlo.constant dense<26> : tensor<ui32> loc(#loc249)
%977 = "mhlo.broadcast_in_dim"(%976) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc239)
%978 = mhlo.shift_right_logical %971, %977 : tensor<1xui32> loc(#loc239)
%979 = mhlo.or %975, %978 : tensor<1xui32> loc(#loc252)
%980 = mhlo.xor %972, %979 : tensor<1xui32> loc(#loc248)
%981 = "mhlo.broadcast_in_dim"(%768) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%982 = mhlo.add %972, %981 : tensor<1xui32> loc(#loc250)
%983 = "mhlo.broadcast_in_dim"(%761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%984 = mhlo.add %980, %983 : tensor<1xui32> loc(#loc250)
%985 = mhlo.constant dense<5> : tensor<ui32> loc(#loc249)
%986 = "mhlo.broadcast_in_dim"(%985) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc250)
%987 = mhlo.add %984, %986 : tensor<1xui32> loc(#loc250)
%988 = "mhlo.concatenate"(%982, %987) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc242)
%989 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc0)
%990 = "mhlo.broadcast_in_dim"(%989) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc253)
%991 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%992 = "mhlo.broadcast_in_dim"(%991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc253)
%993 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<524288xui32> loc(#loc254)
%994 = "mhlo.slice"(%988) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc255)
%995 = "mhlo.reshape"(%994) : (tensor<1xui32>) -> tensor<ui32> loc(#loc256)
%996 = "mhlo.slice"(%988) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc257)
%997 = "mhlo.reshape"(%996) : (tensor<1xui32>) -> tensor<ui32> loc(#loc256)
%998 = "mhlo.slice"(%993) {limit_indices = dense<262144> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<524288xui32>) -> tensor<262144xui32> loc(#loc258)
%999 = "mhlo.slice"(%993) {limit_indices = dense<524288> : tensor<1xi64>, start_indices = dense<262144> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<524288xui32>) -> tensor<262144xui32> loc(#loc259)
%1000 = mhlo.xor %995, %997 : tensor<ui32> loc(#loc260)
%1001 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc261)
%1002 = mhlo.xor %1000, %1001 : tensor<ui32> loc(#loc260)
%1003 = "mhlo.broadcast_in_dim"(%995) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1004 = mhlo.add %998, %1003 : tensor<262144xui32> loc(#loc262)
%1005 = "mhlo.broadcast_in_dim"(%997) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1006 = mhlo.add %999, %1005 : tensor<262144xui32> loc(#loc262)
%1007 = mhlo.add %1004, %1006 : tensor<262144xui32> loc(#loc262)
%1008 = mhlo.constant dense<13> : tensor<ui32> loc(#loc261)
%1009 = "mhlo.broadcast_in_dim"(%1008) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1010 = mhlo.shift_left %1006, %1009 : tensor<262144xui32> loc(#loc263)
%1011 = mhlo.constant dense<19> : tensor<ui32> loc(#loc261)
%1012 = "mhlo.broadcast_in_dim"(%1011) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1013 = mhlo.shift_right_logical %1006, %1012 : tensor<262144xui32> loc(#loc264)
%1014 = mhlo.or %1010, %1013 : tensor<262144xui32> loc(#loc265)
%1015 = mhlo.xor %1007, %1014 : tensor<262144xui32> loc(#loc260)
%1016 = mhlo.add %1007, %1015 : tensor<262144xui32> loc(#loc262)
%1017 = mhlo.constant dense<15> : tensor<ui32> loc(#loc261)
%1018 = "mhlo.broadcast_in_dim"(%1017) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1019 = mhlo.shift_left %1015, %1018 : tensor<262144xui32> loc(#loc263)
%1020 = mhlo.constant dense<17> : tensor<ui32> loc(#loc261)
%1021 = "mhlo.broadcast_in_dim"(%1020) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1022 = mhlo.shift_right_logical %1015, %1021 : tensor<262144xui32> loc(#loc264)
%1023 = mhlo.or %1019, %1022 : tensor<262144xui32> loc(#loc265)
%1024 = mhlo.xor %1016, %1023 : tensor<262144xui32> loc(#loc260)
%1025 = mhlo.add %1016, %1024 : tensor<262144xui32> loc(#loc262)
%1026 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1027 = "mhlo.broadcast_in_dim"(%1026) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1028 = mhlo.shift_left %1024, %1027 : tensor<262144xui32> loc(#loc263)
%1029 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1030 = "mhlo.broadcast_in_dim"(%1029) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1031 = mhlo.shift_right_logical %1024, %1030 : tensor<262144xui32> loc(#loc264)
%1032 = mhlo.or %1028, %1031 : tensor<262144xui32> loc(#loc265)
%1033 = mhlo.xor %1025, %1032 : tensor<262144xui32> loc(#loc260)
%1034 = mhlo.add %1025, %1033 : tensor<262144xui32> loc(#loc262)
%1035 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1036 = "mhlo.broadcast_in_dim"(%1035) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1037 = mhlo.shift_left %1033, %1036 : tensor<262144xui32> loc(#loc263)
%1038 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1039 = "mhlo.broadcast_in_dim"(%1038) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1040 = mhlo.shift_right_logical %1033, %1039 : tensor<262144xui32> loc(#loc264)
%1041 = mhlo.or %1037, %1040 : tensor<262144xui32> loc(#loc265)
%1042 = mhlo.xor %1034, %1041 : tensor<262144xui32> loc(#loc260)
%1043 = "mhlo.broadcast_in_dim"(%997) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1044 = mhlo.add %1034, %1043 : tensor<262144xui32> loc(#loc262)
%1045 = "mhlo.broadcast_in_dim"(%1002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1046 = mhlo.add %1042, %1045 : tensor<262144xui32> loc(#loc262)
%1047 = mhlo.constant dense<1> : tensor<ui32> loc(#loc261)
%1048 = "mhlo.broadcast_in_dim"(%1047) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1049 = mhlo.add %1046, %1048 : tensor<262144xui32> loc(#loc262)
%1050 = mhlo.add %1044, %1049 : tensor<262144xui32> loc(#loc262)
%1051 = mhlo.constant dense<17> : tensor<ui32> loc(#loc261)
%1052 = "mhlo.broadcast_in_dim"(%1051) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1053 = mhlo.shift_left %1049, %1052 : tensor<262144xui32> loc(#loc263)
%1054 = mhlo.constant dense<15> : tensor<ui32> loc(#loc261)
%1055 = "mhlo.broadcast_in_dim"(%1054) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1056 = mhlo.shift_right_logical %1049, %1055 : tensor<262144xui32> loc(#loc264)
%1057 = mhlo.or %1053, %1056 : tensor<262144xui32> loc(#loc265)
%1058 = mhlo.xor %1050, %1057 : tensor<262144xui32> loc(#loc260)
%1059 = mhlo.add %1050, %1058 : tensor<262144xui32> loc(#loc262)
%1060 = mhlo.constant dense<29> : tensor<ui32> loc(#loc261)
%1061 = "mhlo.broadcast_in_dim"(%1060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1062 = mhlo.shift_left %1058, %1061 : tensor<262144xui32> loc(#loc263)
%1063 = mhlo.constant dense<3> : tensor<ui32> loc(#loc261)
%1064 = "mhlo.broadcast_in_dim"(%1063) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1065 = mhlo.shift_right_logical %1058, %1064 : tensor<262144xui32> loc(#loc264)
%1066 = mhlo.or %1062, %1065 : tensor<262144xui32> loc(#loc265)
%1067 = mhlo.xor %1059, %1066 : tensor<262144xui32> loc(#loc260)
%1068 = mhlo.add %1059, %1067 : tensor<262144xui32> loc(#loc262)
%1069 = mhlo.constant dense<16> : tensor<ui32> loc(#loc261)
%1070 = "mhlo.broadcast_in_dim"(%1069) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1071 = mhlo.shift_left %1067, %1070 : tensor<262144xui32> loc(#loc263)
%1072 = mhlo.constant dense<16> : tensor<ui32> loc(#loc261)
%1073 = "mhlo.broadcast_in_dim"(%1072) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1074 = mhlo.shift_right_logical %1067, %1073 : tensor<262144xui32> loc(#loc264)
%1075 = mhlo.or %1071, %1074 : tensor<262144xui32> loc(#loc265)
%1076 = mhlo.xor %1068, %1075 : tensor<262144xui32> loc(#loc260)
%1077 = mhlo.add %1068, %1076 : tensor<262144xui32> loc(#loc262)
%1078 = mhlo.constant dense<24> : tensor<ui32> loc(#loc261)
%1079 = "mhlo.broadcast_in_dim"(%1078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1080 = mhlo.shift_left %1076, %1079 : tensor<262144xui32> loc(#loc263)
%1081 = mhlo.constant dense<8> : tensor<ui32> loc(#loc261)
%1082 = "mhlo.broadcast_in_dim"(%1081) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1083 = mhlo.shift_right_logical %1076, %1082 : tensor<262144xui32> loc(#loc264)
%1084 = mhlo.or %1080, %1083 : tensor<262144xui32> loc(#loc265)
%1085 = mhlo.xor %1077, %1084 : tensor<262144xui32> loc(#loc260)
%1086 = "mhlo.broadcast_in_dim"(%1002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1087 = mhlo.add %1077, %1086 : tensor<262144xui32> loc(#loc262)
%1088 = "mhlo.broadcast_in_dim"(%995) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1089 = mhlo.add %1085, %1088 : tensor<262144xui32> loc(#loc262)
%1090 = mhlo.constant dense<2> : tensor<ui32> loc(#loc261)
%1091 = "mhlo.broadcast_in_dim"(%1090) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1092 = mhlo.add %1089, %1091 : tensor<262144xui32> loc(#loc262)
%1093 = mhlo.add %1087, %1092 : tensor<262144xui32> loc(#loc262)
%1094 = mhlo.constant dense<13> : tensor<ui32> loc(#loc261)
%1095 = "mhlo.broadcast_in_dim"(%1094) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1096 = mhlo.shift_left %1092, %1095 : tensor<262144xui32> loc(#loc263)
%1097 = mhlo.constant dense<19> : tensor<ui32> loc(#loc261)
%1098 = "mhlo.broadcast_in_dim"(%1097) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1099 = mhlo.shift_right_logical %1092, %1098 : tensor<262144xui32> loc(#loc264)
%1100 = mhlo.or %1096, %1099 : tensor<262144xui32> loc(#loc265)
%1101 = mhlo.xor %1093, %1100 : tensor<262144xui32> loc(#loc260)
%1102 = mhlo.add %1093, %1101 : tensor<262144xui32> loc(#loc262)
%1103 = mhlo.constant dense<15> : tensor<ui32> loc(#loc261)
%1104 = "mhlo.broadcast_in_dim"(%1103) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1105 = mhlo.shift_left %1101, %1104 : tensor<262144xui32> loc(#loc263)
%1106 = mhlo.constant dense<17> : tensor<ui32> loc(#loc261)
%1107 = "mhlo.broadcast_in_dim"(%1106) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1108 = mhlo.shift_right_logical %1101, %1107 : tensor<262144xui32> loc(#loc264)
%1109 = mhlo.or %1105, %1108 : tensor<262144xui32> loc(#loc265)
%1110 = mhlo.xor %1102, %1109 : tensor<262144xui32> loc(#loc260)
%1111 = mhlo.add %1102, %1110 : tensor<262144xui32> loc(#loc262)
%1112 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1113 = "mhlo.broadcast_in_dim"(%1112) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1114 = mhlo.shift_left %1110, %1113 : tensor<262144xui32> loc(#loc263)
%1115 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1116 = "mhlo.broadcast_in_dim"(%1115) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1117 = mhlo.shift_right_logical %1110, %1116 : tensor<262144xui32> loc(#loc264)
%1118 = mhlo.or %1114, %1117 : tensor<262144xui32> loc(#loc265)
%1119 = mhlo.xor %1111, %1118 : tensor<262144xui32> loc(#loc260)
%1120 = mhlo.add %1111, %1119 : tensor<262144xui32> loc(#loc262)
%1121 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1122 = "mhlo.broadcast_in_dim"(%1121) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1123 = mhlo.shift_left %1119, %1122 : tensor<262144xui32> loc(#loc263)
%1124 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1125 = "mhlo.broadcast_in_dim"(%1124) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1126 = mhlo.shift_right_logical %1119, %1125 : tensor<262144xui32> loc(#loc264)
%1127 = mhlo.or %1123, %1126 : tensor<262144xui32> loc(#loc265)
%1128 = mhlo.xor %1120, %1127 : tensor<262144xui32> loc(#loc260)
%1129 = "mhlo.broadcast_in_dim"(%995) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1130 = mhlo.add %1120, %1129 : tensor<262144xui32> loc(#loc262)
%1131 = "mhlo.broadcast_in_dim"(%997) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1132 = mhlo.add %1128, %1131 : tensor<262144xui32> loc(#loc262)
%1133 = mhlo.constant dense<3> : tensor<ui32> loc(#loc261)
%1134 = "mhlo.broadcast_in_dim"(%1133) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1135 = mhlo.add %1132, %1134 : tensor<262144xui32> loc(#loc262)
%1136 = mhlo.add %1130, %1135 : tensor<262144xui32> loc(#loc262)
%1137 = mhlo.constant dense<17> : tensor<ui32> loc(#loc261)
%1138 = "mhlo.broadcast_in_dim"(%1137) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1139 = mhlo.shift_left %1135, %1138 : tensor<262144xui32> loc(#loc263)
%1140 = mhlo.constant dense<15> : tensor<ui32> loc(#loc261)
%1141 = "mhlo.broadcast_in_dim"(%1140) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1142 = mhlo.shift_right_logical %1135, %1141 : tensor<262144xui32> loc(#loc264)
%1143 = mhlo.or %1139, %1142 : tensor<262144xui32> loc(#loc265)
%1144 = mhlo.xor %1136, %1143 : tensor<262144xui32> loc(#loc260)
%1145 = mhlo.add %1136, %1144 : tensor<262144xui32> loc(#loc262)
%1146 = mhlo.constant dense<29> : tensor<ui32> loc(#loc261)
%1147 = "mhlo.broadcast_in_dim"(%1146) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1148 = mhlo.shift_left %1144, %1147 : tensor<262144xui32> loc(#loc263)
%1149 = mhlo.constant dense<3> : tensor<ui32> loc(#loc261)
%1150 = "mhlo.broadcast_in_dim"(%1149) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1151 = mhlo.shift_right_logical %1144, %1150 : tensor<262144xui32> loc(#loc264)
%1152 = mhlo.or %1148, %1151 : tensor<262144xui32> loc(#loc265)
%1153 = mhlo.xor %1145, %1152 : tensor<262144xui32> loc(#loc260)
%1154 = mhlo.add %1145, %1153 : tensor<262144xui32> loc(#loc262)
%1155 = mhlo.constant dense<16> : tensor<ui32> loc(#loc261)
%1156 = "mhlo.broadcast_in_dim"(%1155) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1157 = mhlo.shift_left %1153, %1156 : tensor<262144xui32> loc(#loc263)
%1158 = mhlo.constant dense<16> : tensor<ui32> loc(#loc261)
%1159 = "mhlo.broadcast_in_dim"(%1158) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1160 = mhlo.shift_right_logical %1153, %1159 : tensor<262144xui32> loc(#loc264)
%1161 = mhlo.or %1157, %1160 : tensor<262144xui32> loc(#loc265)
%1162 = mhlo.xor %1154, %1161 : tensor<262144xui32> loc(#loc260)
%1163 = mhlo.add %1154, %1162 : tensor<262144xui32> loc(#loc262)
%1164 = mhlo.constant dense<24> : tensor<ui32> loc(#loc261)
%1165 = "mhlo.broadcast_in_dim"(%1164) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1166 = mhlo.shift_left %1162, %1165 : tensor<262144xui32> loc(#loc263)
%1167 = mhlo.constant dense<8> : tensor<ui32> loc(#loc261)
%1168 = "mhlo.broadcast_in_dim"(%1167) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1169 = mhlo.shift_right_logical %1162, %1168 : tensor<262144xui32> loc(#loc264)
%1170 = mhlo.or %1166, %1169 : tensor<262144xui32> loc(#loc265)
%1171 = mhlo.xor %1163, %1170 : tensor<262144xui32> loc(#loc260)
%1172 = "mhlo.broadcast_in_dim"(%997) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1173 = mhlo.add %1163, %1172 : tensor<262144xui32> loc(#loc262)
%1174 = "mhlo.broadcast_in_dim"(%1002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1175 = mhlo.add %1171, %1174 : tensor<262144xui32> loc(#loc262)
%1176 = mhlo.constant dense<4> : tensor<ui32> loc(#loc261)
%1177 = "mhlo.broadcast_in_dim"(%1176) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1178 = mhlo.add %1175, %1177 : tensor<262144xui32> loc(#loc262)
%1179 = mhlo.add %1173, %1178 : tensor<262144xui32> loc(#loc262)
%1180 = mhlo.constant dense<13> : tensor<ui32> loc(#loc261)
%1181 = "mhlo.broadcast_in_dim"(%1180) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1182 = mhlo.shift_left %1178, %1181 : tensor<262144xui32> loc(#loc263)
%1183 = mhlo.constant dense<19> : tensor<ui32> loc(#loc261)
%1184 = "mhlo.broadcast_in_dim"(%1183) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1185 = mhlo.shift_right_logical %1178, %1184 : tensor<262144xui32> loc(#loc264)
%1186 = mhlo.or %1182, %1185 : tensor<262144xui32> loc(#loc265)
%1187 = mhlo.xor %1179, %1186 : tensor<262144xui32> loc(#loc260)
%1188 = mhlo.add %1179, %1187 : tensor<262144xui32> loc(#loc262)
%1189 = mhlo.constant dense<15> : tensor<ui32> loc(#loc261)
%1190 = "mhlo.broadcast_in_dim"(%1189) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1191 = mhlo.shift_left %1187, %1190 : tensor<262144xui32> loc(#loc263)
%1192 = mhlo.constant dense<17> : tensor<ui32> loc(#loc261)
%1193 = "mhlo.broadcast_in_dim"(%1192) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1194 = mhlo.shift_right_logical %1187, %1193 : tensor<262144xui32> loc(#loc264)
%1195 = mhlo.or %1191, %1194 : tensor<262144xui32> loc(#loc265)
%1196 = mhlo.xor %1188, %1195 : tensor<262144xui32> loc(#loc260)
%1197 = mhlo.add %1188, %1196 : tensor<262144xui32> loc(#loc262)
%1198 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1199 = "mhlo.broadcast_in_dim"(%1198) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1200 = mhlo.shift_left %1196, %1199 : tensor<262144xui32> loc(#loc263)
%1201 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1202 = "mhlo.broadcast_in_dim"(%1201) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1203 = mhlo.shift_right_logical %1196, %1202 : tensor<262144xui32> loc(#loc264)
%1204 = mhlo.or %1200, %1203 : tensor<262144xui32> loc(#loc265)
%1205 = mhlo.xor %1197, %1204 : tensor<262144xui32> loc(#loc260)
%1206 = mhlo.add %1197, %1205 : tensor<262144xui32> loc(#loc262)
%1207 = mhlo.constant dense<6> : tensor<ui32> loc(#loc261)
%1208 = "mhlo.broadcast_in_dim"(%1207) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc263)
%1209 = mhlo.shift_left %1205, %1208 : tensor<262144xui32> loc(#loc263)
%1210 = mhlo.constant dense<26> : tensor<ui32> loc(#loc261)
%1211 = "mhlo.broadcast_in_dim"(%1210) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc264)
%1212 = mhlo.shift_right_logical %1205, %1211 : tensor<262144xui32> loc(#loc264)
%1213 = mhlo.or %1209, %1212 : tensor<262144xui32> loc(#loc265)
%1214 = mhlo.xor %1206, %1213 : tensor<262144xui32> loc(#loc260)
%1215 = "mhlo.broadcast_in_dim"(%1002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1216 = mhlo.add %1206, %1215 : tensor<262144xui32> loc(#loc262)
%1217 = "mhlo.broadcast_in_dim"(%995) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1218 = mhlo.add %1214, %1217 : tensor<262144xui32> loc(#loc262)
%1219 = mhlo.constant dense<5> : tensor<ui32> loc(#loc261)
%1220 = "mhlo.broadcast_in_dim"(%1219) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<262144xui32> loc(#loc262)
%1221 = mhlo.add %1218, %1220 : tensor<262144xui32> loc(#loc262)
%1222 = "mhlo.concatenate"(%1216, %1221) {dimension = 0 : i64} : (tensor<262144xui32>, tensor<262144xui32>) -> tensor<524288xui32> loc(#loc266)
%1223 = "mhlo.reshape"(%1222) : (tensor<524288xui32>) -> tensor<256x2048xui32> loc(#loc267)
%1224 = mhlo.constant dense<9> : tensor<ui32> loc(#loc0)
%1225 = "mhlo.broadcast_in_dim"(%1224) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<256x2048xui32> loc(#loc264)
%1226 = mhlo.shift_right_logical %1223, %1225 : tensor<256x2048xui32> loc(#loc264)
%1227 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc0)
%1228 = "mhlo.broadcast_in_dim"(%1227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<256x2048xui32> loc(#loc265)
%1229 = mhlo.or %1226, %1228 : tensor<256x2048xui32> loc(#loc265)
%1230 = "mhlo.bitcast_convert"(%1229) : (tensor<256x2048xui32>) -> tensor<256x2048xf32> loc(#loc268)
%1231 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%1232 = "mhlo.broadcast_in_dim"(%1231) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<256x2048xf32> loc(#loc269)
%1233 = mhlo.subtract %1230, %1232 : tensor<256x2048xf32> loc(#loc269)
%1234 = mhlo.subtract %992, %990 : tensor<1x1xf32> loc(#loc269)
%1235 = "mhlo.broadcast_in_dim"(%1234) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<256x2048xf32> loc(#loc270)
%1236 = mhlo.multiply %1233, %1235 : tensor<256x2048xf32> loc(#loc270)
%1237 = "mhlo.broadcast_in_dim"(%990) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<256x2048xf32> loc(#loc262)
%1238 = mhlo.add %1236, %1237 : tensor<256x2048xf32> loc(#loc262)
%1239 = "mhlo.broadcast_in_dim"(%990) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<256x2048xf32> loc(#loc271)
%1240 = mhlo.maximum %1239, %1238 : tensor<256x2048xf32> loc(#loc271)
%1241 = call @erf_inv_15(%1240) : (tensor<256x2048xf32>) -> tensor<256x2048xf32> loc(#loc272)
%1242 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc0)
%1243 = "mhlo.broadcast_in_dim"(%1242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<256x2048xf32> loc(#loc270)
%1244 = mhlo.multiply %1241, %1243 : tensor<256x2048xf32> loc(#loc270)
%1245 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc0)
%1246 = "mhlo.broadcast_in_dim"(%1245) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<256x2048xf32> loc(#loc270)
%1247 = mhlo.multiply %1244, %1246 : tensor<256x2048xf32> loc(#loc270)
%1248 = call @_take_16(%1247, %751) : (tensor<256x2048xf32>, tensor<1x256xi32>) -> tensor<1x256x2048xf32> loc(#loc273)
%1249 = mhlo.add %748, %1248 : tensor<1x256x2048xf32> loc(#loc274)
%1250 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc275)
%1251 = mhlo.reduce(%1249 init: %1250) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc275)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc275)
} loc(#loc275)
%1252 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%1253 = "mhlo.broadcast_in_dim"(%1252) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc276)
%1254 = mhlo.divide %1251, %1253 : tensor<1x256xf32> loc(#loc276)
%1255 = mhlo.multiply %1249, %1249 : tensor<1x256x2048xf32> loc(#loc277)
%1256 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc278)
%1257 = mhlo.reduce(%1255 init: %1256) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%5188 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc278)
"mhlo.return"(%5188) : (tensor<f32>) -> () loc(#loc278)
} loc(#loc278)
%1258 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc0)
%1259 = "mhlo.broadcast_in_dim"(%1258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc279)
%1260 = mhlo.divide %1257, %1259 : tensor<1x256xf32> loc(#loc279)
%1261 = mhlo.multiply %1254, %1254 : tensor<1x256xf32> loc(#loc277)
%1262 = mhlo.subtract %1260, %1261 : tensor<1x256xf32> loc(#loc280)
%1263 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%1264 = "mhlo.broadcast_in_dim"(%1263) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc281)
%1265 = mhlo.maximum %1264, %1262 : tensor<1x256xf32> loc(#loc281)
%1266 = "mhlo.reshape"(%1254) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc282)
%1267 = "mhlo.reshape"(%1265) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc283)
%1268 = "mhlo.broadcast_in_dim"(%1266) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc284)
%1269 = mhlo.subtract %1249, %1268 : tensor<1x256x2048xf32> loc(#loc284)
%1270 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc0)
%1271 = "mhlo.broadcast_in_dim"(%1270) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc285)
%1272 = mhlo.add %1267, %1271 : tensor<1x256x1xf32> loc(#loc285)
%1273 = mhlo.rsqrt %1272 : tensor<1x256x1xf32> loc(#loc286)
%1274 = mhlo.constant dense<584169612> : tensor<ui32> loc(#loc0)
%1275 = mhlo.constant dense<32> : tensor<ui32> loc(#loc0)
%1276 = mhlo.shift_right_logical %1274, %1275 : tensor<ui32> loc(#loc287)
%1277 = "mhlo.reshape"(%1276) : (tensor<ui32>) -> tensor<1xui32> loc(#loc288)
%1278 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc0)
%1279 = mhlo.and %1274, %1278 : tensor<ui32> loc(#loc289)
%1280 = "mhlo.reshape"(%1279) : (tensor<ui32>) -> tensor<1xui32> loc(#loc288)
%1281 = "mhlo.concatenate"(%1277, %1280) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc290)
%1282 = "mhlo.slice"(%248) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc291)
%1283 = "mhlo.reshape"(%1282) : (tensor<1xui32>) -> tensor<ui32> loc(#loc292)
%1284 = "mhlo.slice"(%248) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc293)
%1285 = "mhlo.reshape"(%1284) : (tensor<1xui32>) -> tensor<ui32> loc(#loc292)
%1286 = "mhlo.slice"(%1281) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc294)
%1287 = "mhlo.slice"(%1281) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc295)
%1288 = mhlo.xor %1283, %1285 : tensor<ui32> loc(#loc296)
%1289 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc297)
%1290 = mhlo.xor %1288, %1289 : tensor<ui32> loc(#loc296)
%1291 = "mhlo.broadcast_in_dim"(%1283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1292 = mhlo.add %1286, %1291 : tensor<1xui32> loc(#loc298)
%1293 = "mhlo.broadcast_in_dim"(%1285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1294 = mhlo.add %1287, %1293 : tensor<1xui32> loc(#loc298)
%1295 = mhlo.add %1292, %1294 : tensor<1xui32> loc(#loc298)
%1296 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1297 = "mhlo.broadcast_in_dim"(%1296) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1298 = mhlo.shift_left %1294, %1297 : tensor<1xui32> loc(#loc299)
%1299 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1300 = "mhlo.broadcast_in_dim"(%1299) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1301 = mhlo.shift_right_logical %1294, %1300 : tensor<1xui32> loc(#loc287)
%1302 = mhlo.or %1298, %1301 : tensor<1xui32> loc(#loc300)
%1303 = mhlo.xor %1295, %1302 : tensor<1xui32> loc(#loc296)
%1304 = mhlo.add %1295, %1303 : tensor<1xui32> loc(#loc298)
%1305 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1306 = "mhlo.broadcast_in_dim"(%1305) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1307 = mhlo.shift_left %1303, %1306 : tensor<1xui32> loc(#loc299)
%1308 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1309 = "mhlo.broadcast_in_dim"(%1308) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1310 = mhlo.shift_right_logical %1303, %1309 : tensor<1xui32> loc(#loc287)
%1311 = mhlo.or %1307, %1310 : tensor<1xui32> loc(#loc300)
%1312 = mhlo.xor %1304, %1311 : tensor<1xui32> loc(#loc296)
%1313 = mhlo.add %1304, %1312 : tensor<1xui32> loc(#loc298)
%1314 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1315 = "mhlo.broadcast_in_dim"(%1314) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1316 = mhlo.shift_left %1312, %1315 : tensor<1xui32> loc(#loc299)
%1317 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1318 = "mhlo.broadcast_in_dim"(%1317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1319 = mhlo.shift_right_logical %1312, %1318 : tensor<1xui32> loc(#loc287)
%1320 = mhlo.or %1316, %1319 : tensor<1xui32> loc(#loc300)
%1321 = mhlo.xor %1313, %1320 : tensor<1xui32> loc(#loc296)
%1322 = mhlo.add %1313, %1321 : tensor<1xui32> loc(#loc298)
%1323 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1324 = "mhlo.broadcast_in_dim"(%1323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1325 = mhlo.shift_left %1321, %1324 : tensor<1xui32> loc(#loc299)
%1326 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1327 = "mhlo.broadcast_in_dim"(%1326) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1328 = mhlo.shift_right_logical %1321, %1327 : tensor<1xui32> loc(#loc287)
%1329 = mhlo.or %1325, %1328 : tensor<1xui32> loc(#loc300)
%1330 = mhlo.xor %1322, %1329 : tensor<1xui32> loc(#loc296)
%1331 = "mhlo.broadcast_in_dim"(%1285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1332 = mhlo.add %1322, %1331 : tensor<1xui32> loc(#loc298)
%1333 = "mhlo.broadcast_in_dim"(%1290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1334 = mhlo.add %1330, %1333 : tensor<1xui32> loc(#loc298)
%1335 = mhlo.constant dense<1> : tensor<ui32> loc(#loc297)
%1336 = "mhlo.broadcast_in_dim"(%1335) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1337 = mhlo.add %1334, %1336 : tensor<1xui32> loc(#loc298)
%1338 = mhlo.add %1332, %1337 : tensor<1xui32> loc(#loc298)
%1339 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1340 = "mhlo.broadcast_in_dim"(%1339) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1341 = mhlo.shift_left %1337, %1340 : tensor<1xui32> loc(#loc299)
%1342 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1343 = "mhlo.broadcast_in_dim"(%1342) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1344 = mhlo.shift_right_logical %1337, %1343 : tensor<1xui32> loc(#loc287)
%1345 = mhlo.or %1341, %1344 : tensor<1xui32> loc(#loc300)
%1346 = mhlo.xor %1338, %1345 : tensor<1xui32> loc(#loc296)
%1347 = mhlo.add %1338, %1346 : tensor<1xui32> loc(#loc298)
%1348 = mhlo.constant dense<29> : tensor<ui32> loc(#loc297)
%1349 = "mhlo.broadcast_in_dim"(%1348) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1350 = mhlo.shift_left %1346, %1349 : tensor<1xui32> loc(#loc299)
%1351 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1352 = "mhlo.broadcast_in_dim"(%1351) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1353 = mhlo.shift_right_logical %1346, %1352 : tensor<1xui32> loc(#loc287)
%1354 = mhlo.or %1350, %1353 : tensor<1xui32> loc(#loc300)
%1355 = mhlo.xor %1347, %1354 : tensor<1xui32> loc(#loc296)
%1356 = mhlo.add %1347, %1355 : tensor<1xui32> loc(#loc298)
%1357 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1358 = "mhlo.broadcast_in_dim"(%1357) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1359 = mhlo.shift_left %1355, %1358 : tensor<1xui32> loc(#loc299)
%1360 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1361 = "mhlo.broadcast_in_dim"(%1360) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1362 = mhlo.shift_right_logical %1355, %1361 : tensor<1xui32> loc(#loc287)
%1363 = mhlo.or %1359, %1362 : tensor<1xui32> loc(#loc300)
%1364 = mhlo.xor %1356, %1363 : tensor<1xui32> loc(#loc296)
%1365 = mhlo.add %1356, %1364 : tensor<1xui32> loc(#loc298)
%1366 = mhlo.constant dense<24> : tensor<ui32> loc(#loc297)
%1367 = "mhlo.broadcast_in_dim"(%1366) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1368 = mhlo.shift_left %1364, %1367 : tensor<1xui32> loc(#loc299)
%1369 = mhlo.constant dense<8> : tensor<ui32> loc(#loc297)
%1370 = "mhlo.broadcast_in_dim"(%1369) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1371 = mhlo.shift_right_logical %1364, %1370 : tensor<1xui32> loc(#loc287)
%1372 = mhlo.or %1368, %1371 : tensor<1xui32> loc(#loc300)
%1373 = mhlo.xor %1365, %1372 : tensor<1xui32> loc(#loc296)
%1374 = "mhlo.broadcast_in_dim"(%1290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1375 = mhlo.add %1365, %1374 : tensor<1xui32> loc(#loc298)
%1376 = "mhlo.broadcast_in_dim"(%1283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1377 = mhlo.add %1373, %1376 : tensor<1xui32> loc(#loc298)
%1378 = mhlo.constant dense<2> : tensor<ui32> loc(#loc297)
%1379 = "mhlo.broadcast_in_dim"(%1378) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1380 = mhlo.add %1377, %1379 : tensor<1xui32> loc(#loc298)
%1381 = mhlo.add %1375, %1380 : tensor<1xui32> loc(#loc298)
%1382 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1383 = "mhlo.broadcast_in_dim"(%1382) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1384 = mhlo.shift_left %1380, %1383 : tensor<1xui32> loc(#loc299)
%1385 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1386 = "mhlo.broadcast_in_dim"(%1385) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1387 = mhlo.shift_right_logical %1380, %1386 : tensor<1xui32> loc(#loc287)
%1388 = mhlo.or %1384, %1387 : tensor<1xui32> loc(#loc300)
%1389 = mhlo.xor %1381, %1388 : tensor<1xui32> loc(#loc296)
%1390 = mhlo.add %1381, %1389 : tensor<1xui32> loc(#loc298)
%1391 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1392 = "mhlo.broadcast_in_dim"(%1391) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1393 = mhlo.shift_left %1389, %1392 : tensor<1xui32> loc(#loc299)
%1394 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1395 = "mhlo.broadcast_in_dim"(%1394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1396 = mhlo.shift_right_logical %1389, %1395 : tensor<1xui32> loc(#loc287)
%1397 = mhlo.or %1393, %1396 : tensor<1xui32> loc(#loc300)
%1398 = mhlo.xor %1390, %1397 : tensor<1xui32> loc(#loc296)
%1399 = mhlo.add %1390, %1398 : tensor<1xui32> loc(#loc298)
%1400 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1401 = "mhlo.broadcast_in_dim"(%1400) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1402 = mhlo.shift_left %1398, %1401 : tensor<1xui32> loc(#loc299)
%1403 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1404 = "mhlo.broadcast_in_dim"(%1403) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1405 = mhlo.shift_right_logical %1398, %1404 : tensor<1xui32> loc(#loc287)
%1406 = mhlo.or %1402, %1405 : tensor<1xui32> loc(#loc300)
%1407 = mhlo.xor %1399, %1406 : tensor<1xui32> loc(#loc296)
%1408 = mhlo.add %1399, %1407 : tensor<1xui32> loc(#loc298)
%1409 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1410 = "mhlo.broadcast_in_dim"(%1409) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1411 = mhlo.shift_left %1407, %1410 : tensor<1xui32> loc(#loc299)
%1412 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1413 = "mhlo.broadcast_in_dim"(%1412) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1414 = mhlo.shift_right_logical %1407, %1413 : tensor<1xui32> loc(#loc287)
%1415 = mhlo.or %1411, %1414 : tensor<1xui32> loc(#loc300)
%1416 = mhlo.xor %1408, %1415 : tensor<1xui32> loc(#loc296)
%1417 = "mhlo.broadcast_in_dim"(%1283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1418 = mhlo.add %1408, %1417 : tensor<1xui32> loc(#loc298)
%1419 = "mhlo.broadcast_in_dim"(%1285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1420 = mhlo.add %1416, %1419 : tensor<1xui32> loc(#loc298)
%1421 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1422 = "mhlo.broadcast_in_dim"(%1421) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1423 = mhlo.add %1420, %1422 : tensor<1xui32> loc(#loc298)
%1424 = mhlo.add %1418, %1423 : tensor<1xui32> loc(#loc298)
%1425 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1426 = "mhlo.broadcast_in_dim"(%1425) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1427 = mhlo.shift_left %1423, %1426 : tensor<1xui32> loc(#loc299)
%1428 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1429 = "mhlo.broadcast_in_dim"(%1428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1430 = mhlo.shift_right_logical %1423, %1429 : tensor<1xui32> loc(#loc287)
%1431 = mhlo.or %1427, %1430 : tensor<1xui32> loc(#loc300)
%1432 = mhlo.xor %1424, %1431 : tensor<1xui32> loc(#loc296)
%1433 = mhlo.add %1424, %1432 : tensor<1xui32> loc(#loc298)
%1434 = mhlo.constant dense<29> : tensor<ui32> loc(#loc297)
%1435 = "mhlo.broadcast_in_dim"(%1434) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1436 = mhlo.shift_left %1432, %1435 : tensor<1xui32> loc(#loc299)
%1437 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1438 = "mhlo.broadcast_in_dim"(%1437) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1439 = mhlo.shift_right_logical %1432, %1438 : tensor<1xui32> loc(#loc287)
%1440 = mhlo.or %1436, %1439 : tensor<1xui32> loc(#loc300)
%1441 = mhlo.xor %1433, %1440 : tensor<1xui32> loc(#loc296)
%1442 = mhlo.add %1433, %1441 : tensor<1xui32> loc(#loc298)
%1443 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1444 = "mhlo.broadcast_in_dim"(%1443) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1445 = mhlo.shift_left %1441, %1444 : tensor<1xui32> loc(#loc299)
%1446 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1447 = "mhlo.broadcast_in_dim"(%1446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1448 = mhlo.shift_right_logical %1441, %1447 : tensor<1xui32> loc(#loc287)
%1449 = mhlo.or %1445, %1448 : tensor<1xui32> loc(#loc300)
%1450 = mhlo.xor %1442, %1449 : tensor<1xui32> loc(#loc296)
%1451 = mhlo.add %1442, %1450 : tensor<1xui32> loc(#loc298)
%1452 = mhlo.constant dense<24> : tensor<ui32> loc(#loc297)
%1453 = "mhlo.broadcast_in_dim"(%1452) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1454 = mhlo.shift_left %1450, %1453 : tensor<1xui32> loc(#loc299)
%1455 = mhlo.constant dense<8> : tensor<ui32> loc(#loc297)
%1456 = "mhlo.broadcast_in_dim"(%1455) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1457 = mhlo.shift_right_logical %1450, %1456 : tensor<1xui32> loc(#loc287)
%1458 = mhlo.or %1454, %1457 : tensor<1xui32> loc(#loc300)
%1459 = mhlo.xor %1451, %1458 : tensor<1xui32> loc(#loc296)
%1460 = "mhlo.broadcast_in_dim"(%1285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1461 = mhlo.add %1451, %1460 : tensor<1xui32> loc(#loc298)
%1462 = "mhlo.broadcast_in_dim"(%1290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1463 = mhlo.add %1459, %1462 : tensor<1xui32> loc(#loc298)
%1464 = mhlo.constant dense<4> : tensor<ui32> loc(#loc297)
%1465 = "mhlo.broadcast_in_dim"(%1464) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1466 = mhlo.add %1463, %1465 : tensor<1xui32> loc(#loc298)
%1467 = mhlo.add %1461, %1466 : tensor<1xui32> loc(#loc298)
%1468 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1469 = "mhlo.broadcast_in_dim"(%1468) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1470 = mhlo.shift_left %1466, %1469 : tensor<1xui32> loc(#loc299)
%1471 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1472 = "mhlo.broadcast_in_dim"(%1471) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1473 = mhlo.shift_right_logical %1466, %1472 : tensor<1xui32> loc(#loc287)
%1474 = mhlo.or %1470, %1473 : tensor<1xui32> loc(#loc300)
%1475 = mhlo.xor %1467, %1474 : tensor<1xui32> loc(#loc296)
%1476 = mhlo.add %1467, %1475 : tensor<1xui32> loc(#loc298)
%1477 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1478 = "mhlo.broadcast_in_dim"(%1477) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1479 = mhlo.shift_left %1475, %1478 : tensor<1xui32> loc(#loc299)
%1480 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1481 = "mhlo.broadcast_in_dim"(%1480) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1482 = mhlo.shift_right_logical %1475, %1481 : tensor<1xui32> loc(#loc287)
%1483 = mhlo.or %1479, %1482 : tensor<1xui32> loc(#loc300)
%1484 = mhlo.xor %1476, %1483 : tensor<1xui32> loc(#loc296)
%1485 = mhlo.add %1476, %1484 : tensor<1xui32> loc(#loc298)
%1486 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1487 = "mhlo.broadcast_in_dim"(%1486) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1488 = mhlo.shift_left %1484, %1487 : tensor<1xui32> loc(#loc299)
%1489 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1490 = "mhlo.broadcast_in_dim"(%1489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1491 = mhlo.shift_right_logical %1484, %1490 : tensor<1xui32> loc(#loc287)
%1492 = mhlo.or %1488, %1491 : tensor<1xui32> loc(#loc300)
%1493 = mhlo.xor %1485, %1492 : tensor<1xui32> loc(#loc296)
%1494 = mhlo.add %1485, %1493 : tensor<1xui32> loc(#loc298)
%1495 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1496 = "mhlo.broadcast_in_dim"(%1495) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1497 = mhlo.shift_left %1493, %1496 : tensor<1xui32> loc(#loc299)
%1498 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1499 = "mhlo.broadcast_in_dim"(%1498) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1500 = mhlo.shift_right_logical %1493, %1499 : tensor<1xui32> loc(#loc287)
%1501 = mhlo.or %1497, %1500 : tensor<1xui32> loc(#loc300)
%1502 = mhlo.xor %1494, %1501 : tensor<1xui32> loc(#loc296)
%1503 = "mhlo.broadcast_in_dim"(%1290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1504 = mhlo.add %1494, %1503 : tensor<1xui32> loc(#loc298)
%1505 = "mhlo.broadcast_in_dim"(%1283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1506 = mhlo.add %1502, %1505 : tensor<1xui32> loc(#loc298)
%1507 = mhlo.constant dense<5> : tensor<ui32> loc(#loc297)
%1508 = "mhlo.broadcast_in_dim"(%1507) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1509 = mhlo.add %1506, %1508 : tensor<1xui32> loc(#loc298)
%1510 = "mhlo.concatenate"(%1504, %1509) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc290)
%1511 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc0)
%1512 = "mhlo.broadcast_in_dim"(%1511) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc301)
%1513 = "mhlo.reshape"(%1512) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc302)
%1514 = "mhlo.broadcast_in_dim"(%1273) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc303)
%1515 = "mhlo.broadcast_in_dim"(%1513) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc303)
%1516 = mhlo.multiply %1514, %1515 : tensor<1x256x2048xf32> loc(#loc303)
%1517 = mhlo.multiply %1269, %1516 : tensor<1x256x2048xf32> loc(#loc304)
%1518 = mhlo.constant dense<161557010> : tensor<ui32> loc(#loc0)
%1519 = mhlo.constant dense<32> : tensor<ui32> loc(#loc0)
%1520 = mhlo.shift_right_logical %1518, %1519 : tensor<ui32> loc(#loc287)
%1521 = "mhlo.reshape"(%1520) : (tensor<ui32>) -> tensor<1xui32> loc(#loc288)
%1522 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc0)
%1523 = mhlo.and %1518, %1522 : tensor<ui32> loc(#loc289)
%1524 = "mhlo.reshape"(%1523) : (tensor<ui32>) -> tensor<1xui32> loc(#loc288)
%1525 = "mhlo.concatenate"(%1521, %1524) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc290)
%1526 = "mhlo.slice"(%248) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc291)
%1527 = "mhlo.reshape"(%1526) : (tensor<1xui32>) -> tensor<ui32> loc(#loc292)
%1528 = "mhlo.slice"(%248) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc293)
%1529 = "mhlo.reshape"(%1528) : (tensor<1xui32>) -> tensor<ui32> loc(#loc292)
%1530 = "mhlo.slice"(%1525) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc294)
%1531 = "mhlo.slice"(%1525) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc295)
%1532 = mhlo.xor %1527, %1529 : tensor<ui32> loc(#loc296)
%1533 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc297)
%1534 = mhlo.xor %1532, %1533 : tensor<ui32> loc(#loc296)
%1535 = "mhlo.broadcast_in_dim"(%1527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1536 = mhlo.add %1530, %1535 : tensor<1xui32> loc(#loc298)
%1537 = "mhlo.broadcast_in_dim"(%1529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1538 = mhlo.add %1531, %1537 : tensor<1xui32> loc(#loc298)
%1539 = mhlo.add %1536, %1538 : tensor<1xui32> loc(#loc298)
%1540 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1541 = "mhlo.broadcast_in_dim"(%1540) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1542 = mhlo.shift_left %1538, %1541 : tensor<1xui32> loc(#loc299)
%1543 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1544 = "mhlo.broadcast_in_dim"(%1543) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1545 = mhlo.shift_right_logical %1538, %1544 : tensor<1xui32> loc(#loc287)
%1546 = mhlo.or %1542, %1545 : tensor<1xui32> loc(#loc300)
%1547 = mhlo.xor %1539, %1546 : tensor<1xui32> loc(#loc296)
%1548 = mhlo.add %1539, %1547 : tensor<1xui32> loc(#loc298)
%1549 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1550 = "mhlo.broadcast_in_dim"(%1549) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1551 = mhlo.shift_left %1547, %1550 : tensor<1xui32> loc(#loc299)
%1552 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1553 = "mhlo.broadcast_in_dim"(%1552) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1554 = mhlo.shift_right_logical %1547, %1553 : tensor<1xui32> loc(#loc287)
%1555 = mhlo.or %1551, %1554 : tensor<1xui32> loc(#loc300)
%1556 = mhlo.xor %1548, %1555 : tensor<1xui32> loc(#loc296)
%1557 = mhlo.add %1548, %1556 : tensor<1xui32> loc(#loc298)
%1558 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1559 = "mhlo.broadcast_in_dim"(%1558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1560 = mhlo.shift_left %1556, %1559 : tensor<1xui32> loc(#loc299)
%1561 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1562 = "mhlo.broadcast_in_dim"(%1561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1563 = mhlo.shift_right_logical %1556, %1562 : tensor<1xui32> loc(#loc287)
%1564 = mhlo.or %1560, %1563 : tensor<1xui32> loc(#loc300)
%1565 = mhlo.xor %1557, %1564 : tensor<1xui32> loc(#loc296)
%1566 = mhlo.add %1557, %1565 : tensor<1xui32> loc(#loc298)
%1567 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1568 = "mhlo.broadcast_in_dim"(%1567) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1569 = mhlo.shift_left %1565, %1568 : tensor<1xui32> loc(#loc299)
%1570 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1571 = "mhlo.broadcast_in_dim"(%1570) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1572 = mhlo.shift_right_logical %1565, %1571 : tensor<1xui32> loc(#loc287)
%1573 = mhlo.or %1569, %1572 : tensor<1xui32> loc(#loc300)
%1574 = mhlo.xor %1566, %1573 : tensor<1xui32> loc(#loc296)
%1575 = "mhlo.broadcast_in_dim"(%1529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1576 = mhlo.add %1566, %1575 : tensor<1xui32> loc(#loc298)
%1577 = "mhlo.broadcast_in_dim"(%1534) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1578 = mhlo.add %1574, %1577 : tensor<1xui32> loc(#loc298)
%1579 = mhlo.constant dense<1> : tensor<ui32> loc(#loc297)
%1580 = "mhlo.broadcast_in_dim"(%1579) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1581 = mhlo.add %1578, %1580 : tensor<1xui32> loc(#loc298)
%1582 = mhlo.add %1576, %1581 : tensor<1xui32> loc(#loc298)
%1583 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1584 = "mhlo.broadcast_in_dim"(%1583) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1585 = mhlo.shift_left %1581, %1584 : tensor<1xui32> loc(#loc299)
%1586 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1587 = "mhlo.broadcast_in_dim"(%1586) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1588 = mhlo.shift_right_logical %1581, %1587 : tensor<1xui32> loc(#loc287)
%1589 = mhlo.or %1585, %1588 : tensor<1xui32> loc(#loc300)
%1590 = mhlo.xor %1582, %1589 : tensor<1xui32> loc(#loc296)
%1591 = mhlo.add %1582, %1590 : tensor<1xui32> loc(#loc298)
%1592 = mhlo.constant dense<29> : tensor<ui32> loc(#loc297)
%1593 = "mhlo.broadcast_in_dim"(%1592) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1594 = mhlo.shift_left %1590, %1593 : tensor<1xui32> loc(#loc299)
%1595 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1596 = "mhlo.broadcast_in_dim"(%1595) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1597 = mhlo.shift_right_logical %1590, %1596 : tensor<1xui32> loc(#loc287)
%1598 = mhlo.or %1594, %1597 : tensor<1xui32> loc(#loc300)
%1599 = mhlo.xor %1591, %1598 : tensor<1xui32> loc(#loc296)
%1600 = mhlo.add %1591, %1599 : tensor<1xui32> loc(#loc298)
%1601 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1602 = "mhlo.broadcast_in_dim"(%1601) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1603 = mhlo.shift_left %1599, %1602 : tensor<1xui32> loc(#loc299)
%1604 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1605 = "mhlo.broadcast_in_dim"(%1604) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1606 = mhlo.shift_right_logical %1599, %1605 : tensor<1xui32> loc(#loc287)
%1607 = mhlo.or %1603, %1606 : tensor<1xui32> loc(#loc300)
%1608 = mhlo.xor %1600, %1607 : tensor<1xui32> loc(#loc296)
%1609 = mhlo.add %1600, %1608 : tensor<1xui32> loc(#loc298)
%1610 = mhlo.constant dense<24> : tensor<ui32> loc(#loc297)
%1611 = "mhlo.broadcast_in_dim"(%1610) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1612 = mhlo.shift_left %1608, %1611 : tensor<1xui32> loc(#loc299)
%1613 = mhlo.constant dense<8> : tensor<ui32> loc(#loc297)
%1614 = "mhlo.broadcast_in_dim"(%1613) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1615 = mhlo.shift_right_logical %1608, %1614 : tensor<1xui32> loc(#loc287)
%1616 = mhlo.or %1612, %1615 : tensor<1xui32> loc(#loc300)
%1617 = mhlo.xor %1609, %1616 : tensor<1xui32> loc(#loc296)
%1618 = "mhlo.broadcast_in_dim"(%1534) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1619 = mhlo.add %1609, %1618 : tensor<1xui32> loc(#loc298)
%1620 = "mhlo.broadcast_in_dim"(%1527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1621 = mhlo.add %1617, %1620 : tensor<1xui32> loc(#loc298)
%1622 = mhlo.constant dense<2> : tensor<ui32> loc(#loc297)
%1623 = "mhlo.broadcast_in_dim"(%1622) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1624 = mhlo.add %1621, %1623 : tensor<1xui32> loc(#loc298)
%1625 = mhlo.add %1619, %1624 : tensor<1xui32> loc(#loc298)
%1626 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1627 = "mhlo.broadcast_in_dim"(%1626) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1628 = mhlo.shift_left %1624, %1627 : tensor<1xui32> loc(#loc299)
%1629 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1630 = "mhlo.broadcast_in_dim"(%1629) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1631 = mhlo.shift_right_logical %1624, %1630 : tensor<1xui32> loc(#loc287)
%1632 = mhlo.or %1628, %1631 : tensor<1xui32> loc(#loc300)
%1633 = mhlo.xor %1625, %1632 : tensor<1xui32> loc(#loc296)
%1634 = mhlo.add %1625, %1633 : tensor<1xui32> loc(#loc298)
%1635 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1636 = "mhlo.broadcast_in_dim"(%1635) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1637 = mhlo.shift_left %1633, %1636 : tensor<1xui32> loc(#loc299)
%1638 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1639 = "mhlo.broadcast_in_dim"(%1638) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1640 = mhlo.shift_right_logical %1633, %1639 : tensor<1xui32> loc(#loc287)
%1641 = mhlo.or %1637, %1640 : tensor<1xui32> loc(#loc300)
%1642 = mhlo.xor %1634, %1641 : tensor<1xui32> loc(#loc296)
%1643 = mhlo.add %1634, %1642 : tensor<1xui32> loc(#loc298)
%1644 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1645 = "mhlo.broadcast_in_dim"(%1644) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1646 = mhlo.shift_left %1642, %1645 : tensor<1xui32> loc(#loc299)
%1647 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1648 = "mhlo.broadcast_in_dim"(%1647) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1649 = mhlo.shift_right_logical %1642, %1648 : tensor<1xui32> loc(#loc287)
%1650 = mhlo.or %1646, %1649 : tensor<1xui32> loc(#loc300)
%1651 = mhlo.xor %1643, %1650 : tensor<1xui32> loc(#loc296)
%1652 = mhlo.add %1643, %1651 : tensor<1xui32> loc(#loc298)
%1653 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1654 = "mhlo.broadcast_in_dim"(%1653) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1655 = mhlo.shift_left %1651, %1654 : tensor<1xui32> loc(#loc299)
%1656 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1657 = "mhlo.broadcast_in_dim"(%1656) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1658 = mhlo.shift_right_logical %1651, %1657 : tensor<1xui32> loc(#loc287)
%1659 = mhlo.or %1655, %1658 : tensor<1xui32> loc(#loc300)
%1660 = mhlo.xor %1652, %1659 : tensor<1xui32> loc(#loc296)
%1661 = "mhlo.broadcast_in_dim"(%1527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1662 = mhlo.add %1652, %1661 : tensor<1xui32> loc(#loc298)
%1663 = "mhlo.broadcast_in_dim"(%1529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1664 = mhlo.add %1660, %1663 : tensor<1xui32> loc(#loc298)
%1665 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1666 = "mhlo.broadcast_in_dim"(%1665) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1667 = mhlo.add %1664, %1666 : tensor<1xui32> loc(#loc298)
%1668 = mhlo.add %1662, %1667 : tensor<1xui32> loc(#loc298)
%1669 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1670 = "mhlo.broadcast_in_dim"(%1669) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1671 = mhlo.shift_left %1667, %1670 : tensor<1xui32> loc(#loc299)
%1672 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1673 = "mhlo.broadcast_in_dim"(%1672) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1674 = mhlo.shift_right_logical %1667, %1673 : tensor<1xui32> loc(#loc287)
%1675 = mhlo.or %1671, %1674 : tensor<1xui32> loc(#loc300)
%1676 = mhlo.xor %1668, %1675 : tensor<1xui32> loc(#loc296)
%1677 = mhlo.add %1668, %1676 : tensor<1xui32> loc(#loc298)
%1678 = mhlo.constant dense<29> : tensor<ui32> loc(#loc297)
%1679 = "mhlo.broadcast_in_dim"(%1678) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1680 = mhlo.shift_left %1676, %1679 : tensor<1xui32> loc(#loc299)
%1681 = mhlo.constant dense<3> : tensor<ui32> loc(#loc297)
%1682 = "mhlo.broadcast_in_dim"(%1681) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1683 = mhlo.shift_right_logical %1676, %1682 : tensor<1xui32> loc(#loc287)
%1684 = mhlo.or %1680, %1683 : tensor<1xui32> loc(#loc300)
%1685 = mhlo.xor %1677, %1684 : tensor<1xui32> loc(#loc296)
%1686 = mhlo.add %1677, %1685 : tensor<1xui32> loc(#loc298)
%1687 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1688 = "mhlo.broadcast_in_dim"(%1687) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1689 = mhlo.shift_left %1685, %1688 : tensor<1xui32> loc(#loc299)
%1690 = mhlo.constant dense<16> : tensor<ui32> loc(#loc297)
%1691 = "mhlo.broadcast_in_dim"(%1690) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1692 = mhlo.shift_right_logical %1685, %1691 : tensor<1xui32> loc(#loc287)
%1693 = mhlo.or %1689, %1692 : tensor<1xui32> loc(#loc300)
%1694 = mhlo.xor %1686, %1693 : tensor<1xui32> loc(#loc296)
%1695 = mhlo.add %1686, %1694 : tensor<1xui32> loc(#loc298)
%1696 = mhlo.constant dense<24> : tensor<ui32> loc(#loc297)
%1697 = "mhlo.broadcast_in_dim"(%1696) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1698 = mhlo.shift_left %1694, %1697 : tensor<1xui32> loc(#loc299)
%1699 = mhlo.constant dense<8> : tensor<ui32> loc(#loc297)
%1700 = "mhlo.broadcast_in_dim"(%1699) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1701 = mhlo.shift_right_logical %1694, %1700 : tensor<1xui32> loc(#loc287)
%1702 = mhlo.or %1698, %1701 : tensor<1xui32> loc(#loc300)
%1703 = mhlo.xor %1695, %1702 : tensor<1xui32> loc(#loc296)
%1704 = "mhlo.broadcast_in_dim"(%1529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1705 = mhlo.add %1695, %1704 : tensor<1xui32> loc(#loc298)
%1706 = "mhlo.broadcast_in_dim"(%1534) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1707 = mhlo.add %1703, %1706 : tensor<1xui32> loc(#loc298)
%1708 = mhlo.constant dense<4> : tensor<ui32> loc(#loc297)
%1709 = "mhlo.broadcast_in_dim"(%1708) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1710 = mhlo.add %1707, %1709 : tensor<1xui32> loc(#loc298)
%1711 = mhlo.add %1705, %1710 : tensor<1xui32> loc(#loc298)
%1712 = mhlo.constant dense<13> : tensor<ui32> loc(#loc297)
%1713 = "mhlo.broadcast_in_dim"(%1712) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1714 = mhlo.shift_left %1710, %1713 : tensor<1xui32> loc(#loc299)
%1715 = mhlo.constant dense<19> : tensor<ui32> loc(#loc297)
%1716 = "mhlo.broadcast_in_dim"(%1715) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1717 = mhlo.shift_right_logical %1710, %1716 : tensor<1xui32> loc(#loc287)
%1718 = mhlo.or %1714, %1717 : tensor<1xui32> loc(#loc300)
%1719 = mhlo.xor %1711, %1718 : tensor<1xui32> loc(#loc296)
%1720 = mhlo.add %1711, %1719 : tensor<1xui32> loc(#loc298)
%1721 = mhlo.constant dense<15> : tensor<ui32> loc(#loc297)
%1722 = "mhlo.broadcast_in_dim"(%1721) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1723 = mhlo.shift_left %1719, %1722 : tensor<1xui32> loc(#loc299)
%1724 = mhlo.constant dense<17> : tensor<ui32> loc(#loc297)
%1725 = "mhlo.broadcast_in_dim"(%1724) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1726 = mhlo.shift_right_logical %1719, %1725 : tensor<1xui32> loc(#loc287)
%1727 = mhlo.or %1723, %1726 : tensor<1xui32> loc(#loc300)
%1728 = mhlo.xor %1720, %1727 : tensor<1xui32> loc(#loc296)
%1729 = mhlo.add %1720, %1728 : tensor<1xui32> loc(#loc298)
%1730 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1731 = "mhlo.broadcast_in_dim"(%1730) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1732 = mhlo.shift_left %1728, %1731 : tensor<1xui32> loc(#loc299)
%1733 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1734 = "mhlo.broadcast_in_dim"(%1733) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1735 = mhlo.shift_right_logical %1728, %1734 : tensor<1xui32> loc(#loc287)
%1736 = mhlo.or %1732, %1735 : tensor<1xui32> loc(#loc300)
%1737 = mhlo.xor %1729, %1736 : tensor<1xui32> loc(#loc296)
%1738 = mhlo.add %1729, %1737 : tensor<1xui32> loc(#loc298)
%1739 = mhlo.constant dense<6> : tensor<ui32> loc(#loc297)
%1740 = "mhlo.broadcast_in_dim"(%1739) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc299)
%1741 = mhlo.shift_left %1737, %1740 : tensor<1xui32> loc(#loc299)
%1742 = mhlo.constant dense<26> : tensor<ui32> loc(#loc297)
%1743 = "mhlo.broadcast_in_dim"(%1742) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc287)
%1744 = mhlo.shift_right_logical %1737, %1743 : tensor<1xui32> loc(#loc287)
%1745 = mhlo.or %1741, %1744 : tensor<1xui32> loc(#loc300)
%1746 = mhlo.xor %1738, %1745 : tensor<1xui32> loc(#loc296)
%1747 = "mhlo.broadcast_in_dim"(%1534) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1748 = mhlo.add %1738, %1747 : tensor<1xui32> loc(#loc298)
%1749 = "mhlo.broadcast_in_dim"(%1527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1750 = mhlo.add %1746, %1749 : tensor<1xui32> loc(#loc298)
%1751 = mhlo.constant dense<5> : tensor<ui32> loc(#loc297)
%1752 = "mhlo.broadcast_in_dim"(%1751) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc298)
%1753 = mhlo.add %1750, %1752 : tensor<1xui32> loc(#loc298)
%1754 = "mhlo.concatenate"(%1748, %1753) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc290)
%1755 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc0)
%1756 = "mhlo.broadcast_in_dim"(%1755) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc301)
%1757 = "mhlo.reshape"(%1756) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc305)
%1758 = "mhlo.broadcast_in_dim"(%1757) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc306)
%1759 = mhlo.add %1517, %1758 : tensor<1x256x2048xf32> loc(#loc306)
%1760 = mhlo.convert(%1759) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc307)
%1761 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<48xui32> loc(#loc308)
%1762 = "mhlo.slice"(%248) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc309)
%1763 = "mhlo.reshape"(%1762) : (tensor<1xui32>) -> tensor<ui32> loc(#loc310)
%1764 = "mhlo.slice"(%248) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc311)
%1765 = "mhlo.reshape"(%1764) : (tensor<1xui32>) -> tensor<ui32> loc(#loc310)
%1766 = "mhlo.slice"(%1761) {limit_indices = dense<24> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<48xui32>) -> tensor<24xui32> loc(#loc312)
%1767 = "mhlo.slice"(%1761) {limit_indices = dense<48> : tensor<1xi64>, start_indices = dense<24> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<48xui32>) -> tensor<24xui32> loc(#loc313)
%1768 = mhlo.xor %1763, %1765 : tensor<ui32> loc(#loc314)
%1769 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc315)
%1770 = mhlo.xor %1768, %1769 : tensor<ui32> loc(#loc314)
%1771 = "mhlo.broadcast_in_dim"(%1763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1772 = mhlo.add %1766, %1771 : tensor<24xui32> loc(#loc316)
%1773 = "mhlo.broadcast_in_dim"(%1765) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1774 = mhlo.add %1767, %1773 : tensor<24xui32> loc(#loc316)
%1775 = mhlo.add %1772, %1774 : tensor<24xui32> loc(#loc316)
%1776 = mhlo.constant dense<13> : tensor<ui32> loc(#loc315)
%1777 = "mhlo.broadcast_in_dim"(%1776) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1778 = mhlo.shift_left %1774, %1777 : tensor<24xui32> loc(#loc317)
%1779 = mhlo.constant dense<19> : tensor<ui32> loc(#loc315)
%1780 = "mhlo.broadcast_in_dim"(%1779) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1781 = mhlo.shift_right_logical %1774, %1780 : tensor<24xui32> loc(#loc318)
%1782 = mhlo.or %1778, %1781 : tensor<24xui32> loc(#loc319)
%1783 = mhlo.xor %1775, %1782 : tensor<24xui32> loc(#loc314)
%1784 = mhlo.add %1775, %1783 : tensor<24xui32> loc(#loc316)
%1785 = mhlo.constant dense<15> : tensor<ui32> loc(#loc315)
%1786 = "mhlo.broadcast_in_dim"(%1785) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1787 = mhlo.shift_left %1783, %1786 : tensor<24xui32> loc(#loc317)
%1788 = mhlo.constant dense<17> : tensor<ui32> loc(#loc315)
%1789 = "mhlo.broadcast_in_dim"(%1788) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1790 = mhlo.shift_right_logical %1783, %1789 : tensor<24xui32> loc(#loc318)
%1791 = mhlo.or %1787, %1790 : tensor<24xui32> loc(#loc319)
%1792 = mhlo.xor %1784, %1791 : tensor<24xui32> loc(#loc314)
%1793 = mhlo.add %1784, %1792 : tensor<24xui32> loc(#loc316)
%1794 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1795 = "mhlo.broadcast_in_dim"(%1794) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1796 = mhlo.shift_left %1792, %1795 : tensor<24xui32> loc(#loc317)
%1797 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1798 = "mhlo.broadcast_in_dim"(%1797) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1799 = mhlo.shift_right_logical %1792, %1798 : tensor<24xui32> loc(#loc318)
%1800 = mhlo.or %1796, %1799 : tensor<24xui32> loc(#loc319)
%1801 = mhlo.xor %1793, %1800 : tensor<24xui32> loc(#loc314)
%1802 = mhlo.add %1793, %1801 : tensor<24xui32> loc(#loc316)
%1803 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1804 = "mhlo.broadcast_in_dim"(%1803) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1805 = mhlo.shift_left %1801, %1804 : tensor<24xui32> loc(#loc317)
%1806 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1807 = "mhlo.broadcast_in_dim"(%1806) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1808 = mhlo.shift_right_logical %1801, %1807 : tensor<24xui32> loc(#loc318)
%1809 = mhlo.or %1805, %1808 : tensor<24xui32> loc(#loc319)
%1810 = mhlo.xor %1802, %1809 : tensor<24xui32> loc(#loc314)
%1811 = "mhlo.broadcast_in_dim"(%1765) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1812 = mhlo.add %1802, %1811 : tensor<24xui32> loc(#loc316)
%1813 = "mhlo.broadcast_in_dim"(%1770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1814 = mhlo.add %1810, %1813 : tensor<24xui32> loc(#loc316)
%1815 = mhlo.constant dense<1> : tensor<ui32> loc(#loc315)
%1816 = "mhlo.broadcast_in_dim"(%1815) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1817 = mhlo.add %1814, %1816 : tensor<24xui32> loc(#loc316)
%1818 = mhlo.add %1812, %1817 : tensor<24xui32> loc(#loc316)
%1819 = mhlo.constant dense<17> : tensor<ui32> loc(#loc315)
%1820 = "mhlo.broadcast_in_dim"(%1819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1821 = mhlo.shift_left %1817, %1820 : tensor<24xui32> loc(#loc317)
%1822 = mhlo.constant dense<15> : tensor<ui32> loc(#loc315)
%1823 = "mhlo.broadcast_in_dim"(%1822) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1824 = mhlo.shift_right_logical %1817, %1823 : tensor<24xui32> loc(#loc318)
%1825 = mhlo.or %1821, %1824 : tensor<24xui32> loc(#loc319)
%1826 = mhlo.xor %1818, %1825 : tensor<24xui32> loc(#loc314)
%1827 = mhlo.add %1818, %1826 : tensor<24xui32> loc(#loc316)
%1828 = mhlo.constant dense<29> : tensor<ui32> loc(#loc315)
%1829 = "mhlo.broadcast_in_dim"(%1828) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1830 = mhlo.shift_left %1826, %1829 : tensor<24xui32> loc(#loc317)
%1831 = mhlo.constant dense<3> : tensor<ui32> loc(#loc315)
%1832 = "mhlo.broadcast_in_dim"(%1831) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1833 = mhlo.shift_right_logical %1826, %1832 : tensor<24xui32> loc(#loc318)
%1834 = mhlo.or %1830, %1833 : tensor<24xui32> loc(#loc319)
%1835 = mhlo.xor %1827, %1834 : tensor<24xui32> loc(#loc314)
%1836 = mhlo.add %1827, %1835 : tensor<24xui32> loc(#loc316)
%1837 = mhlo.constant dense<16> : tensor<ui32> loc(#loc315)
%1838 = "mhlo.broadcast_in_dim"(%1837) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1839 = mhlo.shift_left %1835, %1838 : tensor<24xui32> loc(#loc317)
%1840 = mhlo.constant dense<16> : tensor<ui32> loc(#loc315)
%1841 = "mhlo.broadcast_in_dim"(%1840) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1842 = mhlo.shift_right_logical %1835, %1841 : tensor<24xui32> loc(#loc318)
%1843 = mhlo.or %1839, %1842 : tensor<24xui32> loc(#loc319)
%1844 = mhlo.xor %1836, %1843 : tensor<24xui32> loc(#loc314)
%1845 = mhlo.add %1836, %1844 : tensor<24xui32> loc(#loc316)
%1846 = mhlo.constant dense<24> : tensor<ui32> loc(#loc315)
%1847 = "mhlo.broadcast_in_dim"(%1846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1848 = mhlo.shift_left %1844, %1847 : tensor<24xui32> loc(#loc317)
%1849 = mhlo.constant dense<8> : tensor<ui32> loc(#loc315)
%1850 = "mhlo.broadcast_in_dim"(%1849) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1851 = mhlo.shift_right_logical %1844, %1850 : tensor<24xui32> loc(#loc318)
%1852 = mhlo.or %1848, %1851 : tensor<24xui32> loc(#loc319)
%1853 = mhlo.xor %1845, %1852 : tensor<24xui32> loc(#loc314)
%1854 = "mhlo.broadcast_in_dim"(%1770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1855 = mhlo.add %1845, %1854 : tensor<24xui32> loc(#loc316)
%1856 = "mhlo.broadcast_in_dim"(%1763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1857 = mhlo.add %1853, %1856 : tensor<24xui32> loc(#loc316)
%1858 = mhlo.constant dense<2> : tensor<ui32> loc(#loc315)
%1859 = "mhlo.broadcast_in_dim"(%1858) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1860 = mhlo.add %1857, %1859 : tensor<24xui32> loc(#loc316)
%1861 = mhlo.add %1855, %1860 : tensor<24xui32> loc(#loc316)
%1862 = mhlo.constant dense<13> : tensor<ui32> loc(#loc315)
%1863 = "mhlo.broadcast_in_dim"(%1862) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1864 = mhlo.shift_left %1860, %1863 : tensor<24xui32> loc(#loc317)
%1865 = mhlo.constant dense<19> : tensor<ui32> loc(#loc315)
%1866 = "mhlo.broadcast_in_dim"(%1865) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1867 = mhlo.shift_right_logical %1860, %1866 : tensor<24xui32> loc(#loc318)
%1868 = mhlo.or %1864, %1867 : tensor<24xui32> loc(#loc319)
%1869 = mhlo.xor %1861, %1868 : tensor<24xui32> loc(#loc314)
%1870 = mhlo.add %1861, %1869 : tensor<24xui32> loc(#loc316)
%1871 = mhlo.constant dense<15> : tensor<ui32> loc(#loc315)
%1872 = "mhlo.broadcast_in_dim"(%1871) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1873 = mhlo.shift_left %1869, %1872 : tensor<24xui32> loc(#loc317)
%1874 = mhlo.constant dense<17> : tensor<ui32> loc(#loc315)
%1875 = "mhlo.broadcast_in_dim"(%1874) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1876 = mhlo.shift_right_logical %1869, %1875 : tensor<24xui32> loc(#loc318)
%1877 = mhlo.or %1873, %1876 : tensor<24xui32> loc(#loc319)
%1878 = mhlo.xor %1870, %1877 : tensor<24xui32> loc(#loc314)
%1879 = mhlo.add %1870, %1878 : tensor<24xui32> loc(#loc316)
%1880 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1881 = "mhlo.broadcast_in_dim"(%1880) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1882 = mhlo.shift_left %1878, %1881 : tensor<24xui32> loc(#loc317)
%1883 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1884 = "mhlo.broadcast_in_dim"(%1883) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1885 = mhlo.shift_right_logical %1878, %1884 : tensor<24xui32> loc(#loc318)
%1886 = mhlo.or %1882, %1885 : tensor<24xui32> loc(#loc319)
%1887 = mhlo.xor %1879, %1886 : tensor<24xui32> loc(#loc314)
%1888 = mhlo.add %1879, %1887 : tensor<24xui32> loc(#loc316)
%1889 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1890 = "mhlo.broadcast_in_dim"(%1889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1891 = mhlo.shift_left %1887, %1890 : tensor<24xui32> loc(#loc317)
%1892 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1893 = "mhlo.broadcast_in_dim"(%1892) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1894 = mhlo.shift_right_logical %1887, %1893 : tensor<24xui32> loc(#loc318)
%1895 = mhlo.or %1891, %1894 : tensor<24xui32> loc(#loc319)
%1896 = mhlo.xor %1888, %1895 : tensor<24xui32> loc(#loc314)
%1897 = "mhlo.broadcast_in_dim"(%1763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1898 = mhlo.add %1888, %1897 : tensor<24xui32> loc(#loc316)
%1899 = "mhlo.broadcast_in_dim"(%1765) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1900 = mhlo.add %1896, %1899 : tensor<24xui32> loc(#loc316)
%1901 = mhlo.constant dense<3> : tensor<ui32> loc(#loc315)
%1902 = "mhlo.broadcast_in_dim"(%1901) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1903 = mhlo.add %1900, %1902 : tensor<24xui32> loc(#loc316)
%1904 = mhlo.add %1898, %1903 : tensor<24xui32> loc(#loc316)
%1905 = mhlo.constant dense<17> : tensor<ui32> loc(#loc315)
%1906 = "mhlo.broadcast_in_dim"(%1905) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1907 = mhlo.shift_left %1903, %1906 : tensor<24xui32> loc(#loc317)
%1908 = mhlo.constant dense<15> : tensor<ui32> loc(#loc315)
%1909 = "mhlo.broadcast_in_dim"(%1908) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1910 = mhlo.shift_right_logical %1903, %1909 : tensor<24xui32> loc(#loc318)
%1911 = mhlo.or %1907, %1910 : tensor<24xui32> loc(#loc319)
%1912 = mhlo.xor %1904, %1911 : tensor<24xui32> loc(#loc314)
%1913 = mhlo.add %1904, %1912 : tensor<24xui32> loc(#loc316)
%1914 = mhlo.constant dense<29> : tensor<ui32> loc(#loc315)
%1915 = "mhlo.broadcast_in_dim"(%1914) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1916 = mhlo.shift_left %1912, %1915 : tensor<24xui32> loc(#loc317)
%1917 = mhlo.constant dense<3> : tensor<ui32> loc(#loc315)
%1918 = "mhlo.broadcast_in_dim"(%1917) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1919 = mhlo.shift_right_logical %1912, %1918 : tensor<24xui32> loc(#loc318)
%1920 = mhlo.or %1916, %1919 : tensor<24xui32> loc(#loc319)
%1921 = mhlo.xor %1913, %1920 : tensor<24xui32> loc(#loc314)
%1922 = mhlo.add %1913, %1921 : tensor<24xui32> loc(#loc316)
%1923 = mhlo.constant dense<16> : tensor<ui32> loc(#loc315)
%1924 = "mhlo.broadcast_in_dim"(%1923) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1925 = mhlo.shift_left %1921, %1924 : tensor<24xui32> loc(#loc317)
%1926 = mhlo.constant dense<16> : tensor<ui32> loc(#loc315)
%1927 = "mhlo.broadcast_in_dim"(%1926) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1928 = mhlo.shift_right_logical %1921, %1927 : tensor<24xui32> loc(#loc318)
%1929 = mhlo.or %1925, %1928 : tensor<24xui32> loc(#loc319)
%1930 = mhlo.xor %1922, %1929 : tensor<24xui32> loc(#loc314)
%1931 = mhlo.add %1922, %1930 : tensor<24xui32> loc(#loc316)
%1932 = mhlo.constant dense<24> : tensor<ui32> loc(#loc315)
%1933 = "mhlo.broadcast_in_dim"(%1932) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1934 = mhlo.shift_left %1930, %1933 : tensor<24xui32> loc(#loc317)
%1935 = mhlo.constant dense<8> : tensor<ui32> loc(#loc315)
%1936 = "mhlo.broadcast_in_dim"(%1935) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1937 = mhlo.shift_right_logical %1930, %1936 : tensor<24xui32> loc(#loc318)
%1938 = mhlo.or %1934, %1937 : tensor<24xui32> loc(#loc319)
%1939 = mhlo.xor %1931, %1938 : tensor<24xui32> loc(#loc314)
%1940 = "mhlo.broadcast_in_dim"(%1765) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1941 = mhlo.add %1931, %1940 : tensor<24xui32> loc(#loc316)
%1942 = "mhlo.broadcast_in_dim"(%1770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1943 = mhlo.add %1939, %1942 : tensor<24xui32> loc(#loc316)
%1944 = mhlo.constant dense<4> : tensor<ui32> loc(#loc315)
%1945 = "mhlo.broadcast_in_dim"(%1944) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1946 = mhlo.add %1943, %1945 : tensor<24xui32> loc(#loc316)
%1947 = mhlo.add %1941, %1946 : tensor<24xui32> loc(#loc316)
%1948 = mhlo.constant dense<13> : tensor<ui32> loc(#loc315)
%1949 = "mhlo.broadcast_in_dim"(%1948) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1950 = mhlo.shift_left %1946, %1949 : tensor<24xui32> loc(#loc317)
%1951 = mhlo.constant dense<19> : tensor<ui32> loc(#loc315)
%1952 = "mhlo.broadcast_in_dim"(%1951) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1953 = mhlo.shift_right_logical %1946, %1952 : tensor<24xui32> loc(#loc318)
%1954 = mhlo.or %1950, %1953 : tensor<24xui32> loc(#loc319)
%1955 = mhlo.xor %1947, %1954 : tensor<24xui32> loc(#loc314)
%1956 = mhlo.add %1947, %1955 : tensor<24xui32> loc(#loc316)
%1957 = mhlo.constant dense<15> : tensor<ui32> loc(#loc315)
%1958 = "mhlo.broadcast_in_dim"(%1957) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1959 = mhlo.shift_left %1955, %1958 : tensor<24xui32> loc(#loc317)
%1960 = mhlo.constant dense<17> : tensor<ui32> loc(#loc315)
%1961 = "mhlo.broadcast_in_dim"(%1960) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1962 = mhlo.shift_right_logical %1955, %1961 : tensor<24xui32> loc(#loc318)
%1963 = mhlo.or %1959, %1962 : tensor<24xui32> loc(#loc319)
%1964 = mhlo.xor %1956, %1963 : tensor<24xui32> loc(#loc314)
%1965 = mhlo.add %1956, %1964 : tensor<24xui32> loc(#loc316)
%1966 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1967 = "mhlo.broadcast_in_dim"(%1966) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1968 = mhlo.shift_left %1964, %1967 : tensor<24xui32> loc(#loc317)
%1969 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1970 = "mhlo.broadcast_in_dim"(%1969) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1971 = mhlo.shift_right_logical %1964, %1970 : tensor<24xui32> loc(#loc318)
%1972 = mhlo.or %1968, %1971 : tensor<24xui32> loc(#loc319)
%1973 = mhlo.xor %1965, %1972 : tensor<24xui32> loc(#loc314)
%1974 = mhlo.add %1965, %1973 : tensor<24xui32> loc(#loc316)
%1975 = mhlo.constant dense<6> : tensor<ui32> loc(#loc315)
%1976 = "mhlo.broadcast_in_dim"(%1975) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc317)
%1977 = mhlo.shift_left %1973, %1976 : tensor<24xui32> loc(#loc317)
%1978 = mhlo.constant dense<26> : tensor<ui32> loc(#loc315)
%1979 = "mhlo.broadcast_in_dim"(%1978) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc318)
%1980 = mhlo.shift_right_logical %1973, %1979 : tensor<24xui32> loc(#loc318)
%1981 = mhlo.or %1977, %1980 : tensor<24xui32> loc(#loc319)
%1982 = mhlo.xor %1974, %1981 : tensor<24xui32> loc(#loc314)
%1983 = "mhlo.broadcast_in_dim"(%1770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1984 = mhlo.add %1974, %1983 : tensor<24xui32> loc(#loc316)
%1985 = "mhlo.broadcast_in_dim"(%1763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1986 = mhlo.add %1982, %1985 : tensor<24xui32> loc(#loc316)
%1987 = mhlo.constant dense<5> : tensor<ui32> loc(#loc315)
%1988 = "mhlo.broadcast_in_dim"(%1987) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<24xui32> loc(#loc316)
%1989 = mhlo.add %1986, %1988 : tensor<24xui32> loc(#loc316)
%1990 = "mhlo.concatenate"(%1984, %1989) {dimension = 0 : i64} : (tensor<24xui32>, tensor<24xui32>) -> tensor<48xui32> loc(#loc320)
%1991 = "mhlo.reshape"(%1990) : (tensor<48xui32>) -> tensor<24x2xui32> loc(#loc321)
%1992 = mhlo.constant dense<3919164554> : tensor<ui32> loc(#loc322)
%1993 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%1994 = mhlo.shift_right_logical %1992, %1993 : tensor<ui32> loc(#loc323)
%1995 = "mhlo.reshape"(%1994) : (tensor<ui32>) -> tensor<1xui32> loc(#loc324)
%1996 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%1997 = mhlo.and %1992, %1996 : tensor<ui32> loc(#loc325)
%1998 = "mhlo.reshape"(%1997) : (tensor<ui32>) -> tensor<1xui32> loc(#loc324)
%1999 = "mhlo.concatenate"(%1995, %1998) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc326)
%2000 = "mhlo.slice"(%1999) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc327)
%2001 = "mhlo.slice"(%1999) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc328)
%2002 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2003 = "mhlo.broadcast_in_dim"(%2002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc329)
%2004 = "mhlo.reshape"(%2003) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc330)
%2005 = mhlo.constant dense<true> : tensor<i1> loc(#loc322)
%2006 = "mhlo.broadcast_in_dim"(%2005) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i1>) -> tensor<1x256xi1> loc(#loc331)
%2007 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<256xi32> loc(#loc332)
%2008 = "mhlo.broadcast_in_dim"(%2007) {broadcast_dimensions = dense<1> : tensor<1xi64>} : (tensor<256xi32>) -> tensor<1x256xi32> loc(#loc333)
%2009 = "mhlo.broadcast_in_dim"(%2008) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x256xi32>) -> tensor<1x256x1xi32> loc(#loc334)
%2010 = "mhlo.broadcast_in_dim"(%2008) {broadcast_dimensions = dense<[0, 2]> : tensor<2xi64>} : (tensor<1x256xi32>) -> tensor<1x1x256xi32> loc(#loc335)
%2011 = "mhlo.broadcast_in_dim"(%2009) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xi32>) -> tensor<1x256x256xi32> loc(#loc336)
%2012 = "mhlo.broadcast_in_dim"(%2010) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x256xi32>) -> tensor<1x256x256xi32> loc(#loc336)
%2013 = "mhlo.compare"(%2011, %2012) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction GE">} : (tensor<1x256x256xi32>, tensor<1x256x256xi32>) -> tensor<1x256x256xi1> loc(#loc336)
%2014 = "mhlo.broadcast_in_dim"(%2013) {broadcast_dimensions = dense<[0, 2, 3]> : tensor<3xi64>} : (tensor<1x256x256xi1>) -> tensor<1x1x256x256xi1> loc(#loc337)
%2015 = mhlo.constant dense<2770093708> : tensor<ui32> loc(#loc322)
%2016 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2017 = mhlo.shift_right_logical %2015, %2016 : tensor<ui32> loc(#loc338)
%2018 = "mhlo.reshape"(%2017) : (tensor<ui32>) -> tensor<1xui32> loc(#loc339)
%2019 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2020 = mhlo.and %2015, %2019 : tensor<ui32> loc(#loc340)
%2021 = "mhlo.reshape"(%2020) : (tensor<ui32>) -> tensor<1xui32> loc(#loc339)
%2022 = "mhlo.concatenate"(%2018, %2021) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc341)
%2023 = "mhlo.slice"(%2022) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc342)
%2024 = "mhlo.slice"(%2022) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc343)
%2025 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2026 = "mhlo.broadcast_in_dim"(%2025) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc344)
%2027 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2028 = "mhlo.broadcast_in_dim"(%2027) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc344)
%2029 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc345)
%2030 = "mhlo.slice"(%2029) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc346)
%2031 = "mhlo.slice"(%2029) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc347)
%2032 = mhlo.subtract %2028, %2026 : tensor<1x1xf32> loc(#loc348)
%2033 = mhlo.constant dense<765858160> : tensor<ui32> loc(#loc322)
%2034 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2035 = mhlo.shift_right_logical %2033, %2034 : tensor<ui32> loc(#loc349)
%2036 = "mhlo.reshape"(%2035) : (tensor<ui32>) -> tensor<1xui32> loc(#loc350)
%2037 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2038 = mhlo.and %2033, %2037 : tensor<ui32> loc(#loc351)
%2039 = "mhlo.reshape"(%2038) : (tensor<ui32>) -> tensor<1xui32> loc(#loc350)
%2040 = "mhlo.concatenate"(%2036, %2039) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc352)
%2041 = "mhlo.slice"(%2040) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc353)
%2042 = "mhlo.slice"(%2040) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc354)
%2043 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2044 = "mhlo.broadcast_in_dim"(%2043) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc355)
%2045 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2046 = "mhlo.broadcast_in_dim"(%2045) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc355)
%2047 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc356)
%2048 = "mhlo.slice"(%2047) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc357)
%2049 = "mhlo.slice"(%2047) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc358)
%2050 = mhlo.subtract %2046, %2044 : tensor<1x1xf32> loc(#loc359)
%2051 = mhlo.constant dense<100406128> : tensor<ui32> loc(#loc322)
%2052 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2053 = mhlo.shift_right_logical %2051, %2052 : tensor<ui32> loc(#loc360)
%2054 = "mhlo.reshape"(%2053) : (tensor<ui32>) -> tensor<1xui32> loc(#loc361)
%2055 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2056 = mhlo.and %2051, %2055 : tensor<ui32> loc(#loc362)
%2057 = "mhlo.reshape"(%2056) : (tensor<ui32>) -> tensor<1xui32> loc(#loc361)
%2058 = "mhlo.concatenate"(%2054, %2057) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc363)
%2059 = "mhlo.slice"(%2058) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc364)
%2060 = "mhlo.slice"(%2058) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc365)
%2061 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2062 = "mhlo.broadcast_in_dim"(%2061) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc366)
%2063 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2064 = "mhlo.broadcast_in_dim"(%2063) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc366)
%2065 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc367)
%2066 = "mhlo.slice"(%2065) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc368)
%2067 = "mhlo.slice"(%2065) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc369)
%2068 = mhlo.subtract %2064, %2062 : tensor<1x1xf32> loc(#loc370)
%2069 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc322)
%2070 = "mhlo.broadcast_in_dim"(%2069) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc371)
%2071 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc322)
%2072 = "mhlo.broadcast_in_dim"(%2071) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc371)
%2073 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2074 = "mhlo.broadcast_in_dim"(%2073) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x256x256xf32> loc(#loc372)
%2075 = mhlo.convert(%2074) : (tensor<1x1x256x256xf32>) -> tensor<1x1x256x256xf16> loc(#loc373)
%2076 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc322)
%2077 = "mhlo.broadcast_in_dim"(%2076) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x256x256xf32> loc(#loc374)
%2078 = mhlo.convert(%2077) : (tensor<1x1x256x256xf32>) -> tensor<1x1x256x256xf16> loc(#loc375)
%2079 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc322)
%2080 = mhlo.sqrt %2079 : tensor<f32> loc(#loc376)
%2081 = mhlo.convert(%2080) : (tensor<f32>) -> tensor<f16> loc(#loc377)
call @_einsum_18() : () -> () loc(#loc378)
call @_einsum_19() : () -> () loc(#loc379)
%2082 = mhlo.constant dense<1760901733> : tensor<ui32> loc(#loc322)
%2083 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2084 = mhlo.shift_right_logical %2082, %2083 : tensor<ui32> loc(#loc380)
%2085 = "mhlo.reshape"(%2084) : (tensor<ui32>) -> tensor<1xui32> loc(#loc381)
%2086 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2087 = mhlo.and %2082, %2086 : tensor<ui32> loc(#loc382)
%2088 = "mhlo.reshape"(%2087) : (tensor<ui32>) -> tensor<1xui32> loc(#loc381)
%2089 = "mhlo.concatenate"(%2085, %2088) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc383)
%2090 = "mhlo.slice"(%2089) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc384)
%2091 = "mhlo.slice"(%2089) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc385)
%2092 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2093 = "mhlo.broadcast_in_dim"(%2092) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc386)
%2094 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2095 = "mhlo.broadcast_in_dim"(%2094) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc386)
%2096 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc387)
%2097 = "mhlo.slice"(%2096) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc388)
%2098 = "mhlo.slice"(%2096) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc389)
%2099 = mhlo.subtract %2095, %2093 : tensor<1x1xf32> loc(#loc390)
%2100 = mhlo.constant dense<3282253737> : tensor<ui32> loc(#loc322)
%2101 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2102 = mhlo.shift_right_logical %2100, %2101 : tensor<ui32> loc(#loc391)
%2103 = "mhlo.reshape"(%2102) : (tensor<ui32>) -> tensor<1xui32> loc(#loc392)
%2104 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2105 = mhlo.and %2100, %2104 : tensor<ui32> loc(#loc393)
%2106 = "mhlo.reshape"(%2105) : (tensor<ui32>) -> tensor<1xui32> loc(#loc392)
%2107 = "mhlo.concatenate"(%2103, %2106) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc394)
%2108 = "mhlo.slice"(%2107) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc395)
%2109 = "mhlo.slice"(%2107) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc396)
%2110 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2111 = "mhlo.broadcast_in_dim"(%2110) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc397)
%2112 = "mhlo.reshape"(%2111) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc398)
%2113 = mhlo.constant dense<2734489451> : tensor<ui32> loc(#loc322)
%2114 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2115 = mhlo.shift_right_logical %2113, %2114 : tensor<ui32> loc(#loc391)
%2116 = "mhlo.reshape"(%2115) : (tensor<ui32>) -> tensor<1xui32> loc(#loc392)
%2117 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2118 = mhlo.and %2113, %2117 : tensor<ui32> loc(#loc393)
%2119 = "mhlo.reshape"(%2118) : (tensor<ui32>) -> tensor<1xui32> loc(#loc392)
%2120 = "mhlo.concatenate"(%2116, %2119) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc394)
%2121 = "mhlo.slice"(%2120) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc395)
%2122 = "mhlo.slice"(%2120) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc396)
%2123 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2124 = "mhlo.broadcast_in_dim"(%2123) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc397)
%2125 = "mhlo.reshape"(%2124) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc399)
%2126 = mhlo.constant dense<410921832> : tensor<ui32> loc(#loc322)
%2127 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2128 = mhlo.shift_right_logical %2126, %2127 : tensor<ui32> loc(#loc400)
%2129 = "mhlo.reshape"(%2128) : (tensor<ui32>) -> tensor<1xui32> loc(#loc401)
%2130 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2131 = mhlo.and %2126, %2130 : tensor<ui32> loc(#loc402)
%2132 = "mhlo.reshape"(%2131) : (tensor<ui32>) -> tensor<1xui32> loc(#loc401)
%2133 = "mhlo.concatenate"(%2129, %2132) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc403)
%2134 = "mhlo.slice"(%2133) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc404)
%2135 = "mhlo.slice"(%2133) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc405)
%2136 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2137 = "mhlo.broadcast_in_dim"(%2136) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc406)
%2138 = "mhlo.reshape"(%2137) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc407)
%2139 = mhlo.constant dense<3178097723> : tensor<ui32> loc(#loc322)
%2140 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2141 = mhlo.shift_right_logical %2139, %2140 : tensor<ui32> loc(#loc408)
%2142 = "mhlo.reshape"(%2141) : (tensor<ui32>) -> tensor<1xui32> loc(#loc409)
%2143 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2144 = mhlo.and %2139, %2143 : tensor<ui32> loc(#loc410)
%2145 = "mhlo.reshape"(%2144) : (tensor<ui32>) -> tensor<1xui32> loc(#loc409)
%2146 = "mhlo.concatenate"(%2142, %2145) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc411)
%2147 = "mhlo.slice"(%2146) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc412)
%2148 = "mhlo.slice"(%2146) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc413)
%2149 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2150 = "mhlo.broadcast_in_dim"(%2149) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc414)
%2151 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2152 = "mhlo.broadcast_in_dim"(%2151) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc414)
%2153 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc415)
%2154 = "mhlo.slice"(%2153) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc416)
%2155 = "mhlo.slice"(%2153) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc417)
%2156 = mhlo.subtract %2152, %2150 : tensor<1x1xf32> loc(#loc418)
%2157 = mhlo.constant dense<2142163785> : tensor<ui32> loc(#loc322)
%2158 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2159 = mhlo.shift_right_logical %2157, %2158 : tensor<ui32> loc(#loc419)
%2160 = "mhlo.reshape"(%2159) : (tensor<ui32>) -> tensor<1xui32> loc(#loc420)
%2161 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2162 = mhlo.and %2157, %2161 : tensor<ui32> loc(#loc421)
%2163 = "mhlo.reshape"(%2162) : (tensor<ui32>) -> tensor<1xui32> loc(#loc420)
%2164 = "mhlo.concatenate"(%2160, %2163) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc422)
%2165 = "mhlo.slice"(%2164) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc423)
%2166 = "mhlo.slice"(%2164) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc424)
%2167 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2168 = "mhlo.broadcast_in_dim"(%2167) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc425)
%2169 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2170 = "mhlo.broadcast_in_dim"(%2169) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc425)
%2171 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc426)
%2172 = "mhlo.slice"(%2171) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc427)
%2173 = "mhlo.slice"(%2171) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc428)
%2174 = mhlo.subtract %2170, %2168 : tensor<1x1xf32> loc(#loc429)
%2175 = mhlo.constant dense<4234400552> : tensor<ui32> loc(#loc322)
%2176 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2177 = mhlo.shift_right_logical %2175, %2176 : tensor<ui32> loc(#loc430)
%2178 = "mhlo.reshape"(%2177) : (tensor<ui32>) -> tensor<1xui32> loc(#loc431)
%2179 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2180 = mhlo.and %2175, %2179 : tensor<ui32> loc(#loc432)
%2181 = "mhlo.reshape"(%2180) : (tensor<ui32>) -> tensor<1xui32> loc(#loc431)
%2182 = "mhlo.concatenate"(%2178, %2181) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc433)
%2183 = "mhlo.slice"(%2182) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc434)
%2184 = "mhlo.slice"(%2182) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc435)
%2185 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2186 = "mhlo.broadcast_in_dim"(%2185) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc436)
%2187 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2188 = "mhlo.broadcast_in_dim"(%2187) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc436)
%2189 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc437)
%2190 = "mhlo.slice"(%2189) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc438)
%2191 = "mhlo.slice"(%2189) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc439)
%2192 = mhlo.subtract %2188, %2186 : tensor<1x1xf32> loc(#loc440)
%2193 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc322)
%2194 = mhlo.sqrt %2193 : tensor<f32> loc(#loc441)
%2195 = mhlo.convert(%2194) : (tensor<f32>) -> tensor<f16> loc(#loc442)
call @_einsum_20() : () -> () loc(#loc443)
call @_einsum_21() : () -> () loc(#loc444)
%2196 = mhlo.constant dense<4068095876> : tensor<ui32> loc(#loc322)
%2197 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2198 = mhlo.shift_right_logical %2196, %2197 : tensor<ui32> loc(#loc445)
%2199 = "mhlo.reshape"(%2198) : (tensor<ui32>) -> tensor<1xui32> loc(#loc446)
%2200 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2201 = mhlo.and %2196, %2200 : tensor<ui32> loc(#loc447)
%2202 = "mhlo.reshape"(%2201) : (tensor<ui32>) -> tensor<1xui32> loc(#loc446)
%2203 = "mhlo.concatenate"(%2199, %2202) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc448)
%2204 = "mhlo.slice"(%2203) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc449)
%2205 = "mhlo.slice"(%2203) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc450)
%2206 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2207 = "mhlo.broadcast_in_dim"(%2206) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc451)
%2208 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2209 = "mhlo.broadcast_in_dim"(%2208) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc451)
%2210 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc452)
%2211 = "mhlo.slice"(%2210) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc453)
%2212 = "mhlo.slice"(%2210) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc454)
%2213 = mhlo.subtract %2209, %2207 : tensor<1x1xf32> loc(#loc455)
%2214 = mhlo.constant dense<3714940994> : tensor<ui32> loc(#loc322)
%2215 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2216 = mhlo.shift_right_logical %2214, %2215 : tensor<ui32> loc(#loc456)
%2217 = "mhlo.reshape"(%2216) : (tensor<ui32>) -> tensor<1xui32> loc(#loc457)
%2218 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2219 = mhlo.and %2214, %2218 : tensor<ui32> loc(#loc458)
%2220 = "mhlo.reshape"(%2219) : (tensor<ui32>) -> tensor<1xui32> loc(#loc457)
%2221 = "mhlo.concatenate"(%2217, %2220) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc459)
%2222 = "mhlo.slice"(%2221) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc460)
%2223 = "mhlo.slice"(%2221) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc461)
%2224 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2225 = "mhlo.broadcast_in_dim"(%2224) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc462)
%2226 = "mhlo.reshape"(%2225) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc463)
%2227 = mhlo.constant dense<640852316> : tensor<ui32> loc(#loc322)
%2228 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2229 = mhlo.shift_right_logical %2227, %2228 : tensor<ui32> loc(#loc456)
%2230 = "mhlo.reshape"(%2229) : (tensor<ui32>) -> tensor<1xui32> loc(#loc457)
%2231 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2232 = mhlo.and %2227, %2231 : tensor<ui32> loc(#loc458)
%2233 = "mhlo.reshape"(%2232) : (tensor<ui32>) -> tensor<1xui32> loc(#loc457)
%2234 = "mhlo.concatenate"(%2230, %2233) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc459)
%2235 = "mhlo.slice"(%2234) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc460)
%2236 = "mhlo.slice"(%2234) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc461)
%2237 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2238 = "mhlo.broadcast_in_dim"(%2237) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc462)
%2239 = "mhlo.reshape"(%2238) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc464)
%2240 = mhlo.constant dense<603271431> : tensor<ui32> loc(#loc322)
%2241 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2242 = mhlo.shift_right_logical %2240, %2241 : tensor<ui32> loc(#loc465)
%2243 = "mhlo.reshape"(%2242) : (tensor<ui32>) -> tensor<1xui32> loc(#loc466)
%2244 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2245 = mhlo.and %2240, %2244 : tensor<ui32> loc(#loc467)
%2246 = "mhlo.reshape"(%2245) : (tensor<ui32>) -> tensor<1xui32> loc(#loc466)
%2247 = "mhlo.concatenate"(%2243, %2246) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc468)
%2248 = "mhlo.slice"(%2247) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc469)
%2249 = "mhlo.slice"(%2247) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc470)
%2250 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2251 = "mhlo.broadcast_in_dim"(%2250) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc471)
%2252 = "mhlo.reshape"(%2251) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc472)
%2253 = mhlo.constant dense<2273230458> : tensor<ui32> loc(#loc322)
%2254 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2255 = mhlo.shift_right_logical %2253, %2254 : tensor<ui32> loc(#loc473)
%2256 = "mhlo.reshape"(%2255) : (tensor<ui32>) -> tensor<1xui32> loc(#loc474)
%2257 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2258 = mhlo.and %2253, %2257 : tensor<ui32> loc(#loc475)
%2259 = "mhlo.reshape"(%2258) : (tensor<ui32>) -> tensor<1xui32> loc(#loc474)
%2260 = "mhlo.concatenate"(%2256, %2259) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc476)
%2261 = "mhlo.slice"(%2260) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc477)
%2262 = "mhlo.slice"(%2260) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc478)
%2263 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2264 = "mhlo.broadcast_in_dim"(%2263) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc479)
%2265 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2266 = "mhlo.broadcast_in_dim"(%2265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc479)
%2267 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<8388608xui32> loc(#loc480)
%2268 = "mhlo.slice"(%2267) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc481)
%2269 = "mhlo.slice"(%2267) {limit_indices = dense<8388608> : tensor<1xi64>, start_indices = dense<4194304> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc482)
%2270 = mhlo.subtract %2266, %2264 : tensor<1x1xf32> loc(#loc483)
%2271 = mhlo.constant dense<3288960962> : tensor<ui32> loc(#loc322)
%2272 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2273 = mhlo.shift_right_logical %2271, %2272 : tensor<ui32> loc(#loc484)
%2274 = "mhlo.reshape"(%2273) : (tensor<ui32>) -> tensor<1xui32> loc(#loc485)
%2275 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2276 = mhlo.and %2271, %2275 : tensor<ui32> loc(#loc486)
%2277 = "mhlo.reshape"(%2276) : (tensor<ui32>) -> tensor<1xui32> loc(#loc485)
%2278 = "mhlo.concatenate"(%2274, %2277) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc487)
%2279 = "mhlo.slice"(%2278) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc488)
%2280 = "mhlo.slice"(%2278) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc489)
%2281 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2282 = "mhlo.broadcast_in_dim"(%2281) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc490)
%2283 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2284 = "mhlo.broadcast_in_dim"(%2283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc490)
%2285 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<8388608xui32> loc(#loc491)
%2286 = "mhlo.slice"(%2285) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc492)
%2287 = "mhlo.slice"(%2285) {limit_indices = dense<8388608> : tensor<1xi64>, start_indices = dense<4194304> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc493)
%2288 = mhlo.subtract %2284, %2282 : tensor<1x1xf32> loc(#loc494)
%2289 = mhlo.constant dense<1071643095> : tensor<ui32> loc(#loc322)
%2290 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2291 = mhlo.shift_right_logical %2289, %2290 : tensor<ui32> loc(#loc495)
%2292 = "mhlo.reshape"(%2291) : (tensor<ui32>) -> tensor<1xui32> loc(#loc496)
%2293 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2294 = mhlo.and %2289, %2293 : tensor<ui32> loc(#loc497)
%2295 = "mhlo.reshape"(%2294) : (tensor<ui32>) -> tensor<1xui32> loc(#loc496)
%2296 = "mhlo.concatenate"(%2292, %2295) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc498)
%2297 = "mhlo.slice"(%2296) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc499)
%2298 = "mhlo.slice"(%2296) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc500)
%2299 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2300 = "mhlo.broadcast_in_dim"(%2299) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<4096xf32> loc(#loc501)
%2301 = "mhlo.reshape"(%2300) : (tensor<4096xf32>) -> tensor<1x1x4096xf32> loc(#loc502)
%2302 = mhlo.constant dense<3882838635> : tensor<ui32> loc(#loc322)
%2303 = mhlo.constant dense<32> : tensor<ui32> loc(#loc322)
%2304 = mhlo.shift_right_logical %2302, %2303 : tensor<ui32> loc(#loc503)
%2305 = "mhlo.reshape"(%2304) : (tensor<ui32>) -> tensor<1xui32> loc(#loc504)
%2306 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc322)
%2307 = mhlo.and %2302, %2306 : tensor<ui32> loc(#loc505)
%2308 = "mhlo.reshape"(%2307) : (tensor<ui32>) -> tensor<1xui32> loc(#loc504)
%2309 = "mhlo.concatenate"(%2305, %2308) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc506)
%2310 = "mhlo.slice"(%2309) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc507)
%2311 = "mhlo.slice"(%2309) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc508)
%2312 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc322)
%2313 = "mhlo.broadcast_in_dim"(%2312) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc509)
%2314 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2315 = "mhlo.broadcast_in_dim"(%2314) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc509)
%2316 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<8388608xui32> loc(#loc510)
%2317 = "mhlo.slice"(%2316) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc511)
%2318 = "mhlo.slice"(%2316) {limit_indices = dense<8388608> : tensor<1xi64>, start_indices = dense<4194304> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc512)
%2319 = mhlo.subtract %2315, %2313 : tensor<1x1xf32> loc(#loc513)
%2320 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc322)
%2321 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc322)
%2322 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc322)
%2323 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2324 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2325 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2326 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2327 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2328 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2329 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2330 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2331 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2332 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2333 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2334 = mhlo.constant dense<0> : tensor<i32> loc(#loc322)
%2335 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2336 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2337 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2338 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2339 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2340 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2341 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2342 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2343 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2344 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2345 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2346 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2347 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2348 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2349 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2350 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2351 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2352 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2353 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2354 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2355 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2356 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2357 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2358 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2359 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2360 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2361 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2362 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2363 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2364 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2365 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc322)
%2366 = mhlo.constant dense<2.000000e+00> : tensor<f16> loc(#loc322)
%2367 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc322)
%2368 = mhlo.constant dense<1.414060e+00> : tensor<f16> loc(#loc322)
%2369 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2370 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2371 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2372 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc322)
%2373 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2374 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2375 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2376 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2377 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2378 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2379 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc322)
%2380 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc322)
%2381 = mhlo.constant dense<4.096000e+03> : tensor<f32> loc(#loc322)
%2382 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc322)
%2383 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc322)
%2384 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc322)
%2385 = mhlo.constant dense<0> : tensor<i32> loc(#loc322)
%2386 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2387 = "mhlo.broadcast_in_dim"(%2386) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2388 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2389 = "mhlo.broadcast_in_dim"(%2388) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2390 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2391 = "mhlo.broadcast_in_dim"(%2390) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2392 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2393 = "mhlo.broadcast_in_dim"(%2392) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2394 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2395 = "mhlo.broadcast_in_dim"(%2394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2396 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2397 = "mhlo.broadcast_in_dim"(%2396) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2398 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2399 = "mhlo.broadcast_in_dim"(%2398) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2400 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2401 = "mhlo.broadcast_in_dim"(%2400) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x2048xf32> loc(#loc515)
%2402 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2403 = "mhlo.broadcast_in_dim"(%2402) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x4096xf32> loc(#loc516)
%2404 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2405 = "mhlo.broadcast_in_dim"(%2404) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048x4096xf32> loc(#loc516)
%2406 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2407 = "mhlo.broadcast_in_dim"(%2406) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x4096x2048xf32> loc(#loc517)
%2408 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2409 = "mhlo.broadcast_in_dim"(%2408) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2410 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2411 = "mhlo.broadcast_in_dim"(%2410) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x4096xf32> loc(#loc519)
%2412 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2413 = "mhlo.broadcast_in_dim"(%2412) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2414 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2415 = "mhlo.broadcast_in_dim"(%2414) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2416 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2417 = "mhlo.broadcast_in_dim"(%2416) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2418 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2419 = "mhlo.broadcast_in_dim"(%2418) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2420 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2421 = "mhlo.broadcast_in_dim"(%2420) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2422 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc514)
%2423 = "mhlo.broadcast_in_dim"(%2422) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<24x2048xf32> loc(#loc518)
%2424 = mhlo.constant dense<0> : tensor<i32> loc(#loc514)
%2425 = "mhlo.broadcast_in_dim"(%2424) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<24xi32> loc(#loc520)
%2426 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc514)
%2427 = "mhlo.broadcast_in_dim"(%2426) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<24x1x256x32x64xf16> loc(#loc521)
%2428 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc514)
%2429 = "mhlo.broadcast_in_dim"(%2428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<24x1x256x32x64xf16> loc(#loc521)
%2430 = mhlo.constant dense<0> : tensor<i32> loc(#loc514)
%2431:27 = mhlo.while(%iterArg = %1991, %iterArg_0 = %233, %iterArg_1 = %108, %iterArg_2 = %2430, %iterArg_3 = %1760, %iterArg_4 = %2387, %iterArg_5 = %2389, %iterArg_6 = %2391, %iterArg_7 = %2393, %iterArg_8 = %2395, %iterArg_9 = %2397, %iterArg_10 = %2399, %iterArg_11 = %2401, %iterArg_12 = %2403, %iterArg_13 = %2405, %iterArg_14 = %2407, %iterArg_15 = %2409, %iterArg_16 = %2411, %iterArg_17 = %2413, %iterArg_18 = %2415, %iterArg_19 = %2417, %iterArg_20 = %2419, %iterArg_21 = %2421, %iterArg_22 = %2423, %iterArg_23 = %2425, %iterArg_24 = %2427, %iterArg_25 = %2429) : tensor<24x2xui32>, tensor<1x256xi32>, tensor<1x64x2048xf16>, tensor<i32>, tensor<1x256x2048xf16>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x2048xf32>, tensor<24x2048x4096xf32>, tensor<24x2048x4096xf32>, tensor<24x4096x2048xf32>, tensor<24x2048xf32>, tensor<24x4096xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24x2048xf32>, tensor<24xi32>, tensor<24x1x256x32x64xf16>, tensor<24x1x256x32x64xf16>
cond {
%5188 = mhlo.constant dense<24> : tensor<i32> loc(#loc522)
%5189 = "mhlo.compare"(%iterArg_2, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc523)
"mhlo.return"(%5189) : (tensor<i1>) -> () loc(#loc522)
} do {
%5188 = mhlo.constant dense<0> : tensor<i32> loc(#loc522)
%5189 = "mhlo.compare"(%iterArg_2, %5188) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc524)
%5190 = mhlo.constant dense<24> : tensor<i32> loc(#loc522)
%5191 = mhlo.add %iterArg_2, %5190 : tensor<i32> loc(#loc525)
%5192 = "mhlo.select"(%5189, %5191, %iterArg_2) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc526)
%5193 = mhlo.constant dense<0> : tensor<i32> loc(#loc522)
%5194 = mhlo.constant dense<0> : tensor<i32> loc(#loc522)
%5195 = "mhlo.compare"(%5193, %5194) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction LT">} : (tensor<i32>, tensor<i32>) -> tensor<i1> loc(#loc524)
%5196 = mhlo.constant dense<0> : tensor<i32> loc(#loc522)
%5197 = mhlo.constant dense<2> : tensor<i32> loc(#loc522)
%5198 = mhlo.add %5196, %5197 : tensor<i32> loc(#loc525)
%5199 = mhlo.constant dense<0> : tensor<i32> loc(#loc522)
%5200 = "mhlo.select"(%5195, %5198, %5199) : (tensor<i1>, tensor<i32>, tensor<i32>) -> tensor<i32> loc(#loc526)
%5201 = "mhlo.dynamic-slice"(%iterArg, %5192, %5200) {slice_sizes = dense<[1, 2]> : tensor<2xi64>} : (tensor<24x2xui32>, tensor<i32>, tensor<i32>) -> tensor<1x2xui32> loc(#loc527)
%5202 = "mhlo.reshape"(%5201) : (tensor<1x2xui32>) -> tensor<2xui32> loc(#loc528)
%5203 = mhlo.convert(%iterArg_3) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc529)
%5204 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc530)
%5205 = mhlo.reduce(%5203 init: %5204) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc530)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc530)
} loc(#loc530)
%5206 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%5207 = "mhlo.broadcast_in_dim"(%5206) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc532)
%5208 = mhlo.divide %5205, %5207 : tensor<1x256xf32> loc(#loc532)
%5209 = mhlo.multiply %5203, %5203 : tensor<1x256x2048xf32> loc(#loc533)
%5210 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc534)
%5211 = mhlo.reduce(%5209 init: %5210) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc534)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc534)
} loc(#loc534)
%5212 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%5213 = "mhlo.broadcast_in_dim"(%5212) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc535)
%5214 = mhlo.divide %5211, %5213 : tensor<1x256xf32> loc(#loc535)
%5215 = mhlo.multiply %5208, %5208 : tensor<1x256xf32> loc(#loc533)
%5216 = mhlo.subtract %5214, %5215 : tensor<1x256xf32> loc(#loc536)
%5217 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%5218 = "mhlo.broadcast_in_dim"(%5217) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc537)
%5219 = mhlo.maximum %5218, %5216 : tensor<1x256xf32> loc(#loc537)
%5220 = "mhlo.reshape"(%5208) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc538)
%5221 = "mhlo.reshape"(%5219) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc539)
%5222 = mhlo.convert(%iterArg_3) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc540)
%5223 = "mhlo.broadcast_in_dim"(%5220) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc541)
%5224 = mhlo.subtract %5222, %5223 : tensor<1x256x2048xf32> loc(#loc541)
%5225 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc531)
%5226 = "mhlo.broadcast_in_dim"(%5225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc542)
%5227 = mhlo.add %5221, %5226 : tensor<1x256x1xf32> loc(#loc542)
%5228 = mhlo.rsqrt %5227 : tensor<1x256x1xf32> loc(#loc543)
%5229 = "mhlo.broadcast_in_dim"(%5228) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc544)
%5230 = mhlo.multiply %5224, %5229 : tensor<1x256x2048xf32> loc(#loc544)
%5231 = mhlo.constant dense<3001501508> : tensor<ui32> loc(#loc531)
%5232 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%5233 = mhlo.shift_right_logical %5231, %5232 : tensor<ui32> loc(#loc545)
%5234 = "mhlo.reshape"(%5233) : (tensor<ui32>) -> tensor<1xui32> loc(#loc546)
%5235 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%5236 = mhlo.and %5231, %5235 : tensor<ui32> loc(#loc547)
%5237 = "mhlo.reshape"(%5236) : (tensor<ui32>) -> tensor<1xui32> loc(#loc546)
%5238 = "mhlo.concatenate"(%5234, %5237) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc548)
%5239 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc549)
%5240 = "mhlo.reshape"(%5239) : (tensor<1xui32>) -> tensor<ui32> loc(#loc550)
%5241 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc551)
%5242 = "mhlo.reshape"(%5241) : (tensor<1xui32>) -> tensor<ui32> loc(#loc550)
%5243 = "mhlo.slice"(%5238) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc552)
%5244 = "mhlo.slice"(%5238) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc553)
%5245 = mhlo.xor %5240, %5242 : tensor<ui32> loc(#loc554)
%5246 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc555)
%5247 = mhlo.xor %5245, %5246 : tensor<ui32> loc(#loc554)
%5248 = "mhlo.broadcast_in_dim"(%5240) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5249 = mhlo.add %5243, %5248 : tensor<1xui32> loc(#loc556)
%5250 = "mhlo.broadcast_in_dim"(%5242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5251 = mhlo.add %5244, %5250 : tensor<1xui32> loc(#loc556)
%5252 = mhlo.add %5249, %5251 : tensor<1xui32> loc(#loc556)
%5253 = mhlo.constant dense<13> : tensor<ui32> loc(#loc555)
%5254 = "mhlo.broadcast_in_dim"(%5253) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5255 = mhlo.shift_left %5251, %5254 : tensor<1xui32> loc(#loc557)
%5256 = mhlo.constant dense<19> : tensor<ui32> loc(#loc555)
%5257 = "mhlo.broadcast_in_dim"(%5256) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5258 = mhlo.shift_right_logical %5251, %5257 : tensor<1xui32> loc(#loc545)
%5259 = mhlo.or %5255, %5258 : tensor<1xui32> loc(#loc558)
%5260 = mhlo.xor %5252, %5259 : tensor<1xui32> loc(#loc554)
%5261 = mhlo.add %5252, %5260 : tensor<1xui32> loc(#loc556)
%5262 = mhlo.constant dense<15> : tensor<ui32> loc(#loc555)
%5263 = "mhlo.broadcast_in_dim"(%5262) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5264 = mhlo.shift_left %5260, %5263 : tensor<1xui32> loc(#loc557)
%5265 = mhlo.constant dense<17> : tensor<ui32> loc(#loc555)
%5266 = "mhlo.broadcast_in_dim"(%5265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5267 = mhlo.shift_right_logical %5260, %5266 : tensor<1xui32> loc(#loc545)
%5268 = mhlo.or %5264, %5267 : tensor<1xui32> loc(#loc558)
%5269 = mhlo.xor %5261, %5268 : tensor<1xui32> loc(#loc554)
%5270 = mhlo.add %5261, %5269 : tensor<1xui32> loc(#loc556)
%5271 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5272 = "mhlo.broadcast_in_dim"(%5271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5273 = mhlo.shift_left %5269, %5272 : tensor<1xui32> loc(#loc557)
%5274 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5275 = "mhlo.broadcast_in_dim"(%5274) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5276 = mhlo.shift_right_logical %5269, %5275 : tensor<1xui32> loc(#loc545)
%5277 = mhlo.or %5273, %5276 : tensor<1xui32> loc(#loc558)
%5278 = mhlo.xor %5270, %5277 : tensor<1xui32> loc(#loc554)
%5279 = mhlo.add %5270, %5278 : tensor<1xui32> loc(#loc556)
%5280 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5281 = "mhlo.broadcast_in_dim"(%5280) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5282 = mhlo.shift_left %5278, %5281 : tensor<1xui32> loc(#loc557)
%5283 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5284 = "mhlo.broadcast_in_dim"(%5283) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5285 = mhlo.shift_right_logical %5278, %5284 : tensor<1xui32> loc(#loc545)
%5286 = mhlo.or %5282, %5285 : tensor<1xui32> loc(#loc558)
%5287 = mhlo.xor %5279, %5286 : tensor<1xui32> loc(#loc554)
%5288 = "mhlo.broadcast_in_dim"(%5242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5289 = mhlo.add %5279, %5288 : tensor<1xui32> loc(#loc556)
%5290 = "mhlo.broadcast_in_dim"(%5247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5291 = mhlo.add %5287, %5290 : tensor<1xui32> loc(#loc556)
%5292 = mhlo.constant dense<1> : tensor<ui32> loc(#loc555)
%5293 = "mhlo.broadcast_in_dim"(%5292) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5294 = mhlo.add %5291, %5293 : tensor<1xui32> loc(#loc556)
%5295 = mhlo.add %5289, %5294 : tensor<1xui32> loc(#loc556)
%5296 = mhlo.constant dense<17> : tensor<ui32> loc(#loc555)
%5297 = "mhlo.broadcast_in_dim"(%5296) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5298 = mhlo.shift_left %5294, %5297 : tensor<1xui32> loc(#loc557)
%5299 = mhlo.constant dense<15> : tensor<ui32> loc(#loc555)
%5300 = "mhlo.broadcast_in_dim"(%5299) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5301 = mhlo.shift_right_logical %5294, %5300 : tensor<1xui32> loc(#loc545)
%5302 = mhlo.or %5298, %5301 : tensor<1xui32> loc(#loc558)
%5303 = mhlo.xor %5295, %5302 : tensor<1xui32> loc(#loc554)
%5304 = mhlo.add %5295, %5303 : tensor<1xui32> loc(#loc556)
%5305 = mhlo.constant dense<29> : tensor<ui32> loc(#loc555)
%5306 = "mhlo.broadcast_in_dim"(%5305) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5307 = mhlo.shift_left %5303, %5306 : tensor<1xui32> loc(#loc557)
%5308 = mhlo.constant dense<3> : tensor<ui32> loc(#loc555)
%5309 = "mhlo.broadcast_in_dim"(%5308) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5310 = mhlo.shift_right_logical %5303, %5309 : tensor<1xui32> loc(#loc545)
%5311 = mhlo.or %5307, %5310 : tensor<1xui32> loc(#loc558)
%5312 = mhlo.xor %5304, %5311 : tensor<1xui32> loc(#loc554)
%5313 = mhlo.add %5304, %5312 : tensor<1xui32> loc(#loc556)
%5314 = mhlo.constant dense<16> : tensor<ui32> loc(#loc555)
%5315 = "mhlo.broadcast_in_dim"(%5314) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5316 = mhlo.shift_left %5312, %5315 : tensor<1xui32> loc(#loc557)
%5317 = mhlo.constant dense<16> : tensor<ui32> loc(#loc555)
%5318 = "mhlo.broadcast_in_dim"(%5317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5319 = mhlo.shift_right_logical %5312, %5318 : tensor<1xui32> loc(#loc545)
%5320 = mhlo.or %5316, %5319 : tensor<1xui32> loc(#loc558)
%5321 = mhlo.xor %5313, %5320 : tensor<1xui32> loc(#loc554)
%5322 = mhlo.add %5313, %5321 : tensor<1xui32> loc(#loc556)
%5323 = mhlo.constant dense<24> : tensor<ui32> loc(#loc555)
%5324 = "mhlo.broadcast_in_dim"(%5323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5325 = mhlo.shift_left %5321, %5324 : tensor<1xui32> loc(#loc557)
%5326 = mhlo.constant dense<8> : tensor<ui32> loc(#loc555)
%5327 = "mhlo.broadcast_in_dim"(%5326) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5328 = mhlo.shift_right_logical %5321, %5327 : tensor<1xui32> loc(#loc545)
%5329 = mhlo.or %5325, %5328 : tensor<1xui32> loc(#loc558)
%5330 = mhlo.xor %5322, %5329 : tensor<1xui32> loc(#loc554)
%5331 = "mhlo.broadcast_in_dim"(%5247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5332 = mhlo.add %5322, %5331 : tensor<1xui32> loc(#loc556)
%5333 = "mhlo.broadcast_in_dim"(%5240) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5334 = mhlo.add %5330, %5333 : tensor<1xui32> loc(#loc556)
%5335 = mhlo.constant dense<2> : tensor<ui32> loc(#loc555)
%5336 = "mhlo.broadcast_in_dim"(%5335) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5337 = mhlo.add %5334, %5336 : tensor<1xui32> loc(#loc556)
%5338 = mhlo.add %5332, %5337 : tensor<1xui32> loc(#loc556)
%5339 = mhlo.constant dense<13> : tensor<ui32> loc(#loc555)
%5340 = "mhlo.broadcast_in_dim"(%5339) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5341 = mhlo.shift_left %5337, %5340 : tensor<1xui32> loc(#loc557)
%5342 = mhlo.constant dense<19> : tensor<ui32> loc(#loc555)
%5343 = "mhlo.broadcast_in_dim"(%5342) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5344 = mhlo.shift_right_logical %5337, %5343 : tensor<1xui32> loc(#loc545)
%5345 = mhlo.or %5341, %5344 : tensor<1xui32> loc(#loc558)
%5346 = mhlo.xor %5338, %5345 : tensor<1xui32> loc(#loc554)
%5347 = mhlo.add %5338, %5346 : tensor<1xui32> loc(#loc556)
%5348 = mhlo.constant dense<15> : tensor<ui32> loc(#loc555)
%5349 = "mhlo.broadcast_in_dim"(%5348) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5350 = mhlo.shift_left %5346, %5349 : tensor<1xui32> loc(#loc557)
%5351 = mhlo.constant dense<17> : tensor<ui32> loc(#loc555)
%5352 = "mhlo.broadcast_in_dim"(%5351) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5353 = mhlo.shift_right_logical %5346, %5352 : tensor<1xui32> loc(#loc545)
%5354 = mhlo.or %5350, %5353 : tensor<1xui32> loc(#loc558)
%5355 = mhlo.xor %5347, %5354 : tensor<1xui32> loc(#loc554)
%5356 = mhlo.add %5347, %5355 : tensor<1xui32> loc(#loc556)
%5357 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5358 = "mhlo.broadcast_in_dim"(%5357) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5359 = mhlo.shift_left %5355, %5358 : tensor<1xui32> loc(#loc557)
%5360 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5361 = "mhlo.broadcast_in_dim"(%5360) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5362 = mhlo.shift_right_logical %5355, %5361 : tensor<1xui32> loc(#loc545)
%5363 = mhlo.or %5359, %5362 : tensor<1xui32> loc(#loc558)
%5364 = mhlo.xor %5356, %5363 : tensor<1xui32> loc(#loc554)
%5365 = mhlo.add %5356, %5364 : tensor<1xui32> loc(#loc556)
%5366 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5367 = "mhlo.broadcast_in_dim"(%5366) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5368 = mhlo.shift_left %5364, %5367 : tensor<1xui32> loc(#loc557)
%5369 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5370 = "mhlo.broadcast_in_dim"(%5369) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5371 = mhlo.shift_right_logical %5364, %5370 : tensor<1xui32> loc(#loc545)
%5372 = mhlo.or %5368, %5371 : tensor<1xui32> loc(#loc558)
%5373 = mhlo.xor %5365, %5372 : tensor<1xui32> loc(#loc554)
%5374 = "mhlo.broadcast_in_dim"(%5240) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5375 = mhlo.add %5365, %5374 : tensor<1xui32> loc(#loc556)
%5376 = "mhlo.broadcast_in_dim"(%5242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5377 = mhlo.add %5373, %5376 : tensor<1xui32> loc(#loc556)
%5378 = mhlo.constant dense<3> : tensor<ui32> loc(#loc555)
%5379 = "mhlo.broadcast_in_dim"(%5378) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5380 = mhlo.add %5377, %5379 : tensor<1xui32> loc(#loc556)
%5381 = mhlo.add %5375, %5380 : tensor<1xui32> loc(#loc556)
%5382 = mhlo.constant dense<17> : tensor<ui32> loc(#loc555)
%5383 = "mhlo.broadcast_in_dim"(%5382) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5384 = mhlo.shift_left %5380, %5383 : tensor<1xui32> loc(#loc557)
%5385 = mhlo.constant dense<15> : tensor<ui32> loc(#loc555)
%5386 = "mhlo.broadcast_in_dim"(%5385) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5387 = mhlo.shift_right_logical %5380, %5386 : tensor<1xui32> loc(#loc545)
%5388 = mhlo.or %5384, %5387 : tensor<1xui32> loc(#loc558)
%5389 = mhlo.xor %5381, %5388 : tensor<1xui32> loc(#loc554)
%5390 = mhlo.add %5381, %5389 : tensor<1xui32> loc(#loc556)
%5391 = mhlo.constant dense<29> : tensor<ui32> loc(#loc555)
%5392 = "mhlo.broadcast_in_dim"(%5391) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5393 = mhlo.shift_left %5389, %5392 : tensor<1xui32> loc(#loc557)
%5394 = mhlo.constant dense<3> : tensor<ui32> loc(#loc555)
%5395 = "mhlo.broadcast_in_dim"(%5394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5396 = mhlo.shift_right_logical %5389, %5395 : tensor<1xui32> loc(#loc545)
%5397 = mhlo.or %5393, %5396 : tensor<1xui32> loc(#loc558)
%5398 = mhlo.xor %5390, %5397 : tensor<1xui32> loc(#loc554)
%5399 = mhlo.add %5390, %5398 : tensor<1xui32> loc(#loc556)
%5400 = mhlo.constant dense<16> : tensor<ui32> loc(#loc555)
%5401 = "mhlo.broadcast_in_dim"(%5400) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5402 = mhlo.shift_left %5398, %5401 : tensor<1xui32> loc(#loc557)
%5403 = mhlo.constant dense<16> : tensor<ui32> loc(#loc555)
%5404 = "mhlo.broadcast_in_dim"(%5403) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5405 = mhlo.shift_right_logical %5398, %5404 : tensor<1xui32> loc(#loc545)
%5406 = mhlo.or %5402, %5405 : tensor<1xui32> loc(#loc558)
%5407 = mhlo.xor %5399, %5406 : tensor<1xui32> loc(#loc554)
%5408 = mhlo.add %5399, %5407 : tensor<1xui32> loc(#loc556)
%5409 = mhlo.constant dense<24> : tensor<ui32> loc(#loc555)
%5410 = "mhlo.broadcast_in_dim"(%5409) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5411 = mhlo.shift_left %5407, %5410 : tensor<1xui32> loc(#loc557)
%5412 = mhlo.constant dense<8> : tensor<ui32> loc(#loc555)
%5413 = "mhlo.broadcast_in_dim"(%5412) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5414 = mhlo.shift_right_logical %5407, %5413 : tensor<1xui32> loc(#loc545)
%5415 = mhlo.or %5411, %5414 : tensor<1xui32> loc(#loc558)
%5416 = mhlo.xor %5408, %5415 : tensor<1xui32> loc(#loc554)
%5417 = "mhlo.broadcast_in_dim"(%5242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5418 = mhlo.add %5408, %5417 : tensor<1xui32> loc(#loc556)
%5419 = "mhlo.broadcast_in_dim"(%5247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5420 = mhlo.add %5416, %5419 : tensor<1xui32> loc(#loc556)
%5421 = mhlo.constant dense<4> : tensor<ui32> loc(#loc555)
%5422 = "mhlo.broadcast_in_dim"(%5421) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5423 = mhlo.add %5420, %5422 : tensor<1xui32> loc(#loc556)
%5424 = mhlo.add %5418, %5423 : tensor<1xui32> loc(#loc556)
%5425 = mhlo.constant dense<13> : tensor<ui32> loc(#loc555)
%5426 = "mhlo.broadcast_in_dim"(%5425) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5427 = mhlo.shift_left %5423, %5426 : tensor<1xui32> loc(#loc557)
%5428 = mhlo.constant dense<19> : tensor<ui32> loc(#loc555)
%5429 = "mhlo.broadcast_in_dim"(%5428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5430 = mhlo.shift_right_logical %5423, %5429 : tensor<1xui32> loc(#loc545)
%5431 = mhlo.or %5427, %5430 : tensor<1xui32> loc(#loc558)
%5432 = mhlo.xor %5424, %5431 : tensor<1xui32> loc(#loc554)
%5433 = mhlo.add %5424, %5432 : tensor<1xui32> loc(#loc556)
%5434 = mhlo.constant dense<15> : tensor<ui32> loc(#loc555)
%5435 = "mhlo.broadcast_in_dim"(%5434) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5436 = mhlo.shift_left %5432, %5435 : tensor<1xui32> loc(#loc557)
%5437 = mhlo.constant dense<17> : tensor<ui32> loc(#loc555)
%5438 = "mhlo.broadcast_in_dim"(%5437) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5439 = mhlo.shift_right_logical %5432, %5438 : tensor<1xui32> loc(#loc545)
%5440 = mhlo.or %5436, %5439 : tensor<1xui32> loc(#loc558)
%5441 = mhlo.xor %5433, %5440 : tensor<1xui32> loc(#loc554)
%5442 = mhlo.add %5433, %5441 : tensor<1xui32> loc(#loc556)
%5443 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5444 = "mhlo.broadcast_in_dim"(%5443) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5445 = mhlo.shift_left %5441, %5444 : tensor<1xui32> loc(#loc557)
%5446 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5447 = "mhlo.broadcast_in_dim"(%5446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5448 = mhlo.shift_right_logical %5441, %5447 : tensor<1xui32> loc(#loc545)
%5449 = mhlo.or %5445, %5448 : tensor<1xui32> loc(#loc558)
%5450 = mhlo.xor %5442, %5449 : tensor<1xui32> loc(#loc554)
%5451 = mhlo.add %5442, %5450 : tensor<1xui32> loc(#loc556)
%5452 = mhlo.constant dense<6> : tensor<ui32> loc(#loc555)
%5453 = "mhlo.broadcast_in_dim"(%5452) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc557)
%5454 = mhlo.shift_left %5450, %5453 : tensor<1xui32> loc(#loc557)
%5455 = mhlo.constant dense<26> : tensor<ui32> loc(#loc555)
%5456 = "mhlo.broadcast_in_dim"(%5455) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc545)
%5457 = mhlo.shift_right_logical %5450, %5456 : tensor<1xui32> loc(#loc545)
%5458 = mhlo.or %5454, %5457 : tensor<1xui32> loc(#loc558)
%5459 = mhlo.xor %5451, %5458 : tensor<1xui32> loc(#loc554)
%5460 = "mhlo.broadcast_in_dim"(%5247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5461 = mhlo.add %5451, %5460 : tensor<1xui32> loc(#loc556)
%5462 = "mhlo.broadcast_in_dim"(%5240) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5463 = mhlo.add %5459, %5462 : tensor<1xui32> loc(#loc556)
%5464 = mhlo.constant dense<5> : tensor<ui32> loc(#loc555)
%5465 = "mhlo.broadcast_in_dim"(%5464) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc556)
%5466 = mhlo.add %5463, %5465 : tensor<1xui32> loc(#loc556)
%5467 = "mhlo.concatenate"(%5461, %5466) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc548)
%5468 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%5469 = "mhlo.broadcast_in_dim"(%5468) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc559)
%5470 = "mhlo.reshape"(%5469) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc560)
%5471 = "mhlo.broadcast_in_dim"(%5470) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc561)
%5472 = mhlo.add %5230, %5471 : tensor<1x256x2048xf32> loc(#loc561)
%5473 = mhlo.convert(%5472) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc562)
%5474 = mhlo.constant dense<true> : tensor<i1> loc(#loc531)
%5475 = "mhlo.broadcast_in_dim"(%5474) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i1>) -> tensor<1x256xi1> loc(#loc563)
%5476 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<256xi32> loc(#loc564)
%5477 = "mhlo.broadcast_in_dim"(%5476) {broadcast_dimensions = dense<1> : tensor<1xi64>} : (tensor<256xi32>) -> tensor<1x256xi32> loc(#loc565)
%5478 = "mhlo.broadcast_in_dim"(%5477) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x256xi32>) -> tensor<1x256x1xi32> loc(#loc566)
%5479 = "mhlo.broadcast_in_dim"(%5477) {broadcast_dimensions = dense<[0, 2]> : tensor<2xi64>} : (tensor<1x256xi32>) -> tensor<1x1x256xi32> loc(#loc567)
%5480 = "mhlo.broadcast_in_dim"(%5478) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xi32>) -> tensor<1x256x256xi32> loc(#loc568)
%5481 = "mhlo.broadcast_in_dim"(%5479) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x256xi32>) -> tensor<1x256x256xi32> loc(#loc568)
%5482 = "mhlo.compare"(%5480, %5481) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction GE">} : (tensor<1x256x256xi32>, tensor<1x256x256xi32>) -> tensor<1x256x256xi1> loc(#loc568)
%5483 = "mhlo.broadcast_in_dim"(%5482) {broadcast_dimensions = dense<[0, 2, 3]> : tensor<3xi64>} : (tensor<1x256x256xi1>) -> tensor<1x1x256x256xi1> loc(#loc569)
%5484 = mhlo.constant dense<2728363194> : tensor<ui32> loc(#loc531)
%5485 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%5486 = mhlo.shift_right_logical %5484, %5485 : tensor<ui32> loc(#loc570)
%5487 = "mhlo.reshape"(%5486) : (tensor<ui32>) -> tensor<1xui32> loc(#loc571)
%5488 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%5489 = mhlo.and %5484, %5488 : tensor<ui32> loc(#loc572)
%5490 = "mhlo.reshape"(%5489) : (tensor<ui32>) -> tensor<1xui32> loc(#loc571)
%5491 = "mhlo.concatenate"(%5487, %5490) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc573)
%5492 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc574)
%5493 = "mhlo.reshape"(%5492) : (tensor<1xui32>) -> tensor<ui32> loc(#loc575)
%5494 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc576)
%5495 = "mhlo.reshape"(%5494) : (tensor<1xui32>) -> tensor<ui32> loc(#loc575)
%5496 = "mhlo.slice"(%5491) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc577)
%5497 = "mhlo.slice"(%5491) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc578)
%5498 = mhlo.xor %5493, %5495 : tensor<ui32> loc(#loc579)
%5499 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc580)
%5500 = mhlo.xor %5498, %5499 : tensor<ui32> loc(#loc579)
%5501 = "mhlo.broadcast_in_dim"(%5493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5502 = mhlo.add %5496, %5501 : tensor<1xui32> loc(#loc581)
%5503 = "mhlo.broadcast_in_dim"(%5495) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5504 = mhlo.add %5497, %5503 : tensor<1xui32> loc(#loc581)
%5505 = mhlo.add %5502, %5504 : tensor<1xui32> loc(#loc581)
%5506 = mhlo.constant dense<13> : tensor<ui32> loc(#loc580)
%5507 = "mhlo.broadcast_in_dim"(%5506) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5508 = mhlo.shift_left %5504, %5507 : tensor<1xui32> loc(#loc582)
%5509 = mhlo.constant dense<19> : tensor<ui32> loc(#loc580)
%5510 = "mhlo.broadcast_in_dim"(%5509) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5511 = mhlo.shift_right_logical %5504, %5510 : tensor<1xui32> loc(#loc570)
%5512 = mhlo.or %5508, %5511 : tensor<1xui32> loc(#loc583)
%5513 = mhlo.xor %5505, %5512 : tensor<1xui32> loc(#loc579)
%5514 = mhlo.add %5505, %5513 : tensor<1xui32> loc(#loc581)
%5515 = mhlo.constant dense<15> : tensor<ui32> loc(#loc580)
%5516 = "mhlo.broadcast_in_dim"(%5515) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5517 = mhlo.shift_left %5513, %5516 : tensor<1xui32> loc(#loc582)
%5518 = mhlo.constant dense<17> : tensor<ui32> loc(#loc580)
%5519 = "mhlo.broadcast_in_dim"(%5518) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5520 = mhlo.shift_right_logical %5513, %5519 : tensor<1xui32> loc(#loc570)
%5521 = mhlo.or %5517, %5520 : tensor<1xui32> loc(#loc583)
%5522 = mhlo.xor %5514, %5521 : tensor<1xui32> loc(#loc579)
%5523 = mhlo.add %5514, %5522 : tensor<1xui32> loc(#loc581)
%5524 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5525 = "mhlo.broadcast_in_dim"(%5524) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5526 = mhlo.shift_left %5522, %5525 : tensor<1xui32> loc(#loc582)
%5527 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5528 = "mhlo.broadcast_in_dim"(%5527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5529 = mhlo.shift_right_logical %5522, %5528 : tensor<1xui32> loc(#loc570)
%5530 = mhlo.or %5526, %5529 : tensor<1xui32> loc(#loc583)
%5531 = mhlo.xor %5523, %5530 : tensor<1xui32> loc(#loc579)
%5532 = mhlo.add %5523, %5531 : tensor<1xui32> loc(#loc581)
%5533 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5534 = "mhlo.broadcast_in_dim"(%5533) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5535 = mhlo.shift_left %5531, %5534 : tensor<1xui32> loc(#loc582)
%5536 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5537 = "mhlo.broadcast_in_dim"(%5536) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5538 = mhlo.shift_right_logical %5531, %5537 : tensor<1xui32> loc(#loc570)
%5539 = mhlo.or %5535, %5538 : tensor<1xui32> loc(#loc583)
%5540 = mhlo.xor %5532, %5539 : tensor<1xui32> loc(#loc579)
%5541 = "mhlo.broadcast_in_dim"(%5495) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5542 = mhlo.add %5532, %5541 : tensor<1xui32> loc(#loc581)
%5543 = "mhlo.broadcast_in_dim"(%5500) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5544 = mhlo.add %5540, %5543 : tensor<1xui32> loc(#loc581)
%5545 = mhlo.constant dense<1> : tensor<ui32> loc(#loc580)
%5546 = "mhlo.broadcast_in_dim"(%5545) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5547 = mhlo.add %5544, %5546 : tensor<1xui32> loc(#loc581)
%5548 = mhlo.add %5542, %5547 : tensor<1xui32> loc(#loc581)
%5549 = mhlo.constant dense<17> : tensor<ui32> loc(#loc580)
%5550 = "mhlo.broadcast_in_dim"(%5549) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5551 = mhlo.shift_left %5547, %5550 : tensor<1xui32> loc(#loc582)
%5552 = mhlo.constant dense<15> : tensor<ui32> loc(#loc580)
%5553 = "mhlo.broadcast_in_dim"(%5552) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5554 = mhlo.shift_right_logical %5547, %5553 : tensor<1xui32> loc(#loc570)
%5555 = mhlo.or %5551, %5554 : tensor<1xui32> loc(#loc583)
%5556 = mhlo.xor %5548, %5555 : tensor<1xui32> loc(#loc579)
%5557 = mhlo.add %5548, %5556 : tensor<1xui32> loc(#loc581)
%5558 = mhlo.constant dense<29> : tensor<ui32> loc(#loc580)
%5559 = "mhlo.broadcast_in_dim"(%5558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5560 = mhlo.shift_left %5556, %5559 : tensor<1xui32> loc(#loc582)
%5561 = mhlo.constant dense<3> : tensor<ui32> loc(#loc580)
%5562 = "mhlo.broadcast_in_dim"(%5561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5563 = mhlo.shift_right_logical %5556, %5562 : tensor<1xui32> loc(#loc570)
%5564 = mhlo.or %5560, %5563 : tensor<1xui32> loc(#loc583)
%5565 = mhlo.xor %5557, %5564 : tensor<1xui32> loc(#loc579)
%5566 = mhlo.add %5557, %5565 : tensor<1xui32> loc(#loc581)
%5567 = mhlo.constant dense<16> : tensor<ui32> loc(#loc580)
%5568 = "mhlo.broadcast_in_dim"(%5567) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5569 = mhlo.shift_left %5565, %5568 : tensor<1xui32> loc(#loc582)
%5570 = mhlo.constant dense<16> : tensor<ui32> loc(#loc580)
%5571 = "mhlo.broadcast_in_dim"(%5570) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5572 = mhlo.shift_right_logical %5565, %5571 : tensor<1xui32> loc(#loc570)
%5573 = mhlo.or %5569, %5572 : tensor<1xui32> loc(#loc583)
%5574 = mhlo.xor %5566, %5573 : tensor<1xui32> loc(#loc579)
%5575 = mhlo.add %5566, %5574 : tensor<1xui32> loc(#loc581)
%5576 = mhlo.constant dense<24> : tensor<ui32> loc(#loc580)
%5577 = "mhlo.broadcast_in_dim"(%5576) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5578 = mhlo.shift_left %5574, %5577 : tensor<1xui32> loc(#loc582)
%5579 = mhlo.constant dense<8> : tensor<ui32> loc(#loc580)
%5580 = "mhlo.broadcast_in_dim"(%5579) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5581 = mhlo.shift_right_logical %5574, %5580 : tensor<1xui32> loc(#loc570)
%5582 = mhlo.or %5578, %5581 : tensor<1xui32> loc(#loc583)
%5583 = mhlo.xor %5575, %5582 : tensor<1xui32> loc(#loc579)
%5584 = "mhlo.broadcast_in_dim"(%5500) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5585 = mhlo.add %5575, %5584 : tensor<1xui32> loc(#loc581)
%5586 = "mhlo.broadcast_in_dim"(%5493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5587 = mhlo.add %5583, %5586 : tensor<1xui32> loc(#loc581)
%5588 = mhlo.constant dense<2> : tensor<ui32> loc(#loc580)
%5589 = "mhlo.broadcast_in_dim"(%5588) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5590 = mhlo.add %5587, %5589 : tensor<1xui32> loc(#loc581)
%5591 = mhlo.add %5585, %5590 : tensor<1xui32> loc(#loc581)
%5592 = mhlo.constant dense<13> : tensor<ui32> loc(#loc580)
%5593 = "mhlo.broadcast_in_dim"(%5592) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5594 = mhlo.shift_left %5590, %5593 : tensor<1xui32> loc(#loc582)
%5595 = mhlo.constant dense<19> : tensor<ui32> loc(#loc580)
%5596 = "mhlo.broadcast_in_dim"(%5595) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5597 = mhlo.shift_right_logical %5590, %5596 : tensor<1xui32> loc(#loc570)
%5598 = mhlo.or %5594, %5597 : tensor<1xui32> loc(#loc583)
%5599 = mhlo.xor %5591, %5598 : tensor<1xui32> loc(#loc579)
%5600 = mhlo.add %5591, %5599 : tensor<1xui32> loc(#loc581)
%5601 = mhlo.constant dense<15> : tensor<ui32> loc(#loc580)
%5602 = "mhlo.broadcast_in_dim"(%5601) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5603 = mhlo.shift_left %5599, %5602 : tensor<1xui32> loc(#loc582)
%5604 = mhlo.constant dense<17> : tensor<ui32> loc(#loc580)
%5605 = "mhlo.broadcast_in_dim"(%5604) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5606 = mhlo.shift_right_logical %5599, %5605 : tensor<1xui32> loc(#loc570)
%5607 = mhlo.or %5603, %5606 : tensor<1xui32> loc(#loc583)
%5608 = mhlo.xor %5600, %5607 : tensor<1xui32> loc(#loc579)
%5609 = mhlo.add %5600, %5608 : tensor<1xui32> loc(#loc581)
%5610 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5611 = "mhlo.broadcast_in_dim"(%5610) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5612 = mhlo.shift_left %5608, %5611 : tensor<1xui32> loc(#loc582)
%5613 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5614 = "mhlo.broadcast_in_dim"(%5613) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5615 = mhlo.shift_right_logical %5608, %5614 : tensor<1xui32> loc(#loc570)
%5616 = mhlo.or %5612, %5615 : tensor<1xui32> loc(#loc583)
%5617 = mhlo.xor %5609, %5616 : tensor<1xui32> loc(#loc579)
%5618 = mhlo.add %5609, %5617 : tensor<1xui32> loc(#loc581)
%5619 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5620 = "mhlo.broadcast_in_dim"(%5619) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5621 = mhlo.shift_left %5617, %5620 : tensor<1xui32> loc(#loc582)
%5622 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5623 = "mhlo.broadcast_in_dim"(%5622) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5624 = mhlo.shift_right_logical %5617, %5623 : tensor<1xui32> loc(#loc570)
%5625 = mhlo.or %5621, %5624 : tensor<1xui32> loc(#loc583)
%5626 = mhlo.xor %5618, %5625 : tensor<1xui32> loc(#loc579)
%5627 = "mhlo.broadcast_in_dim"(%5493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5628 = mhlo.add %5618, %5627 : tensor<1xui32> loc(#loc581)
%5629 = "mhlo.broadcast_in_dim"(%5495) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5630 = mhlo.add %5626, %5629 : tensor<1xui32> loc(#loc581)
%5631 = mhlo.constant dense<3> : tensor<ui32> loc(#loc580)
%5632 = "mhlo.broadcast_in_dim"(%5631) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5633 = mhlo.add %5630, %5632 : tensor<1xui32> loc(#loc581)
%5634 = mhlo.add %5628, %5633 : tensor<1xui32> loc(#loc581)
%5635 = mhlo.constant dense<17> : tensor<ui32> loc(#loc580)
%5636 = "mhlo.broadcast_in_dim"(%5635) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5637 = mhlo.shift_left %5633, %5636 : tensor<1xui32> loc(#loc582)
%5638 = mhlo.constant dense<15> : tensor<ui32> loc(#loc580)
%5639 = "mhlo.broadcast_in_dim"(%5638) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5640 = mhlo.shift_right_logical %5633, %5639 : tensor<1xui32> loc(#loc570)
%5641 = mhlo.or %5637, %5640 : tensor<1xui32> loc(#loc583)
%5642 = mhlo.xor %5634, %5641 : tensor<1xui32> loc(#loc579)
%5643 = mhlo.add %5634, %5642 : tensor<1xui32> loc(#loc581)
%5644 = mhlo.constant dense<29> : tensor<ui32> loc(#loc580)
%5645 = "mhlo.broadcast_in_dim"(%5644) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5646 = mhlo.shift_left %5642, %5645 : tensor<1xui32> loc(#loc582)
%5647 = mhlo.constant dense<3> : tensor<ui32> loc(#loc580)
%5648 = "mhlo.broadcast_in_dim"(%5647) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5649 = mhlo.shift_right_logical %5642, %5648 : tensor<1xui32> loc(#loc570)
%5650 = mhlo.or %5646, %5649 : tensor<1xui32> loc(#loc583)
%5651 = mhlo.xor %5643, %5650 : tensor<1xui32> loc(#loc579)
%5652 = mhlo.add %5643, %5651 : tensor<1xui32> loc(#loc581)
%5653 = mhlo.constant dense<16> : tensor<ui32> loc(#loc580)
%5654 = "mhlo.broadcast_in_dim"(%5653) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5655 = mhlo.shift_left %5651, %5654 : tensor<1xui32> loc(#loc582)
%5656 = mhlo.constant dense<16> : tensor<ui32> loc(#loc580)
%5657 = "mhlo.broadcast_in_dim"(%5656) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5658 = mhlo.shift_right_logical %5651, %5657 : tensor<1xui32> loc(#loc570)
%5659 = mhlo.or %5655, %5658 : tensor<1xui32> loc(#loc583)
%5660 = mhlo.xor %5652, %5659 : tensor<1xui32> loc(#loc579)
%5661 = mhlo.add %5652, %5660 : tensor<1xui32> loc(#loc581)
%5662 = mhlo.constant dense<24> : tensor<ui32> loc(#loc580)
%5663 = "mhlo.broadcast_in_dim"(%5662) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5664 = mhlo.shift_left %5660, %5663 : tensor<1xui32> loc(#loc582)
%5665 = mhlo.constant dense<8> : tensor<ui32> loc(#loc580)
%5666 = "mhlo.broadcast_in_dim"(%5665) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5667 = mhlo.shift_right_logical %5660, %5666 : tensor<1xui32> loc(#loc570)
%5668 = mhlo.or %5664, %5667 : tensor<1xui32> loc(#loc583)
%5669 = mhlo.xor %5661, %5668 : tensor<1xui32> loc(#loc579)
%5670 = "mhlo.broadcast_in_dim"(%5495) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5671 = mhlo.add %5661, %5670 : tensor<1xui32> loc(#loc581)
%5672 = "mhlo.broadcast_in_dim"(%5500) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5673 = mhlo.add %5669, %5672 : tensor<1xui32> loc(#loc581)
%5674 = mhlo.constant dense<4> : tensor<ui32> loc(#loc580)
%5675 = "mhlo.broadcast_in_dim"(%5674) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5676 = mhlo.add %5673, %5675 : tensor<1xui32> loc(#loc581)
%5677 = mhlo.add %5671, %5676 : tensor<1xui32> loc(#loc581)
%5678 = mhlo.constant dense<13> : tensor<ui32> loc(#loc580)
%5679 = "mhlo.broadcast_in_dim"(%5678) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5680 = mhlo.shift_left %5676, %5679 : tensor<1xui32> loc(#loc582)
%5681 = mhlo.constant dense<19> : tensor<ui32> loc(#loc580)
%5682 = "mhlo.broadcast_in_dim"(%5681) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5683 = mhlo.shift_right_logical %5676, %5682 : tensor<1xui32> loc(#loc570)
%5684 = mhlo.or %5680, %5683 : tensor<1xui32> loc(#loc583)
%5685 = mhlo.xor %5677, %5684 : tensor<1xui32> loc(#loc579)
%5686 = mhlo.add %5677, %5685 : tensor<1xui32> loc(#loc581)
%5687 = mhlo.constant dense<15> : tensor<ui32> loc(#loc580)
%5688 = "mhlo.broadcast_in_dim"(%5687) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5689 = mhlo.shift_left %5685, %5688 : tensor<1xui32> loc(#loc582)
%5690 = mhlo.constant dense<17> : tensor<ui32> loc(#loc580)
%5691 = "mhlo.broadcast_in_dim"(%5690) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5692 = mhlo.shift_right_logical %5685, %5691 : tensor<1xui32> loc(#loc570)
%5693 = mhlo.or %5689, %5692 : tensor<1xui32> loc(#loc583)
%5694 = mhlo.xor %5686, %5693 : tensor<1xui32> loc(#loc579)
%5695 = mhlo.add %5686, %5694 : tensor<1xui32> loc(#loc581)
%5696 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5697 = "mhlo.broadcast_in_dim"(%5696) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5698 = mhlo.shift_left %5694, %5697 : tensor<1xui32> loc(#loc582)
%5699 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5700 = "mhlo.broadcast_in_dim"(%5699) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5701 = mhlo.shift_right_logical %5694, %5700 : tensor<1xui32> loc(#loc570)
%5702 = mhlo.or %5698, %5701 : tensor<1xui32> loc(#loc583)
%5703 = mhlo.xor %5695, %5702 : tensor<1xui32> loc(#loc579)
%5704 = mhlo.add %5695, %5703 : tensor<1xui32> loc(#loc581)
%5705 = mhlo.constant dense<6> : tensor<ui32> loc(#loc580)
%5706 = "mhlo.broadcast_in_dim"(%5705) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc582)
%5707 = mhlo.shift_left %5703, %5706 : tensor<1xui32> loc(#loc582)
%5708 = mhlo.constant dense<26> : tensor<ui32> loc(#loc580)
%5709 = "mhlo.broadcast_in_dim"(%5708) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc570)
%5710 = mhlo.shift_right_logical %5703, %5709 : tensor<1xui32> loc(#loc570)
%5711 = mhlo.or %5707, %5710 : tensor<1xui32> loc(#loc583)
%5712 = mhlo.xor %5704, %5711 : tensor<1xui32> loc(#loc579)
%5713 = "mhlo.broadcast_in_dim"(%5500) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5714 = mhlo.add %5704, %5713 : tensor<1xui32> loc(#loc581)
%5715 = "mhlo.broadcast_in_dim"(%5493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5716 = mhlo.add %5712, %5715 : tensor<1xui32> loc(#loc581)
%5717 = mhlo.constant dense<5> : tensor<ui32> loc(#loc580)
%5718 = "mhlo.broadcast_in_dim"(%5717) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc581)
%5719 = mhlo.add %5716, %5718 : tensor<1xui32> loc(#loc581)
%5720 = "mhlo.concatenate"(%5714, %5719) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc573)
%5721 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%5722 = "mhlo.broadcast_in_dim"(%5721) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc584)
%5723 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%5724 = "mhlo.broadcast_in_dim"(%5723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc584)
%5725 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc585)
%5726 = "mhlo.slice"(%5720) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc586)
%5727 = "mhlo.reshape"(%5726) : (tensor<1xui32>) -> tensor<ui32> loc(#loc587)
%5728 = "mhlo.slice"(%5720) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc588)
%5729 = "mhlo.reshape"(%5728) : (tensor<1xui32>) -> tensor<ui32> loc(#loc587)
%5730 = "mhlo.slice"(%5725) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc589)
%5731 = "mhlo.slice"(%5725) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc590)
%5732 = mhlo.xor %5727, %5729 : tensor<ui32> loc(#loc591)
%5733 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc592)
%5734 = mhlo.xor %5732, %5733 : tensor<ui32> loc(#loc591)
%5735 = "mhlo.broadcast_in_dim"(%5727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5736 = mhlo.add %5730, %5735 : tensor<2097152xui32> loc(#loc593)
%5737 = "mhlo.broadcast_in_dim"(%5729) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5738 = mhlo.add %5731, %5737 : tensor<2097152xui32> loc(#loc593)
%5739 = mhlo.add %5736, %5738 : tensor<2097152xui32> loc(#loc593)
%5740 = mhlo.constant dense<13> : tensor<ui32> loc(#loc592)
%5741 = "mhlo.broadcast_in_dim"(%5740) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5742 = mhlo.shift_left %5738, %5741 : tensor<2097152xui32> loc(#loc594)
%5743 = mhlo.constant dense<19> : tensor<ui32> loc(#loc592)
%5744 = "mhlo.broadcast_in_dim"(%5743) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5745 = mhlo.shift_right_logical %5738, %5744 : tensor<2097152xui32> loc(#loc595)
%5746 = mhlo.or %5742, %5745 : tensor<2097152xui32> loc(#loc596)
%5747 = mhlo.xor %5739, %5746 : tensor<2097152xui32> loc(#loc591)
%5748 = mhlo.add %5739, %5747 : tensor<2097152xui32> loc(#loc593)
%5749 = mhlo.constant dense<15> : tensor<ui32> loc(#loc592)
%5750 = "mhlo.broadcast_in_dim"(%5749) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5751 = mhlo.shift_left %5747, %5750 : tensor<2097152xui32> loc(#loc594)
%5752 = mhlo.constant dense<17> : tensor<ui32> loc(#loc592)
%5753 = "mhlo.broadcast_in_dim"(%5752) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5754 = mhlo.shift_right_logical %5747, %5753 : tensor<2097152xui32> loc(#loc595)
%5755 = mhlo.or %5751, %5754 : tensor<2097152xui32> loc(#loc596)
%5756 = mhlo.xor %5748, %5755 : tensor<2097152xui32> loc(#loc591)
%5757 = mhlo.add %5748, %5756 : tensor<2097152xui32> loc(#loc593)
%5758 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5759 = "mhlo.broadcast_in_dim"(%5758) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5760 = mhlo.shift_left %5756, %5759 : tensor<2097152xui32> loc(#loc594)
%5761 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5762 = "mhlo.broadcast_in_dim"(%5761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5763 = mhlo.shift_right_logical %5756, %5762 : tensor<2097152xui32> loc(#loc595)
%5764 = mhlo.or %5760, %5763 : tensor<2097152xui32> loc(#loc596)
%5765 = mhlo.xor %5757, %5764 : tensor<2097152xui32> loc(#loc591)
%5766 = mhlo.add %5757, %5765 : tensor<2097152xui32> loc(#loc593)
%5767 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5768 = "mhlo.broadcast_in_dim"(%5767) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5769 = mhlo.shift_left %5765, %5768 : tensor<2097152xui32> loc(#loc594)
%5770 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5771 = "mhlo.broadcast_in_dim"(%5770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5772 = mhlo.shift_right_logical %5765, %5771 : tensor<2097152xui32> loc(#loc595)
%5773 = mhlo.or %5769, %5772 : tensor<2097152xui32> loc(#loc596)
%5774 = mhlo.xor %5766, %5773 : tensor<2097152xui32> loc(#loc591)
%5775 = "mhlo.broadcast_in_dim"(%5729) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5776 = mhlo.add %5766, %5775 : tensor<2097152xui32> loc(#loc593)
%5777 = "mhlo.broadcast_in_dim"(%5734) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5778 = mhlo.add %5774, %5777 : tensor<2097152xui32> loc(#loc593)
%5779 = mhlo.constant dense<1> : tensor<ui32> loc(#loc592)
%5780 = "mhlo.broadcast_in_dim"(%5779) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5781 = mhlo.add %5778, %5780 : tensor<2097152xui32> loc(#loc593)
%5782 = mhlo.add %5776, %5781 : tensor<2097152xui32> loc(#loc593)
%5783 = mhlo.constant dense<17> : tensor<ui32> loc(#loc592)
%5784 = "mhlo.broadcast_in_dim"(%5783) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5785 = mhlo.shift_left %5781, %5784 : tensor<2097152xui32> loc(#loc594)
%5786 = mhlo.constant dense<15> : tensor<ui32> loc(#loc592)
%5787 = "mhlo.broadcast_in_dim"(%5786) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5788 = mhlo.shift_right_logical %5781, %5787 : tensor<2097152xui32> loc(#loc595)
%5789 = mhlo.or %5785, %5788 : tensor<2097152xui32> loc(#loc596)
%5790 = mhlo.xor %5782, %5789 : tensor<2097152xui32> loc(#loc591)
%5791 = mhlo.add %5782, %5790 : tensor<2097152xui32> loc(#loc593)
%5792 = mhlo.constant dense<29> : tensor<ui32> loc(#loc592)
%5793 = "mhlo.broadcast_in_dim"(%5792) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5794 = mhlo.shift_left %5790, %5793 : tensor<2097152xui32> loc(#loc594)
%5795 = mhlo.constant dense<3> : tensor<ui32> loc(#loc592)
%5796 = "mhlo.broadcast_in_dim"(%5795) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5797 = mhlo.shift_right_logical %5790, %5796 : tensor<2097152xui32> loc(#loc595)
%5798 = mhlo.or %5794, %5797 : tensor<2097152xui32> loc(#loc596)
%5799 = mhlo.xor %5791, %5798 : tensor<2097152xui32> loc(#loc591)
%5800 = mhlo.add %5791, %5799 : tensor<2097152xui32> loc(#loc593)
%5801 = mhlo.constant dense<16> : tensor<ui32> loc(#loc592)
%5802 = "mhlo.broadcast_in_dim"(%5801) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5803 = mhlo.shift_left %5799, %5802 : tensor<2097152xui32> loc(#loc594)
%5804 = mhlo.constant dense<16> : tensor<ui32> loc(#loc592)
%5805 = "mhlo.broadcast_in_dim"(%5804) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5806 = mhlo.shift_right_logical %5799, %5805 : tensor<2097152xui32> loc(#loc595)
%5807 = mhlo.or %5803, %5806 : tensor<2097152xui32> loc(#loc596)
%5808 = mhlo.xor %5800, %5807 : tensor<2097152xui32> loc(#loc591)
%5809 = mhlo.add %5800, %5808 : tensor<2097152xui32> loc(#loc593)
%5810 = mhlo.constant dense<24> : tensor<ui32> loc(#loc592)
%5811 = "mhlo.broadcast_in_dim"(%5810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5812 = mhlo.shift_left %5808, %5811 : tensor<2097152xui32> loc(#loc594)
%5813 = mhlo.constant dense<8> : tensor<ui32> loc(#loc592)
%5814 = "mhlo.broadcast_in_dim"(%5813) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5815 = mhlo.shift_right_logical %5808, %5814 : tensor<2097152xui32> loc(#loc595)
%5816 = mhlo.or %5812, %5815 : tensor<2097152xui32> loc(#loc596)
%5817 = mhlo.xor %5809, %5816 : tensor<2097152xui32> loc(#loc591)
%5818 = "mhlo.broadcast_in_dim"(%5734) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5819 = mhlo.add %5809, %5818 : tensor<2097152xui32> loc(#loc593)
%5820 = "mhlo.broadcast_in_dim"(%5727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5821 = mhlo.add %5817, %5820 : tensor<2097152xui32> loc(#loc593)
%5822 = mhlo.constant dense<2> : tensor<ui32> loc(#loc592)
%5823 = "mhlo.broadcast_in_dim"(%5822) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5824 = mhlo.add %5821, %5823 : tensor<2097152xui32> loc(#loc593)
%5825 = mhlo.add %5819, %5824 : tensor<2097152xui32> loc(#loc593)
%5826 = mhlo.constant dense<13> : tensor<ui32> loc(#loc592)
%5827 = "mhlo.broadcast_in_dim"(%5826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5828 = mhlo.shift_left %5824, %5827 : tensor<2097152xui32> loc(#loc594)
%5829 = mhlo.constant dense<19> : tensor<ui32> loc(#loc592)
%5830 = "mhlo.broadcast_in_dim"(%5829) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5831 = mhlo.shift_right_logical %5824, %5830 : tensor<2097152xui32> loc(#loc595)
%5832 = mhlo.or %5828, %5831 : tensor<2097152xui32> loc(#loc596)
%5833 = mhlo.xor %5825, %5832 : tensor<2097152xui32> loc(#loc591)
%5834 = mhlo.add %5825, %5833 : tensor<2097152xui32> loc(#loc593)
%5835 = mhlo.constant dense<15> : tensor<ui32> loc(#loc592)
%5836 = "mhlo.broadcast_in_dim"(%5835) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5837 = mhlo.shift_left %5833, %5836 : tensor<2097152xui32> loc(#loc594)
%5838 = mhlo.constant dense<17> : tensor<ui32> loc(#loc592)
%5839 = "mhlo.broadcast_in_dim"(%5838) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5840 = mhlo.shift_right_logical %5833, %5839 : tensor<2097152xui32> loc(#loc595)
%5841 = mhlo.or %5837, %5840 : tensor<2097152xui32> loc(#loc596)
%5842 = mhlo.xor %5834, %5841 : tensor<2097152xui32> loc(#loc591)
%5843 = mhlo.add %5834, %5842 : tensor<2097152xui32> loc(#loc593)
%5844 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5845 = "mhlo.broadcast_in_dim"(%5844) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5846 = mhlo.shift_left %5842, %5845 : tensor<2097152xui32> loc(#loc594)
%5847 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5848 = "mhlo.broadcast_in_dim"(%5847) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5849 = mhlo.shift_right_logical %5842, %5848 : tensor<2097152xui32> loc(#loc595)
%5850 = mhlo.or %5846, %5849 : tensor<2097152xui32> loc(#loc596)
%5851 = mhlo.xor %5843, %5850 : tensor<2097152xui32> loc(#loc591)
%5852 = mhlo.add %5843, %5851 : tensor<2097152xui32> loc(#loc593)
%5853 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5854 = "mhlo.broadcast_in_dim"(%5853) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5855 = mhlo.shift_left %5851, %5854 : tensor<2097152xui32> loc(#loc594)
%5856 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5857 = "mhlo.broadcast_in_dim"(%5856) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5858 = mhlo.shift_right_logical %5851, %5857 : tensor<2097152xui32> loc(#loc595)
%5859 = mhlo.or %5855, %5858 : tensor<2097152xui32> loc(#loc596)
%5860 = mhlo.xor %5852, %5859 : tensor<2097152xui32> loc(#loc591)
%5861 = "mhlo.broadcast_in_dim"(%5727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5862 = mhlo.add %5852, %5861 : tensor<2097152xui32> loc(#loc593)
%5863 = "mhlo.broadcast_in_dim"(%5729) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5864 = mhlo.add %5860, %5863 : tensor<2097152xui32> loc(#loc593)
%5865 = mhlo.constant dense<3> : tensor<ui32> loc(#loc592)
%5866 = "mhlo.broadcast_in_dim"(%5865) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5867 = mhlo.add %5864, %5866 : tensor<2097152xui32> loc(#loc593)
%5868 = mhlo.add %5862, %5867 : tensor<2097152xui32> loc(#loc593)
%5869 = mhlo.constant dense<17> : tensor<ui32> loc(#loc592)
%5870 = "mhlo.broadcast_in_dim"(%5869) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5871 = mhlo.shift_left %5867, %5870 : tensor<2097152xui32> loc(#loc594)
%5872 = mhlo.constant dense<15> : tensor<ui32> loc(#loc592)
%5873 = "mhlo.broadcast_in_dim"(%5872) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5874 = mhlo.shift_right_logical %5867, %5873 : tensor<2097152xui32> loc(#loc595)
%5875 = mhlo.or %5871, %5874 : tensor<2097152xui32> loc(#loc596)
%5876 = mhlo.xor %5868, %5875 : tensor<2097152xui32> loc(#loc591)
%5877 = mhlo.add %5868, %5876 : tensor<2097152xui32> loc(#loc593)
%5878 = mhlo.constant dense<29> : tensor<ui32> loc(#loc592)
%5879 = "mhlo.broadcast_in_dim"(%5878) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5880 = mhlo.shift_left %5876, %5879 : tensor<2097152xui32> loc(#loc594)
%5881 = mhlo.constant dense<3> : tensor<ui32> loc(#loc592)
%5882 = "mhlo.broadcast_in_dim"(%5881) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5883 = mhlo.shift_right_logical %5876, %5882 : tensor<2097152xui32> loc(#loc595)
%5884 = mhlo.or %5880, %5883 : tensor<2097152xui32> loc(#loc596)
%5885 = mhlo.xor %5877, %5884 : tensor<2097152xui32> loc(#loc591)
%5886 = mhlo.add %5877, %5885 : tensor<2097152xui32> loc(#loc593)
%5887 = mhlo.constant dense<16> : tensor<ui32> loc(#loc592)
%5888 = "mhlo.broadcast_in_dim"(%5887) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5889 = mhlo.shift_left %5885, %5888 : tensor<2097152xui32> loc(#loc594)
%5890 = mhlo.constant dense<16> : tensor<ui32> loc(#loc592)
%5891 = "mhlo.broadcast_in_dim"(%5890) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5892 = mhlo.shift_right_logical %5885, %5891 : tensor<2097152xui32> loc(#loc595)
%5893 = mhlo.or %5889, %5892 : tensor<2097152xui32> loc(#loc596)
%5894 = mhlo.xor %5886, %5893 : tensor<2097152xui32> loc(#loc591)
%5895 = mhlo.add %5886, %5894 : tensor<2097152xui32> loc(#loc593)
%5896 = mhlo.constant dense<24> : tensor<ui32> loc(#loc592)
%5897 = "mhlo.broadcast_in_dim"(%5896) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5898 = mhlo.shift_left %5894, %5897 : tensor<2097152xui32> loc(#loc594)
%5899 = mhlo.constant dense<8> : tensor<ui32> loc(#loc592)
%5900 = "mhlo.broadcast_in_dim"(%5899) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5901 = mhlo.shift_right_logical %5894, %5900 : tensor<2097152xui32> loc(#loc595)
%5902 = mhlo.or %5898, %5901 : tensor<2097152xui32> loc(#loc596)
%5903 = mhlo.xor %5895, %5902 : tensor<2097152xui32> loc(#loc591)
%5904 = "mhlo.broadcast_in_dim"(%5729) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5905 = mhlo.add %5895, %5904 : tensor<2097152xui32> loc(#loc593)
%5906 = "mhlo.broadcast_in_dim"(%5734) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5907 = mhlo.add %5903, %5906 : tensor<2097152xui32> loc(#loc593)
%5908 = mhlo.constant dense<4> : tensor<ui32> loc(#loc592)
%5909 = "mhlo.broadcast_in_dim"(%5908) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5910 = mhlo.add %5907, %5909 : tensor<2097152xui32> loc(#loc593)
%5911 = mhlo.add %5905, %5910 : tensor<2097152xui32> loc(#loc593)
%5912 = mhlo.constant dense<13> : tensor<ui32> loc(#loc592)
%5913 = "mhlo.broadcast_in_dim"(%5912) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5914 = mhlo.shift_left %5910, %5913 : tensor<2097152xui32> loc(#loc594)
%5915 = mhlo.constant dense<19> : tensor<ui32> loc(#loc592)
%5916 = "mhlo.broadcast_in_dim"(%5915) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5917 = mhlo.shift_right_logical %5910, %5916 : tensor<2097152xui32> loc(#loc595)
%5918 = mhlo.or %5914, %5917 : tensor<2097152xui32> loc(#loc596)
%5919 = mhlo.xor %5911, %5918 : tensor<2097152xui32> loc(#loc591)
%5920 = mhlo.add %5911, %5919 : tensor<2097152xui32> loc(#loc593)
%5921 = mhlo.constant dense<15> : tensor<ui32> loc(#loc592)
%5922 = "mhlo.broadcast_in_dim"(%5921) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5923 = mhlo.shift_left %5919, %5922 : tensor<2097152xui32> loc(#loc594)
%5924 = mhlo.constant dense<17> : tensor<ui32> loc(#loc592)
%5925 = "mhlo.broadcast_in_dim"(%5924) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5926 = mhlo.shift_right_logical %5919, %5925 : tensor<2097152xui32> loc(#loc595)
%5927 = mhlo.or %5923, %5926 : tensor<2097152xui32> loc(#loc596)
%5928 = mhlo.xor %5920, %5927 : tensor<2097152xui32> loc(#loc591)
%5929 = mhlo.add %5920, %5928 : tensor<2097152xui32> loc(#loc593)
%5930 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5931 = "mhlo.broadcast_in_dim"(%5930) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5932 = mhlo.shift_left %5928, %5931 : tensor<2097152xui32> loc(#loc594)
%5933 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5934 = "mhlo.broadcast_in_dim"(%5933) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5935 = mhlo.shift_right_logical %5928, %5934 : tensor<2097152xui32> loc(#loc595)
%5936 = mhlo.or %5932, %5935 : tensor<2097152xui32> loc(#loc596)
%5937 = mhlo.xor %5929, %5936 : tensor<2097152xui32> loc(#loc591)
%5938 = mhlo.add %5929, %5937 : tensor<2097152xui32> loc(#loc593)
%5939 = mhlo.constant dense<6> : tensor<ui32> loc(#loc592)
%5940 = "mhlo.broadcast_in_dim"(%5939) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc594)
%5941 = mhlo.shift_left %5937, %5940 : tensor<2097152xui32> loc(#loc594)
%5942 = mhlo.constant dense<26> : tensor<ui32> loc(#loc592)
%5943 = "mhlo.broadcast_in_dim"(%5942) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc595)
%5944 = mhlo.shift_right_logical %5937, %5943 : tensor<2097152xui32> loc(#loc595)
%5945 = mhlo.or %5941, %5944 : tensor<2097152xui32> loc(#loc596)
%5946 = mhlo.xor %5938, %5945 : tensor<2097152xui32> loc(#loc591)
%5947 = "mhlo.broadcast_in_dim"(%5734) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5948 = mhlo.add %5938, %5947 : tensor<2097152xui32> loc(#loc593)
%5949 = "mhlo.broadcast_in_dim"(%5727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5950 = mhlo.add %5946, %5949 : tensor<2097152xui32> loc(#loc593)
%5951 = mhlo.constant dense<5> : tensor<ui32> loc(#loc592)
%5952 = "mhlo.broadcast_in_dim"(%5951) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc593)
%5953 = mhlo.add %5950, %5952 : tensor<2097152xui32> loc(#loc593)
%5954 = "mhlo.concatenate"(%5948, %5953) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc597)
%5955 = "mhlo.reshape"(%5954) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc598)
%5956 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%5957 = "mhlo.broadcast_in_dim"(%5956) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc595)
%5958 = mhlo.shift_right_logical %5955, %5957 : tensor<2048x2048xui32> loc(#loc595)
%5959 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%5960 = "mhlo.broadcast_in_dim"(%5959) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc596)
%5961 = mhlo.or %5958, %5960 : tensor<2048x2048xui32> loc(#loc596)
%5962 = "mhlo.bitcast_convert"(%5961) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc599)
%5963 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%5964 = "mhlo.broadcast_in_dim"(%5963) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc600)
%5965 = mhlo.subtract %5962, %5964 : tensor<2048x2048xf32> loc(#loc600)
%5966 = mhlo.subtract %5724, %5722 : tensor<1x1xf32> loc(#loc600)
%5967 = "mhlo.broadcast_in_dim"(%5966) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc601)
%5968 = mhlo.multiply %5965, %5967 : tensor<2048x2048xf32> loc(#loc601)
%5969 = "mhlo.broadcast_in_dim"(%5722) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc593)
%5970 = mhlo.add %5968, %5969 : tensor<2048x2048xf32> loc(#loc593)
%5971 = "mhlo.broadcast_in_dim"(%5722) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc602)
%5972 = mhlo.maximum %5971, %5970 : tensor<2048x2048xf32> loc(#loc602)
%5973 = func.call @erf_inv_22(%5972) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc603)
%5974 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%5975 = "mhlo.broadcast_in_dim"(%5974) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc601)
%5976 = mhlo.multiply %5973, %5975 : tensor<2048x2048xf32> loc(#loc601)
%5977 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%5978 = "mhlo.broadcast_in_dim"(%5977) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc601)
%5979 = mhlo.multiply %5976, %5978 : tensor<2048x2048xf32> loc(#loc601)
%5980 = mhlo.convert(%5979) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc604)
%5981 = "mhlo.dot_general"(%5473, %5980) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc605)
%5982 = mhlo.constant dense<3443933479> : tensor<ui32> loc(#loc531)
%5983 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%5984 = mhlo.shift_right_logical %5982, %5983 : tensor<ui32> loc(#loc606)
%5985 = "mhlo.reshape"(%5984) : (tensor<ui32>) -> tensor<1xui32> loc(#loc607)
%5986 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%5987 = mhlo.and %5982, %5986 : tensor<ui32> loc(#loc608)
%5988 = "mhlo.reshape"(%5987) : (tensor<ui32>) -> tensor<1xui32> loc(#loc607)
%5989 = "mhlo.concatenate"(%5985, %5988) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc609)
%5990 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc610)
%5991 = "mhlo.reshape"(%5990) : (tensor<1xui32>) -> tensor<ui32> loc(#loc611)
%5992 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc612)
%5993 = "mhlo.reshape"(%5992) : (tensor<1xui32>) -> tensor<ui32> loc(#loc611)
%5994 = "mhlo.slice"(%5989) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc613)
%5995 = "mhlo.slice"(%5989) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc614)
%5996 = mhlo.xor %5991, %5993 : tensor<ui32> loc(#loc615)
%5997 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc616)
%5998 = mhlo.xor %5996, %5997 : tensor<ui32> loc(#loc615)
%5999 = "mhlo.broadcast_in_dim"(%5991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6000 = mhlo.add %5994, %5999 : tensor<1xui32> loc(#loc617)
%6001 = "mhlo.broadcast_in_dim"(%5993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6002 = mhlo.add %5995, %6001 : tensor<1xui32> loc(#loc617)
%6003 = mhlo.add %6000, %6002 : tensor<1xui32> loc(#loc617)
%6004 = mhlo.constant dense<13> : tensor<ui32> loc(#loc616)
%6005 = "mhlo.broadcast_in_dim"(%6004) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6006 = mhlo.shift_left %6002, %6005 : tensor<1xui32> loc(#loc618)
%6007 = mhlo.constant dense<19> : tensor<ui32> loc(#loc616)
%6008 = "mhlo.broadcast_in_dim"(%6007) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6009 = mhlo.shift_right_logical %6002, %6008 : tensor<1xui32> loc(#loc606)
%6010 = mhlo.or %6006, %6009 : tensor<1xui32> loc(#loc619)
%6011 = mhlo.xor %6003, %6010 : tensor<1xui32> loc(#loc615)
%6012 = mhlo.add %6003, %6011 : tensor<1xui32> loc(#loc617)
%6013 = mhlo.constant dense<15> : tensor<ui32> loc(#loc616)
%6014 = "mhlo.broadcast_in_dim"(%6013) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6015 = mhlo.shift_left %6011, %6014 : tensor<1xui32> loc(#loc618)
%6016 = mhlo.constant dense<17> : tensor<ui32> loc(#loc616)
%6017 = "mhlo.broadcast_in_dim"(%6016) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6018 = mhlo.shift_right_logical %6011, %6017 : tensor<1xui32> loc(#loc606)
%6019 = mhlo.or %6015, %6018 : tensor<1xui32> loc(#loc619)
%6020 = mhlo.xor %6012, %6019 : tensor<1xui32> loc(#loc615)
%6021 = mhlo.add %6012, %6020 : tensor<1xui32> loc(#loc617)
%6022 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6023 = "mhlo.broadcast_in_dim"(%6022) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6024 = mhlo.shift_left %6020, %6023 : tensor<1xui32> loc(#loc618)
%6025 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6026 = "mhlo.broadcast_in_dim"(%6025) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6027 = mhlo.shift_right_logical %6020, %6026 : tensor<1xui32> loc(#loc606)
%6028 = mhlo.or %6024, %6027 : tensor<1xui32> loc(#loc619)
%6029 = mhlo.xor %6021, %6028 : tensor<1xui32> loc(#loc615)
%6030 = mhlo.add %6021, %6029 : tensor<1xui32> loc(#loc617)
%6031 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6032 = "mhlo.broadcast_in_dim"(%6031) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6033 = mhlo.shift_left %6029, %6032 : tensor<1xui32> loc(#loc618)
%6034 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6035 = "mhlo.broadcast_in_dim"(%6034) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6036 = mhlo.shift_right_logical %6029, %6035 : tensor<1xui32> loc(#loc606)
%6037 = mhlo.or %6033, %6036 : tensor<1xui32> loc(#loc619)
%6038 = mhlo.xor %6030, %6037 : tensor<1xui32> loc(#loc615)
%6039 = "mhlo.broadcast_in_dim"(%5993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6040 = mhlo.add %6030, %6039 : tensor<1xui32> loc(#loc617)
%6041 = "mhlo.broadcast_in_dim"(%5998) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6042 = mhlo.add %6038, %6041 : tensor<1xui32> loc(#loc617)
%6043 = mhlo.constant dense<1> : tensor<ui32> loc(#loc616)
%6044 = "mhlo.broadcast_in_dim"(%6043) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6045 = mhlo.add %6042, %6044 : tensor<1xui32> loc(#loc617)
%6046 = mhlo.add %6040, %6045 : tensor<1xui32> loc(#loc617)
%6047 = mhlo.constant dense<17> : tensor<ui32> loc(#loc616)
%6048 = "mhlo.broadcast_in_dim"(%6047) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6049 = mhlo.shift_left %6045, %6048 : tensor<1xui32> loc(#loc618)
%6050 = mhlo.constant dense<15> : tensor<ui32> loc(#loc616)
%6051 = "mhlo.broadcast_in_dim"(%6050) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6052 = mhlo.shift_right_logical %6045, %6051 : tensor<1xui32> loc(#loc606)
%6053 = mhlo.or %6049, %6052 : tensor<1xui32> loc(#loc619)
%6054 = mhlo.xor %6046, %6053 : tensor<1xui32> loc(#loc615)
%6055 = mhlo.add %6046, %6054 : tensor<1xui32> loc(#loc617)
%6056 = mhlo.constant dense<29> : tensor<ui32> loc(#loc616)
%6057 = "mhlo.broadcast_in_dim"(%6056) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6058 = mhlo.shift_left %6054, %6057 : tensor<1xui32> loc(#loc618)
%6059 = mhlo.constant dense<3> : tensor<ui32> loc(#loc616)
%6060 = "mhlo.broadcast_in_dim"(%6059) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6061 = mhlo.shift_right_logical %6054, %6060 : tensor<1xui32> loc(#loc606)
%6062 = mhlo.or %6058, %6061 : tensor<1xui32> loc(#loc619)
%6063 = mhlo.xor %6055, %6062 : tensor<1xui32> loc(#loc615)
%6064 = mhlo.add %6055, %6063 : tensor<1xui32> loc(#loc617)
%6065 = mhlo.constant dense<16> : tensor<ui32> loc(#loc616)
%6066 = "mhlo.broadcast_in_dim"(%6065) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6067 = mhlo.shift_left %6063, %6066 : tensor<1xui32> loc(#loc618)
%6068 = mhlo.constant dense<16> : tensor<ui32> loc(#loc616)
%6069 = "mhlo.broadcast_in_dim"(%6068) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6070 = mhlo.shift_right_logical %6063, %6069 : tensor<1xui32> loc(#loc606)
%6071 = mhlo.or %6067, %6070 : tensor<1xui32> loc(#loc619)
%6072 = mhlo.xor %6064, %6071 : tensor<1xui32> loc(#loc615)
%6073 = mhlo.add %6064, %6072 : tensor<1xui32> loc(#loc617)
%6074 = mhlo.constant dense<24> : tensor<ui32> loc(#loc616)
%6075 = "mhlo.broadcast_in_dim"(%6074) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6076 = mhlo.shift_left %6072, %6075 : tensor<1xui32> loc(#loc618)
%6077 = mhlo.constant dense<8> : tensor<ui32> loc(#loc616)
%6078 = "mhlo.broadcast_in_dim"(%6077) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6079 = mhlo.shift_right_logical %6072, %6078 : tensor<1xui32> loc(#loc606)
%6080 = mhlo.or %6076, %6079 : tensor<1xui32> loc(#loc619)
%6081 = mhlo.xor %6073, %6080 : tensor<1xui32> loc(#loc615)
%6082 = "mhlo.broadcast_in_dim"(%5998) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6083 = mhlo.add %6073, %6082 : tensor<1xui32> loc(#loc617)
%6084 = "mhlo.broadcast_in_dim"(%5991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6085 = mhlo.add %6081, %6084 : tensor<1xui32> loc(#loc617)
%6086 = mhlo.constant dense<2> : tensor<ui32> loc(#loc616)
%6087 = "mhlo.broadcast_in_dim"(%6086) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6088 = mhlo.add %6085, %6087 : tensor<1xui32> loc(#loc617)
%6089 = mhlo.add %6083, %6088 : tensor<1xui32> loc(#loc617)
%6090 = mhlo.constant dense<13> : tensor<ui32> loc(#loc616)
%6091 = "mhlo.broadcast_in_dim"(%6090) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6092 = mhlo.shift_left %6088, %6091 : tensor<1xui32> loc(#loc618)
%6093 = mhlo.constant dense<19> : tensor<ui32> loc(#loc616)
%6094 = "mhlo.broadcast_in_dim"(%6093) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6095 = mhlo.shift_right_logical %6088, %6094 : tensor<1xui32> loc(#loc606)
%6096 = mhlo.or %6092, %6095 : tensor<1xui32> loc(#loc619)
%6097 = mhlo.xor %6089, %6096 : tensor<1xui32> loc(#loc615)
%6098 = mhlo.add %6089, %6097 : tensor<1xui32> loc(#loc617)
%6099 = mhlo.constant dense<15> : tensor<ui32> loc(#loc616)
%6100 = "mhlo.broadcast_in_dim"(%6099) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6101 = mhlo.shift_left %6097, %6100 : tensor<1xui32> loc(#loc618)
%6102 = mhlo.constant dense<17> : tensor<ui32> loc(#loc616)
%6103 = "mhlo.broadcast_in_dim"(%6102) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6104 = mhlo.shift_right_logical %6097, %6103 : tensor<1xui32> loc(#loc606)
%6105 = mhlo.or %6101, %6104 : tensor<1xui32> loc(#loc619)
%6106 = mhlo.xor %6098, %6105 : tensor<1xui32> loc(#loc615)
%6107 = mhlo.add %6098, %6106 : tensor<1xui32> loc(#loc617)
%6108 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6109 = "mhlo.broadcast_in_dim"(%6108) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6110 = mhlo.shift_left %6106, %6109 : tensor<1xui32> loc(#loc618)
%6111 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6112 = "mhlo.broadcast_in_dim"(%6111) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6113 = mhlo.shift_right_logical %6106, %6112 : tensor<1xui32> loc(#loc606)
%6114 = mhlo.or %6110, %6113 : tensor<1xui32> loc(#loc619)
%6115 = mhlo.xor %6107, %6114 : tensor<1xui32> loc(#loc615)
%6116 = mhlo.add %6107, %6115 : tensor<1xui32> loc(#loc617)
%6117 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6118 = "mhlo.broadcast_in_dim"(%6117) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6119 = mhlo.shift_left %6115, %6118 : tensor<1xui32> loc(#loc618)
%6120 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6121 = "mhlo.broadcast_in_dim"(%6120) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6122 = mhlo.shift_right_logical %6115, %6121 : tensor<1xui32> loc(#loc606)
%6123 = mhlo.or %6119, %6122 : tensor<1xui32> loc(#loc619)
%6124 = mhlo.xor %6116, %6123 : tensor<1xui32> loc(#loc615)
%6125 = "mhlo.broadcast_in_dim"(%5991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6126 = mhlo.add %6116, %6125 : tensor<1xui32> loc(#loc617)
%6127 = "mhlo.broadcast_in_dim"(%5993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6128 = mhlo.add %6124, %6127 : tensor<1xui32> loc(#loc617)
%6129 = mhlo.constant dense<3> : tensor<ui32> loc(#loc616)
%6130 = "mhlo.broadcast_in_dim"(%6129) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6131 = mhlo.add %6128, %6130 : tensor<1xui32> loc(#loc617)
%6132 = mhlo.add %6126, %6131 : tensor<1xui32> loc(#loc617)
%6133 = mhlo.constant dense<17> : tensor<ui32> loc(#loc616)
%6134 = "mhlo.broadcast_in_dim"(%6133) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6135 = mhlo.shift_left %6131, %6134 : tensor<1xui32> loc(#loc618)
%6136 = mhlo.constant dense<15> : tensor<ui32> loc(#loc616)
%6137 = "mhlo.broadcast_in_dim"(%6136) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6138 = mhlo.shift_right_logical %6131, %6137 : tensor<1xui32> loc(#loc606)
%6139 = mhlo.or %6135, %6138 : tensor<1xui32> loc(#loc619)
%6140 = mhlo.xor %6132, %6139 : tensor<1xui32> loc(#loc615)
%6141 = mhlo.add %6132, %6140 : tensor<1xui32> loc(#loc617)
%6142 = mhlo.constant dense<29> : tensor<ui32> loc(#loc616)
%6143 = "mhlo.broadcast_in_dim"(%6142) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6144 = mhlo.shift_left %6140, %6143 : tensor<1xui32> loc(#loc618)
%6145 = mhlo.constant dense<3> : tensor<ui32> loc(#loc616)
%6146 = "mhlo.broadcast_in_dim"(%6145) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6147 = mhlo.shift_right_logical %6140, %6146 : tensor<1xui32> loc(#loc606)
%6148 = mhlo.or %6144, %6147 : tensor<1xui32> loc(#loc619)
%6149 = mhlo.xor %6141, %6148 : tensor<1xui32> loc(#loc615)
%6150 = mhlo.add %6141, %6149 : tensor<1xui32> loc(#loc617)
%6151 = mhlo.constant dense<16> : tensor<ui32> loc(#loc616)
%6152 = "mhlo.broadcast_in_dim"(%6151) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6153 = mhlo.shift_left %6149, %6152 : tensor<1xui32> loc(#loc618)
%6154 = mhlo.constant dense<16> : tensor<ui32> loc(#loc616)
%6155 = "mhlo.broadcast_in_dim"(%6154) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6156 = mhlo.shift_right_logical %6149, %6155 : tensor<1xui32> loc(#loc606)
%6157 = mhlo.or %6153, %6156 : tensor<1xui32> loc(#loc619)
%6158 = mhlo.xor %6150, %6157 : tensor<1xui32> loc(#loc615)
%6159 = mhlo.add %6150, %6158 : tensor<1xui32> loc(#loc617)
%6160 = mhlo.constant dense<24> : tensor<ui32> loc(#loc616)
%6161 = "mhlo.broadcast_in_dim"(%6160) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6162 = mhlo.shift_left %6158, %6161 : tensor<1xui32> loc(#loc618)
%6163 = mhlo.constant dense<8> : tensor<ui32> loc(#loc616)
%6164 = "mhlo.broadcast_in_dim"(%6163) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6165 = mhlo.shift_right_logical %6158, %6164 : tensor<1xui32> loc(#loc606)
%6166 = mhlo.or %6162, %6165 : tensor<1xui32> loc(#loc619)
%6167 = mhlo.xor %6159, %6166 : tensor<1xui32> loc(#loc615)
%6168 = "mhlo.broadcast_in_dim"(%5993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6169 = mhlo.add %6159, %6168 : tensor<1xui32> loc(#loc617)
%6170 = "mhlo.broadcast_in_dim"(%5998) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6171 = mhlo.add %6167, %6170 : tensor<1xui32> loc(#loc617)
%6172 = mhlo.constant dense<4> : tensor<ui32> loc(#loc616)
%6173 = "mhlo.broadcast_in_dim"(%6172) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6174 = mhlo.add %6171, %6173 : tensor<1xui32> loc(#loc617)
%6175 = mhlo.add %6169, %6174 : tensor<1xui32> loc(#loc617)
%6176 = mhlo.constant dense<13> : tensor<ui32> loc(#loc616)
%6177 = "mhlo.broadcast_in_dim"(%6176) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6178 = mhlo.shift_left %6174, %6177 : tensor<1xui32> loc(#loc618)
%6179 = mhlo.constant dense<19> : tensor<ui32> loc(#loc616)
%6180 = "mhlo.broadcast_in_dim"(%6179) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6181 = mhlo.shift_right_logical %6174, %6180 : tensor<1xui32> loc(#loc606)
%6182 = mhlo.or %6178, %6181 : tensor<1xui32> loc(#loc619)
%6183 = mhlo.xor %6175, %6182 : tensor<1xui32> loc(#loc615)
%6184 = mhlo.add %6175, %6183 : tensor<1xui32> loc(#loc617)
%6185 = mhlo.constant dense<15> : tensor<ui32> loc(#loc616)
%6186 = "mhlo.broadcast_in_dim"(%6185) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6187 = mhlo.shift_left %6183, %6186 : tensor<1xui32> loc(#loc618)
%6188 = mhlo.constant dense<17> : tensor<ui32> loc(#loc616)
%6189 = "mhlo.broadcast_in_dim"(%6188) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6190 = mhlo.shift_right_logical %6183, %6189 : tensor<1xui32> loc(#loc606)
%6191 = mhlo.or %6187, %6190 : tensor<1xui32> loc(#loc619)
%6192 = mhlo.xor %6184, %6191 : tensor<1xui32> loc(#loc615)
%6193 = mhlo.add %6184, %6192 : tensor<1xui32> loc(#loc617)
%6194 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6195 = "mhlo.broadcast_in_dim"(%6194) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6196 = mhlo.shift_left %6192, %6195 : tensor<1xui32> loc(#loc618)
%6197 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6198 = "mhlo.broadcast_in_dim"(%6197) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6199 = mhlo.shift_right_logical %6192, %6198 : tensor<1xui32> loc(#loc606)
%6200 = mhlo.or %6196, %6199 : tensor<1xui32> loc(#loc619)
%6201 = mhlo.xor %6193, %6200 : tensor<1xui32> loc(#loc615)
%6202 = mhlo.add %6193, %6201 : tensor<1xui32> loc(#loc617)
%6203 = mhlo.constant dense<6> : tensor<ui32> loc(#loc616)
%6204 = "mhlo.broadcast_in_dim"(%6203) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc618)
%6205 = mhlo.shift_left %6201, %6204 : tensor<1xui32> loc(#loc618)
%6206 = mhlo.constant dense<26> : tensor<ui32> loc(#loc616)
%6207 = "mhlo.broadcast_in_dim"(%6206) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc606)
%6208 = mhlo.shift_right_logical %6201, %6207 : tensor<1xui32> loc(#loc606)
%6209 = mhlo.or %6205, %6208 : tensor<1xui32> loc(#loc619)
%6210 = mhlo.xor %6202, %6209 : tensor<1xui32> loc(#loc615)
%6211 = "mhlo.broadcast_in_dim"(%5998) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6212 = mhlo.add %6202, %6211 : tensor<1xui32> loc(#loc617)
%6213 = "mhlo.broadcast_in_dim"(%5991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6214 = mhlo.add %6210, %6213 : tensor<1xui32> loc(#loc617)
%6215 = mhlo.constant dense<5> : tensor<ui32> loc(#loc616)
%6216 = "mhlo.broadcast_in_dim"(%6215) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc617)
%6217 = mhlo.add %6214, %6216 : tensor<1xui32> loc(#loc617)
%6218 = "mhlo.concatenate"(%6212, %6217) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc609)
%6219 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%6220 = "mhlo.broadcast_in_dim"(%6219) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc620)
%6221 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%6222 = "mhlo.broadcast_in_dim"(%6221) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc620)
%6223 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc621)
%6224 = "mhlo.slice"(%6218) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc622)
%6225 = "mhlo.reshape"(%6224) : (tensor<1xui32>) -> tensor<ui32> loc(#loc623)
%6226 = "mhlo.slice"(%6218) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc624)
%6227 = "mhlo.reshape"(%6226) : (tensor<1xui32>) -> tensor<ui32> loc(#loc623)
%6228 = "mhlo.slice"(%6223) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc625)
%6229 = "mhlo.slice"(%6223) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc626)
%6230 = mhlo.xor %6225, %6227 : tensor<ui32> loc(#loc627)
%6231 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc628)
%6232 = mhlo.xor %6230, %6231 : tensor<ui32> loc(#loc627)
%6233 = "mhlo.broadcast_in_dim"(%6225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6234 = mhlo.add %6228, %6233 : tensor<2097152xui32> loc(#loc629)
%6235 = "mhlo.broadcast_in_dim"(%6227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6236 = mhlo.add %6229, %6235 : tensor<2097152xui32> loc(#loc629)
%6237 = mhlo.add %6234, %6236 : tensor<2097152xui32> loc(#loc629)
%6238 = mhlo.constant dense<13> : tensor<ui32> loc(#loc628)
%6239 = "mhlo.broadcast_in_dim"(%6238) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6240 = mhlo.shift_left %6236, %6239 : tensor<2097152xui32> loc(#loc630)
%6241 = mhlo.constant dense<19> : tensor<ui32> loc(#loc628)
%6242 = "mhlo.broadcast_in_dim"(%6241) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6243 = mhlo.shift_right_logical %6236, %6242 : tensor<2097152xui32> loc(#loc631)
%6244 = mhlo.or %6240, %6243 : tensor<2097152xui32> loc(#loc632)
%6245 = mhlo.xor %6237, %6244 : tensor<2097152xui32> loc(#loc627)
%6246 = mhlo.add %6237, %6245 : tensor<2097152xui32> loc(#loc629)
%6247 = mhlo.constant dense<15> : tensor<ui32> loc(#loc628)
%6248 = "mhlo.broadcast_in_dim"(%6247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6249 = mhlo.shift_left %6245, %6248 : tensor<2097152xui32> loc(#loc630)
%6250 = mhlo.constant dense<17> : tensor<ui32> loc(#loc628)
%6251 = "mhlo.broadcast_in_dim"(%6250) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6252 = mhlo.shift_right_logical %6245, %6251 : tensor<2097152xui32> loc(#loc631)
%6253 = mhlo.or %6249, %6252 : tensor<2097152xui32> loc(#loc632)
%6254 = mhlo.xor %6246, %6253 : tensor<2097152xui32> loc(#loc627)
%6255 = mhlo.add %6246, %6254 : tensor<2097152xui32> loc(#loc629)
%6256 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6257 = "mhlo.broadcast_in_dim"(%6256) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6258 = mhlo.shift_left %6254, %6257 : tensor<2097152xui32> loc(#loc630)
%6259 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6260 = "mhlo.broadcast_in_dim"(%6259) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6261 = mhlo.shift_right_logical %6254, %6260 : tensor<2097152xui32> loc(#loc631)
%6262 = mhlo.or %6258, %6261 : tensor<2097152xui32> loc(#loc632)
%6263 = mhlo.xor %6255, %6262 : tensor<2097152xui32> loc(#loc627)
%6264 = mhlo.add %6255, %6263 : tensor<2097152xui32> loc(#loc629)
%6265 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6266 = "mhlo.broadcast_in_dim"(%6265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6267 = mhlo.shift_left %6263, %6266 : tensor<2097152xui32> loc(#loc630)
%6268 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6269 = "mhlo.broadcast_in_dim"(%6268) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6270 = mhlo.shift_right_logical %6263, %6269 : tensor<2097152xui32> loc(#loc631)
%6271 = mhlo.or %6267, %6270 : tensor<2097152xui32> loc(#loc632)
%6272 = mhlo.xor %6264, %6271 : tensor<2097152xui32> loc(#loc627)
%6273 = "mhlo.broadcast_in_dim"(%6227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6274 = mhlo.add %6264, %6273 : tensor<2097152xui32> loc(#loc629)
%6275 = "mhlo.broadcast_in_dim"(%6232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6276 = mhlo.add %6272, %6275 : tensor<2097152xui32> loc(#loc629)
%6277 = mhlo.constant dense<1> : tensor<ui32> loc(#loc628)
%6278 = "mhlo.broadcast_in_dim"(%6277) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6279 = mhlo.add %6276, %6278 : tensor<2097152xui32> loc(#loc629)
%6280 = mhlo.add %6274, %6279 : tensor<2097152xui32> loc(#loc629)
%6281 = mhlo.constant dense<17> : tensor<ui32> loc(#loc628)
%6282 = "mhlo.broadcast_in_dim"(%6281) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6283 = mhlo.shift_left %6279, %6282 : tensor<2097152xui32> loc(#loc630)
%6284 = mhlo.constant dense<15> : tensor<ui32> loc(#loc628)
%6285 = "mhlo.broadcast_in_dim"(%6284) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6286 = mhlo.shift_right_logical %6279, %6285 : tensor<2097152xui32> loc(#loc631)
%6287 = mhlo.or %6283, %6286 : tensor<2097152xui32> loc(#loc632)
%6288 = mhlo.xor %6280, %6287 : tensor<2097152xui32> loc(#loc627)
%6289 = mhlo.add %6280, %6288 : tensor<2097152xui32> loc(#loc629)
%6290 = mhlo.constant dense<29> : tensor<ui32> loc(#loc628)
%6291 = "mhlo.broadcast_in_dim"(%6290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6292 = mhlo.shift_left %6288, %6291 : tensor<2097152xui32> loc(#loc630)
%6293 = mhlo.constant dense<3> : tensor<ui32> loc(#loc628)
%6294 = "mhlo.broadcast_in_dim"(%6293) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6295 = mhlo.shift_right_logical %6288, %6294 : tensor<2097152xui32> loc(#loc631)
%6296 = mhlo.or %6292, %6295 : tensor<2097152xui32> loc(#loc632)
%6297 = mhlo.xor %6289, %6296 : tensor<2097152xui32> loc(#loc627)
%6298 = mhlo.add %6289, %6297 : tensor<2097152xui32> loc(#loc629)
%6299 = mhlo.constant dense<16> : tensor<ui32> loc(#loc628)
%6300 = "mhlo.broadcast_in_dim"(%6299) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6301 = mhlo.shift_left %6297, %6300 : tensor<2097152xui32> loc(#loc630)
%6302 = mhlo.constant dense<16> : tensor<ui32> loc(#loc628)
%6303 = "mhlo.broadcast_in_dim"(%6302) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6304 = mhlo.shift_right_logical %6297, %6303 : tensor<2097152xui32> loc(#loc631)
%6305 = mhlo.or %6301, %6304 : tensor<2097152xui32> loc(#loc632)
%6306 = mhlo.xor %6298, %6305 : tensor<2097152xui32> loc(#loc627)
%6307 = mhlo.add %6298, %6306 : tensor<2097152xui32> loc(#loc629)
%6308 = mhlo.constant dense<24> : tensor<ui32> loc(#loc628)
%6309 = "mhlo.broadcast_in_dim"(%6308) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6310 = mhlo.shift_left %6306, %6309 : tensor<2097152xui32> loc(#loc630)
%6311 = mhlo.constant dense<8> : tensor<ui32> loc(#loc628)
%6312 = "mhlo.broadcast_in_dim"(%6311) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6313 = mhlo.shift_right_logical %6306, %6312 : tensor<2097152xui32> loc(#loc631)
%6314 = mhlo.or %6310, %6313 : tensor<2097152xui32> loc(#loc632)
%6315 = mhlo.xor %6307, %6314 : tensor<2097152xui32> loc(#loc627)
%6316 = "mhlo.broadcast_in_dim"(%6232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6317 = mhlo.add %6307, %6316 : tensor<2097152xui32> loc(#loc629)
%6318 = "mhlo.broadcast_in_dim"(%6225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6319 = mhlo.add %6315, %6318 : tensor<2097152xui32> loc(#loc629)
%6320 = mhlo.constant dense<2> : tensor<ui32> loc(#loc628)
%6321 = "mhlo.broadcast_in_dim"(%6320) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6322 = mhlo.add %6319, %6321 : tensor<2097152xui32> loc(#loc629)
%6323 = mhlo.add %6317, %6322 : tensor<2097152xui32> loc(#loc629)
%6324 = mhlo.constant dense<13> : tensor<ui32> loc(#loc628)
%6325 = "mhlo.broadcast_in_dim"(%6324) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6326 = mhlo.shift_left %6322, %6325 : tensor<2097152xui32> loc(#loc630)
%6327 = mhlo.constant dense<19> : tensor<ui32> loc(#loc628)
%6328 = "mhlo.broadcast_in_dim"(%6327) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6329 = mhlo.shift_right_logical %6322, %6328 : tensor<2097152xui32> loc(#loc631)
%6330 = mhlo.or %6326, %6329 : tensor<2097152xui32> loc(#loc632)
%6331 = mhlo.xor %6323, %6330 : tensor<2097152xui32> loc(#loc627)
%6332 = mhlo.add %6323, %6331 : tensor<2097152xui32> loc(#loc629)
%6333 = mhlo.constant dense<15> : tensor<ui32> loc(#loc628)
%6334 = "mhlo.broadcast_in_dim"(%6333) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6335 = mhlo.shift_left %6331, %6334 : tensor<2097152xui32> loc(#loc630)
%6336 = mhlo.constant dense<17> : tensor<ui32> loc(#loc628)
%6337 = "mhlo.broadcast_in_dim"(%6336) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6338 = mhlo.shift_right_logical %6331, %6337 : tensor<2097152xui32> loc(#loc631)
%6339 = mhlo.or %6335, %6338 : tensor<2097152xui32> loc(#loc632)
%6340 = mhlo.xor %6332, %6339 : tensor<2097152xui32> loc(#loc627)
%6341 = mhlo.add %6332, %6340 : tensor<2097152xui32> loc(#loc629)
%6342 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6343 = "mhlo.broadcast_in_dim"(%6342) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6344 = mhlo.shift_left %6340, %6343 : tensor<2097152xui32> loc(#loc630)
%6345 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6346 = "mhlo.broadcast_in_dim"(%6345) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6347 = mhlo.shift_right_logical %6340, %6346 : tensor<2097152xui32> loc(#loc631)
%6348 = mhlo.or %6344, %6347 : tensor<2097152xui32> loc(#loc632)
%6349 = mhlo.xor %6341, %6348 : tensor<2097152xui32> loc(#loc627)
%6350 = mhlo.add %6341, %6349 : tensor<2097152xui32> loc(#loc629)
%6351 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6352 = "mhlo.broadcast_in_dim"(%6351) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6353 = mhlo.shift_left %6349, %6352 : tensor<2097152xui32> loc(#loc630)
%6354 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6355 = "mhlo.broadcast_in_dim"(%6354) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6356 = mhlo.shift_right_logical %6349, %6355 : tensor<2097152xui32> loc(#loc631)
%6357 = mhlo.or %6353, %6356 : tensor<2097152xui32> loc(#loc632)
%6358 = mhlo.xor %6350, %6357 : tensor<2097152xui32> loc(#loc627)
%6359 = "mhlo.broadcast_in_dim"(%6225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6360 = mhlo.add %6350, %6359 : tensor<2097152xui32> loc(#loc629)
%6361 = "mhlo.broadcast_in_dim"(%6227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6362 = mhlo.add %6358, %6361 : tensor<2097152xui32> loc(#loc629)
%6363 = mhlo.constant dense<3> : tensor<ui32> loc(#loc628)
%6364 = "mhlo.broadcast_in_dim"(%6363) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6365 = mhlo.add %6362, %6364 : tensor<2097152xui32> loc(#loc629)
%6366 = mhlo.add %6360, %6365 : tensor<2097152xui32> loc(#loc629)
%6367 = mhlo.constant dense<17> : tensor<ui32> loc(#loc628)
%6368 = "mhlo.broadcast_in_dim"(%6367) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6369 = mhlo.shift_left %6365, %6368 : tensor<2097152xui32> loc(#loc630)
%6370 = mhlo.constant dense<15> : tensor<ui32> loc(#loc628)
%6371 = "mhlo.broadcast_in_dim"(%6370) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6372 = mhlo.shift_right_logical %6365, %6371 : tensor<2097152xui32> loc(#loc631)
%6373 = mhlo.or %6369, %6372 : tensor<2097152xui32> loc(#loc632)
%6374 = mhlo.xor %6366, %6373 : tensor<2097152xui32> loc(#loc627)
%6375 = mhlo.add %6366, %6374 : tensor<2097152xui32> loc(#loc629)
%6376 = mhlo.constant dense<29> : tensor<ui32> loc(#loc628)
%6377 = "mhlo.broadcast_in_dim"(%6376) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6378 = mhlo.shift_left %6374, %6377 : tensor<2097152xui32> loc(#loc630)
%6379 = mhlo.constant dense<3> : tensor<ui32> loc(#loc628)
%6380 = "mhlo.broadcast_in_dim"(%6379) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6381 = mhlo.shift_right_logical %6374, %6380 : tensor<2097152xui32> loc(#loc631)
%6382 = mhlo.or %6378, %6381 : tensor<2097152xui32> loc(#loc632)
%6383 = mhlo.xor %6375, %6382 : tensor<2097152xui32> loc(#loc627)
%6384 = mhlo.add %6375, %6383 : tensor<2097152xui32> loc(#loc629)
%6385 = mhlo.constant dense<16> : tensor<ui32> loc(#loc628)
%6386 = "mhlo.broadcast_in_dim"(%6385) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6387 = mhlo.shift_left %6383, %6386 : tensor<2097152xui32> loc(#loc630)
%6388 = mhlo.constant dense<16> : tensor<ui32> loc(#loc628)
%6389 = "mhlo.broadcast_in_dim"(%6388) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6390 = mhlo.shift_right_logical %6383, %6389 : tensor<2097152xui32> loc(#loc631)
%6391 = mhlo.or %6387, %6390 : tensor<2097152xui32> loc(#loc632)
%6392 = mhlo.xor %6384, %6391 : tensor<2097152xui32> loc(#loc627)
%6393 = mhlo.add %6384, %6392 : tensor<2097152xui32> loc(#loc629)
%6394 = mhlo.constant dense<24> : tensor<ui32> loc(#loc628)
%6395 = "mhlo.broadcast_in_dim"(%6394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6396 = mhlo.shift_left %6392, %6395 : tensor<2097152xui32> loc(#loc630)
%6397 = mhlo.constant dense<8> : tensor<ui32> loc(#loc628)
%6398 = "mhlo.broadcast_in_dim"(%6397) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6399 = mhlo.shift_right_logical %6392, %6398 : tensor<2097152xui32> loc(#loc631)
%6400 = mhlo.or %6396, %6399 : tensor<2097152xui32> loc(#loc632)
%6401 = mhlo.xor %6393, %6400 : tensor<2097152xui32> loc(#loc627)
%6402 = "mhlo.broadcast_in_dim"(%6227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6403 = mhlo.add %6393, %6402 : tensor<2097152xui32> loc(#loc629)
%6404 = "mhlo.broadcast_in_dim"(%6232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6405 = mhlo.add %6401, %6404 : tensor<2097152xui32> loc(#loc629)
%6406 = mhlo.constant dense<4> : tensor<ui32> loc(#loc628)
%6407 = "mhlo.broadcast_in_dim"(%6406) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6408 = mhlo.add %6405, %6407 : tensor<2097152xui32> loc(#loc629)
%6409 = mhlo.add %6403, %6408 : tensor<2097152xui32> loc(#loc629)
%6410 = mhlo.constant dense<13> : tensor<ui32> loc(#loc628)
%6411 = "mhlo.broadcast_in_dim"(%6410) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6412 = mhlo.shift_left %6408, %6411 : tensor<2097152xui32> loc(#loc630)
%6413 = mhlo.constant dense<19> : tensor<ui32> loc(#loc628)
%6414 = "mhlo.broadcast_in_dim"(%6413) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6415 = mhlo.shift_right_logical %6408, %6414 : tensor<2097152xui32> loc(#loc631)
%6416 = mhlo.or %6412, %6415 : tensor<2097152xui32> loc(#loc632)
%6417 = mhlo.xor %6409, %6416 : tensor<2097152xui32> loc(#loc627)
%6418 = mhlo.add %6409, %6417 : tensor<2097152xui32> loc(#loc629)
%6419 = mhlo.constant dense<15> : tensor<ui32> loc(#loc628)
%6420 = "mhlo.broadcast_in_dim"(%6419) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6421 = mhlo.shift_left %6417, %6420 : tensor<2097152xui32> loc(#loc630)
%6422 = mhlo.constant dense<17> : tensor<ui32> loc(#loc628)
%6423 = "mhlo.broadcast_in_dim"(%6422) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6424 = mhlo.shift_right_logical %6417, %6423 : tensor<2097152xui32> loc(#loc631)
%6425 = mhlo.or %6421, %6424 : tensor<2097152xui32> loc(#loc632)
%6426 = mhlo.xor %6418, %6425 : tensor<2097152xui32> loc(#loc627)
%6427 = mhlo.add %6418, %6426 : tensor<2097152xui32> loc(#loc629)
%6428 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6429 = "mhlo.broadcast_in_dim"(%6428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6430 = mhlo.shift_left %6426, %6429 : tensor<2097152xui32> loc(#loc630)
%6431 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6432 = "mhlo.broadcast_in_dim"(%6431) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6433 = mhlo.shift_right_logical %6426, %6432 : tensor<2097152xui32> loc(#loc631)
%6434 = mhlo.or %6430, %6433 : tensor<2097152xui32> loc(#loc632)
%6435 = mhlo.xor %6427, %6434 : tensor<2097152xui32> loc(#loc627)
%6436 = mhlo.add %6427, %6435 : tensor<2097152xui32> loc(#loc629)
%6437 = mhlo.constant dense<6> : tensor<ui32> loc(#loc628)
%6438 = "mhlo.broadcast_in_dim"(%6437) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc630)
%6439 = mhlo.shift_left %6435, %6438 : tensor<2097152xui32> loc(#loc630)
%6440 = mhlo.constant dense<26> : tensor<ui32> loc(#loc628)
%6441 = "mhlo.broadcast_in_dim"(%6440) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc631)
%6442 = mhlo.shift_right_logical %6435, %6441 : tensor<2097152xui32> loc(#loc631)
%6443 = mhlo.or %6439, %6442 : tensor<2097152xui32> loc(#loc632)
%6444 = mhlo.xor %6436, %6443 : tensor<2097152xui32> loc(#loc627)
%6445 = "mhlo.broadcast_in_dim"(%6232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6446 = mhlo.add %6436, %6445 : tensor<2097152xui32> loc(#loc629)
%6447 = "mhlo.broadcast_in_dim"(%6225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6448 = mhlo.add %6444, %6447 : tensor<2097152xui32> loc(#loc629)
%6449 = mhlo.constant dense<5> : tensor<ui32> loc(#loc628)
%6450 = "mhlo.broadcast_in_dim"(%6449) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc629)
%6451 = mhlo.add %6448, %6450 : tensor<2097152xui32> loc(#loc629)
%6452 = "mhlo.concatenate"(%6446, %6451) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc633)
%6453 = "mhlo.reshape"(%6452) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc634)
%6454 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%6455 = "mhlo.broadcast_in_dim"(%6454) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc631)
%6456 = mhlo.shift_right_logical %6453, %6455 : tensor<2048x2048xui32> loc(#loc631)
%6457 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%6458 = "mhlo.broadcast_in_dim"(%6457) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc632)
%6459 = mhlo.or %6456, %6458 : tensor<2048x2048xui32> loc(#loc632)
%6460 = "mhlo.bitcast_convert"(%6459) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc635)
%6461 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%6462 = "mhlo.broadcast_in_dim"(%6461) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc636)
%6463 = mhlo.subtract %6460, %6462 : tensor<2048x2048xf32> loc(#loc636)
%6464 = mhlo.subtract %6222, %6220 : tensor<1x1xf32> loc(#loc636)
%6465 = "mhlo.broadcast_in_dim"(%6464) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc637)
%6466 = mhlo.multiply %6463, %6465 : tensor<2048x2048xf32> loc(#loc637)
%6467 = "mhlo.broadcast_in_dim"(%6220) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc629)
%6468 = mhlo.add %6466, %6467 : tensor<2048x2048xf32> loc(#loc629)
%6469 = "mhlo.broadcast_in_dim"(%6220) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc638)
%6470 = mhlo.maximum %6469, %6468 : tensor<2048x2048xf32> loc(#loc638)
%6471 = func.call @erf_inv_22(%6470) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc639)
%6472 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%6473 = "mhlo.broadcast_in_dim"(%6472) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc637)
%6474 = mhlo.multiply %6471, %6473 : tensor<2048x2048xf32> loc(#loc637)
%6475 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%6476 = "mhlo.broadcast_in_dim"(%6475) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc637)
%6477 = mhlo.multiply %6474, %6476 : tensor<2048x2048xf32> loc(#loc637)
%6478 = mhlo.convert(%6477) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc640)
%6479 = "mhlo.dot_general"(%5473, %6478) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc641)
%6480 = mhlo.constant dense<2007060452> : tensor<ui32> loc(#loc531)
%6481 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%6482 = mhlo.shift_right_logical %6480, %6481 : tensor<ui32> loc(#loc642)
%6483 = "mhlo.reshape"(%6482) : (tensor<ui32>) -> tensor<1xui32> loc(#loc643)
%6484 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%6485 = mhlo.and %6480, %6484 : tensor<ui32> loc(#loc644)
%6486 = "mhlo.reshape"(%6485) : (tensor<ui32>) -> tensor<1xui32> loc(#loc643)
%6487 = "mhlo.concatenate"(%6483, %6486) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc645)
%6488 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc646)
%6489 = "mhlo.reshape"(%6488) : (tensor<1xui32>) -> tensor<ui32> loc(#loc647)
%6490 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc648)
%6491 = "mhlo.reshape"(%6490) : (tensor<1xui32>) -> tensor<ui32> loc(#loc647)
%6492 = "mhlo.slice"(%6487) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc649)
%6493 = "mhlo.slice"(%6487) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc650)
%6494 = mhlo.xor %6489, %6491 : tensor<ui32> loc(#loc651)
%6495 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc652)
%6496 = mhlo.xor %6494, %6495 : tensor<ui32> loc(#loc651)
%6497 = "mhlo.broadcast_in_dim"(%6489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6498 = mhlo.add %6492, %6497 : tensor<1xui32> loc(#loc653)
%6499 = "mhlo.broadcast_in_dim"(%6491) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6500 = mhlo.add %6493, %6499 : tensor<1xui32> loc(#loc653)
%6501 = mhlo.add %6498, %6500 : tensor<1xui32> loc(#loc653)
%6502 = mhlo.constant dense<13> : tensor<ui32> loc(#loc652)
%6503 = "mhlo.broadcast_in_dim"(%6502) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6504 = mhlo.shift_left %6500, %6503 : tensor<1xui32> loc(#loc654)
%6505 = mhlo.constant dense<19> : tensor<ui32> loc(#loc652)
%6506 = "mhlo.broadcast_in_dim"(%6505) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6507 = mhlo.shift_right_logical %6500, %6506 : tensor<1xui32> loc(#loc642)
%6508 = mhlo.or %6504, %6507 : tensor<1xui32> loc(#loc655)
%6509 = mhlo.xor %6501, %6508 : tensor<1xui32> loc(#loc651)
%6510 = mhlo.add %6501, %6509 : tensor<1xui32> loc(#loc653)
%6511 = mhlo.constant dense<15> : tensor<ui32> loc(#loc652)
%6512 = "mhlo.broadcast_in_dim"(%6511) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6513 = mhlo.shift_left %6509, %6512 : tensor<1xui32> loc(#loc654)
%6514 = mhlo.constant dense<17> : tensor<ui32> loc(#loc652)
%6515 = "mhlo.broadcast_in_dim"(%6514) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6516 = mhlo.shift_right_logical %6509, %6515 : tensor<1xui32> loc(#loc642)
%6517 = mhlo.or %6513, %6516 : tensor<1xui32> loc(#loc655)
%6518 = mhlo.xor %6510, %6517 : tensor<1xui32> loc(#loc651)
%6519 = mhlo.add %6510, %6518 : tensor<1xui32> loc(#loc653)
%6520 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6521 = "mhlo.broadcast_in_dim"(%6520) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6522 = mhlo.shift_left %6518, %6521 : tensor<1xui32> loc(#loc654)
%6523 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6524 = "mhlo.broadcast_in_dim"(%6523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6525 = mhlo.shift_right_logical %6518, %6524 : tensor<1xui32> loc(#loc642)
%6526 = mhlo.or %6522, %6525 : tensor<1xui32> loc(#loc655)
%6527 = mhlo.xor %6519, %6526 : tensor<1xui32> loc(#loc651)
%6528 = mhlo.add %6519, %6527 : tensor<1xui32> loc(#loc653)
%6529 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6530 = "mhlo.broadcast_in_dim"(%6529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6531 = mhlo.shift_left %6527, %6530 : tensor<1xui32> loc(#loc654)
%6532 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6533 = "mhlo.broadcast_in_dim"(%6532) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6534 = mhlo.shift_right_logical %6527, %6533 : tensor<1xui32> loc(#loc642)
%6535 = mhlo.or %6531, %6534 : tensor<1xui32> loc(#loc655)
%6536 = mhlo.xor %6528, %6535 : tensor<1xui32> loc(#loc651)
%6537 = "mhlo.broadcast_in_dim"(%6491) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6538 = mhlo.add %6528, %6537 : tensor<1xui32> loc(#loc653)
%6539 = "mhlo.broadcast_in_dim"(%6496) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6540 = mhlo.add %6536, %6539 : tensor<1xui32> loc(#loc653)
%6541 = mhlo.constant dense<1> : tensor<ui32> loc(#loc652)
%6542 = "mhlo.broadcast_in_dim"(%6541) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6543 = mhlo.add %6540, %6542 : tensor<1xui32> loc(#loc653)
%6544 = mhlo.add %6538, %6543 : tensor<1xui32> loc(#loc653)
%6545 = mhlo.constant dense<17> : tensor<ui32> loc(#loc652)
%6546 = "mhlo.broadcast_in_dim"(%6545) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6547 = mhlo.shift_left %6543, %6546 : tensor<1xui32> loc(#loc654)
%6548 = mhlo.constant dense<15> : tensor<ui32> loc(#loc652)
%6549 = "mhlo.broadcast_in_dim"(%6548) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6550 = mhlo.shift_right_logical %6543, %6549 : tensor<1xui32> loc(#loc642)
%6551 = mhlo.or %6547, %6550 : tensor<1xui32> loc(#loc655)
%6552 = mhlo.xor %6544, %6551 : tensor<1xui32> loc(#loc651)
%6553 = mhlo.add %6544, %6552 : tensor<1xui32> loc(#loc653)
%6554 = mhlo.constant dense<29> : tensor<ui32> loc(#loc652)
%6555 = "mhlo.broadcast_in_dim"(%6554) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6556 = mhlo.shift_left %6552, %6555 : tensor<1xui32> loc(#loc654)
%6557 = mhlo.constant dense<3> : tensor<ui32> loc(#loc652)
%6558 = "mhlo.broadcast_in_dim"(%6557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6559 = mhlo.shift_right_logical %6552, %6558 : tensor<1xui32> loc(#loc642)
%6560 = mhlo.or %6556, %6559 : tensor<1xui32> loc(#loc655)
%6561 = mhlo.xor %6553, %6560 : tensor<1xui32> loc(#loc651)
%6562 = mhlo.add %6553, %6561 : tensor<1xui32> loc(#loc653)
%6563 = mhlo.constant dense<16> : tensor<ui32> loc(#loc652)
%6564 = "mhlo.broadcast_in_dim"(%6563) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6565 = mhlo.shift_left %6561, %6564 : tensor<1xui32> loc(#loc654)
%6566 = mhlo.constant dense<16> : tensor<ui32> loc(#loc652)
%6567 = "mhlo.broadcast_in_dim"(%6566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6568 = mhlo.shift_right_logical %6561, %6567 : tensor<1xui32> loc(#loc642)
%6569 = mhlo.or %6565, %6568 : tensor<1xui32> loc(#loc655)
%6570 = mhlo.xor %6562, %6569 : tensor<1xui32> loc(#loc651)
%6571 = mhlo.add %6562, %6570 : tensor<1xui32> loc(#loc653)
%6572 = mhlo.constant dense<24> : tensor<ui32> loc(#loc652)
%6573 = "mhlo.broadcast_in_dim"(%6572) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6574 = mhlo.shift_left %6570, %6573 : tensor<1xui32> loc(#loc654)
%6575 = mhlo.constant dense<8> : tensor<ui32> loc(#loc652)
%6576 = "mhlo.broadcast_in_dim"(%6575) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6577 = mhlo.shift_right_logical %6570, %6576 : tensor<1xui32> loc(#loc642)
%6578 = mhlo.or %6574, %6577 : tensor<1xui32> loc(#loc655)
%6579 = mhlo.xor %6571, %6578 : tensor<1xui32> loc(#loc651)
%6580 = "mhlo.broadcast_in_dim"(%6496) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6581 = mhlo.add %6571, %6580 : tensor<1xui32> loc(#loc653)
%6582 = "mhlo.broadcast_in_dim"(%6489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6583 = mhlo.add %6579, %6582 : tensor<1xui32> loc(#loc653)
%6584 = mhlo.constant dense<2> : tensor<ui32> loc(#loc652)
%6585 = "mhlo.broadcast_in_dim"(%6584) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6586 = mhlo.add %6583, %6585 : tensor<1xui32> loc(#loc653)
%6587 = mhlo.add %6581, %6586 : tensor<1xui32> loc(#loc653)
%6588 = mhlo.constant dense<13> : tensor<ui32> loc(#loc652)
%6589 = "mhlo.broadcast_in_dim"(%6588) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6590 = mhlo.shift_left %6586, %6589 : tensor<1xui32> loc(#loc654)
%6591 = mhlo.constant dense<19> : tensor<ui32> loc(#loc652)
%6592 = "mhlo.broadcast_in_dim"(%6591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6593 = mhlo.shift_right_logical %6586, %6592 : tensor<1xui32> loc(#loc642)
%6594 = mhlo.or %6590, %6593 : tensor<1xui32> loc(#loc655)
%6595 = mhlo.xor %6587, %6594 : tensor<1xui32> loc(#loc651)
%6596 = mhlo.add %6587, %6595 : tensor<1xui32> loc(#loc653)
%6597 = mhlo.constant dense<15> : tensor<ui32> loc(#loc652)
%6598 = "mhlo.broadcast_in_dim"(%6597) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6599 = mhlo.shift_left %6595, %6598 : tensor<1xui32> loc(#loc654)
%6600 = mhlo.constant dense<17> : tensor<ui32> loc(#loc652)
%6601 = "mhlo.broadcast_in_dim"(%6600) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6602 = mhlo.shift_right_logical %6595, %6601 : tensor<1xui32> loc(#loc642)
%6603 = mhlo.or %6599, %6602 : tensor<1xui32> loc(#loc655)
%6604 = mhlo.xor %6596, %6603 : tensor<1xui32> loc(#loc651)
%6605 = mhlo.add %6596, %6604 : tensor<1xui32> loc(#loc653)
%6606 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6607 = "mhlo.broadcast_in_dim"(%6606) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6608 = mhlo.shift_left %6604, %6607 : tensor<1xui32> loc(#loc654)
%6609 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6610 = "mhlo.broadcast_in_dim"(%6609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6611 = mhlo.shift_right_logical %6604, %6610 : tensor<1xui32> loc(#loc642)
%6612 = mhlo.or %6608, %6611 : tensor<1xui32> loc(#loc655)
%6613 = mhlo.xor %6605, %6612 : tensor<1xui32> loc(#loc651)
%6614 = mhlo.add %6605, %6613 : tensor<1xui32> loc(#loc653)
%6615 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6616 = "mhlo.broadcast_in_dim"(%6615) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6617 = mhlo.shift_left %6613, %6616 : tensor<1xui32> loc(#loc654)
%6618 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6619 = "mhlo.broadcast_in_dim"(%6618) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6620 = mhlo.shift_right_logical %6613, %6619 : tensor<1xui32> loc(#loc642)
%6621 = mhlo.or %6617, %6620 : tensor<1xui32> loc(#loc655)
%6622 = mhlo.xor %6614, %6621 : tensor<1xui32> loc(#loc651)
%6623 = "mhlo.broadcast_in_dim"(%6489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6624 = mhlo.add %6614, %6623 : tensor<1xui32> loc(#loc653)
%6625 = "mhlo.broadcast_in_dim"(%6491) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6626 = mhlo.add %6622, %6625 : tensor<1xui32> loc(#loc653)
%6627 = mhlo.constant dense<3> : tensor<ui32> loc(#loc652)
%6628 = "mhlo.broadcast_in_dim"(%6627) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6629 = mhlo.add %6626, %6628 : tensor<1xui32> loc(#loc653)
%6630 = mhlo.add %6624, %6629 : tensor<1xui32> loc(#loc653)
%6631 = mhlo.constant dense<17> : tensor<ui32> loc(#loc652)
%6632 = "mhlo.broadcast_in_dim"(%6631) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6633 = mhlo.shift_left %6629, %6632 : tensor<1xui32> loc(#loc654)
%6634 = mhlo.constant dense<15> : tensor<ui32> loc(#loc652)
%6635 = "mhlo.broadcast_in_dim"(%6634) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6636 = mhlo.shift_right_logical %6629, %6635 : tensor<1xui32> loc(#loc642)
%6637 = mhlo.or %6633, %6636 : tensor<1xui32> loc(#loc655)
%6638 = mhlo.xor %6630, %6637 : tensor<1xui32> loc(#loc651)
%6639 = mhlo.add %6630, %6638 : tensor<1xui32> loc(#loc653)
%6640 = mhlo.constant dense<29> : tensor<ui32> loc(#loc652)
%6641 = "mhlo.broadcast_in_dim"(%6640) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6642 = mhlo.shift_left %6638, %6641 : tensor<1xui32> loc(#loc654)
%6643 = mhlo.constant dense<3> : tensor<ui32> loc(#loc652)
%6644 = "mhlo.broadcast_in_dim"(%6643) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6645 = mhlo.shift_right_logical %6638, %6644 : tensor<1xui32> loc(#loc642)
%6646 = mhlo.or %6642, %6645 : tensor<1xui32> loc(#loc655)
%6647 = mhlo.xor %6639, %6646 : tensor<1xui32> loc(#loc651)
%6648 = mhlo.add %6639, %6647 : tensor<1xui32> loc(#loc653)
%6649 = mhlo.constant dense<16> : tensor<ui32> loc(#loc652)
%6650 = "mhlo.broadcast_in_dim"(%6649) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6651 = mhlo.shift_left %6647, %6650 : tensor<1xui32> loc(#loc654)
%6652 = mhlo.constant dense<16> : tensor<ui32> loc(#loc652)
%6653 = "mhlo.broadcast_in_dim"(%6652) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6654 = mhlo.shift_right_logical %6647, %6653 : tensor<1xui32> loc(#loc642)
%6655 = mhlo.or %6651, %6654 : tensor<1xui32> loc(#loc655)
%6656 = mhlo.xor %6648, %6655 : tensor<1xui32> loc(#loc651)
%6657 = mhlo.add %6648, %6656 : tensor<1xui32> loc(#loc653)
%6658 = mhlo.constant dense<24> : tensor<ui32> loc(#loc652)
%6659 = "mhlo.broadcast_in_dim"(%6658) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6660 = mhlo.shift_left %6656, %6659 : tensor<1xui32> loc(#loc654)
%6661 = mhlo.constant dense<8> : tensor<ui32> loc(#loc652)
%6662 = "mhlo.broadcast_in_dim"(%6661) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6663 = mhlo.shift_right_logical %6656, %6662 : tensor<1xui32> loc(#loc642)
%6664 = mhlo.or %6660, %6663 : tensor<1xui32> loc(#loc655)
%6665 = mhlo.xor %6657, %6664 : tensor<1xui32> loc(#loc651)
%6666 = "mhlo.broadcast_in_dim"(%6491) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6667 = mhlo.add %6657, %6666 : tensor<1xui32> loc(#loc653)
%6668 = "mhlo.broadcast_in_dim"(%6496) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6669 = mhlo.add %6665, %6668 : tensor<1xui32> loc(#loc653)
%6670 = mhlo.constant dense<4> : tensor<ui32> loc(#loc652)
%6671 = "mhlo.broadcast_in_dim"(%6670) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6672 = mhlo.add %6669, %6671 : tensor<1xui32> loc(#loc653)
%6673 = mhlo.add %6667, %6672 : tensor<1xui32> loc(#loc653)
%6674 = mhlo.constant dense<13> : tensor<ui32> loc(#loc652)
%6675 = "mhlo.broadcast_in_dim"(%6674) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6676 = mhlo.shift_left %6672, %6675 : tensor<1xui32> loc(#loc654)
%6677 = mhlo.constant dense<19> : tensor<ui32> loc(#loc652)
%6678 = "mhlo.broadcast_in_dim"(%6677) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6679 = mhlo.shift_right_logical %6672, %6678 : tensor<1xui32> loc(#loc642)
%6680 = mhlo.or %6676, %6679 : tensor<1xui32> loc(#loc655)
%6681 = mhlo.xor %6673, %6680 : tensor<1xui32> loc(#loc651)
%6682 = mhlo.add %6673, %6681 : tensor<1xui32> loc(#loc653)
%6683 = mhlo.constant dense<15> : tensor<ui32> loc(#loc652)
%6684 = "mhlo.broadcast_in_dim"(%6683) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6685 = mhlo.shift_left %6681, %6684 : tensor<1xui32> loc(#loc654)
%6686 = mhlo.constant dense<17> : tensor<ui32> loc(#loc652)
%6687 = "mhlo.broadcast_in_dim"(%6686) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6688 = mhlo.shift_right_logical %6681, %6687 : tensor<1xui32> loc(#loc642)
%6689 = mhlo.or %6685, %6688 : tensor<1xui32> loc(#loc655)
%6690 = mhlo.xor %6682, %6689 : tensor<1xui32> loc(#loc651)
%6691 = mhlo.add %6682, %6690 : tensor<1xui32> loc(#loc653)
%6692 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6693 = "mhlo.broadcast_in_dim"(%6692) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6694 = mhlo.shift_left %6690, %6693 : tensor<1xui32> loc(#loc654)
%6695 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6696 = "mhlo.broadcast_in_dim"(%6695) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6697 = mhlo.shift_right_logical %6690, %6696 : tensor<1xui32> loc(#loc642)
%6698 = mhlo.or %6694, %6697 : tensor<1xui32> loc(#loc655)
%6699 = mhlo.xor %6691, %6698 : tensor<1xui32> loc(#loc651)
%6700 = mhlo.add %6691, %6699 : tensor<1xui32> loc(#loc653)
%6701 = mhlo.constant dense<6> : tensor<ui32> loc(#loc652)
%6702 = "mhlo.broadcast_in_dim"(%6701) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc654)
%6703 = mhlo.shift_left %6699, %6702 : tensor<1xui32> loc(#loc654)
%6704 = mhlo.constant dense<26> : tensor<ui32> loc(#loc652)
%6705 = "mhlo.broadcast_in_dim"(%6704) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc642)
%6706 = mhlo.shift_right_logical %6699, %6705 : tensor<1xui32> loc(#loc642)
%6707 = mhlo.or %6703, %6706 : tensor<1xui32> loc(#loc655)
%6708 = mhlo.xor %6700, %6707 : tensor<1xui32> loc(#loc651)
%6709 = "mhlo.broadcast_in_dim"(%6496) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6710 = mhlo.add %6700, %6709 : tensor<1xui32> loc(#loc653)
%6711 = "mhlo.broadcast_in_dim"(%6489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6712 = mhlo.add %6708, %6711 : tensor<1xui32> loc(#loc653)
%6713 = mhlo.constant dense<5> : tensor<ui32> loc(#loc652)
%6714 = "mhlo.broadcast_in_dim"(%6713) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc653)
%6715 = mhlo.add %6712, %6714 : tensor<1xui32> loc(#loc653)
%6716 = "mhlo.concatenate"(%6710, %6715) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc645)
%6717 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%6718 = "mhlo.broadcast_in_dim"(%6717) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc656)
%6719 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%6720 = "mhlo.broadcast_in_dim"(%6719) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc656)
%6721 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc657)
%6722 = "mhlo.slice"(%6716) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc658)
%6723 = "mhlo.reshape"(%6722) : (tensor<1xui32>) -> tensor<ui32> loc(#loc659)
%6724 = "mhlo.slice"(%6716) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc660)
%6725 = "mhlo.reshape"(%6724) : (tensor<1xui32>) -> tensor<ui32> loc(#loc659)
%6726 = "mhlo.slice"(%6721) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc661)
%6727 = "mhlo.slice"(%6721) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc662)
%6728 = mhlo.xor %6723, %6725 : tensor<ui32> loc(#loc663)
%6729 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc664)
%6730 = mhlo.xor %6728, %6729 : tensor<ui32> loc(#loc663)
%6731 = "mhlo.broadcast_in_dim"(%6723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6732 = mhlo.add %6726, %6731 : tensor<2097152xui32> loc(#loc665)
%6733 = "mhlo.broadcast_in_dim"(%6725) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6734 = mhlo.add %6727, %6733 : tensor<2097152xui32> loc(#loc665)
%6735 = mhlo.add %6732, %6734 : tensor<2097152xui32> loc(#loc665)
%6736 = mhlo.constant dense<13> : tensor<ui32> loc(#loc664)
%6737 = "mhlo.broadcast_in_dim"(%6736) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6738 = mhlo.shift_left %6734, %6737 : tensor<2097152xui32> loc(#loc666)
%6739 = mhlo.constant dense<19> : tensor<ui32> loc(#loc664)
%6740 = "mhlo.broadcast_in_dim"(%6739) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6741 = mhlo.shift_right_logical %6734, %6740 : tensor<2097152xui32> loc(#loc667)
%6742 = mhlo.or %6738, %6741 : tensor<2097152xui32> loc(#loc668)
%6743 = mhlo.xor %6735, %6742 : tensor<2097152xui32> loc(#loc663)
%6744 = mhlo.add %6735, %6743 : tensor<2097152xui32> loc(#loc665)
%6745 = mhlo.constant dense<15> : tensor<ui32> loc(#loc664)
%6746 = "mhlo.broadcast_in_dim"(%6745) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6747 = mhlo.shift_left %6743, %6746 : tensor<2097152xui32> loc(#loc666)
%6748 = mhlo.constant dense<17> : tensor<ui32> loc(#loc664)
%6749 = "mhlo.broadcast_in_dim"(%6748) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6750 = mhlo.shift_right_logical %6743, %6749 : tensor<2097152xui32> loc(#loc667)
%6751 = mhlo.or %6747, %6750 : tensor<2097152xui32> loc(#loc668)
%6752 = mhlo.xor %6744, %6751 : tensor<2097152xui32> loc(#loc663)
%6753 = mhlo.add %6744, %6752 : tensor<2097152xui32> loc(#loc665)
%6754 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6755 = "mhlo.broadcast_in_dim"(%6754) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6756 = mhlo.shift_left %6752, %6755 : tensor<2097152xui32> loc(#loc666)
%6757 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6758 = "mhlo.broadcast_in_dim"(%6757) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6759 = mhlo.shift_right_logical %6752, %6758 : tensor<2097152xui32> loc(#loc667)
%6760 = mhlo.or %6756, %6759 : tensor<2097152xui32> loc(#loc668)
%6761 = mhlo.xor %6753, %6760 : tensor<2097152xui32> loc(#loc663)
%6762 = mhlo.add %6753, %6761 : tensor<2097152xui32> loc(#loc665)
%6763 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6764 = "mhlo.broadcast_in_dim"(%6763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6765 = mhlo.shift_left %6761, %6764 : tensor<2097152xui32> loc(#loc666)
%6766 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6767 = "mhlo.broadcast_in_dim"(%6766) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6768 = mhlo.shift_right_logical %6761, %6767 : tensor<2097152xui32> loc(#loc667)
%6769 = mhlo.or %6765, %6768 : tensor<2097152xui32> loc(#loc668)
%6770 = mhlo.xor %6762, %6769 : tensor<2097152xui32> loc(#loc663)
%6771 = "mhlo.broadcast_in_dim"(%6725) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6772 = mhlo.add %6762, %6771 : tensor<2097152xui32> loc(#loc665)
%6773 = "mhlo.broadcast_in_dim"(%6730) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6774 = mhlo.add %6770, %6773 : tensor<2097152xui32> loc(#loc665)
%6775 = mhlo.constant dense<1> : tensor<ui32> loc(#loc664)
%6776 = "mhlo.broadcast_in_dim"(%6775) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6777 = mhlo.add %6774, %6776 : tensor<2097152xui32> loc(#loc665)
%6778 = mhlo.add %6772, %6777 : tensor<2097152xui32> loc(#loc665)
%6779 = mhlo.constant dense<17> : tensor<ui32> loc(#loc664)
%6780 = "mhlo.broadcast_in_dim"(%6779) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6781 = mhlo.shift_left %6777, %6780 : tensor<2097152xui32> loc(#loc666)
%6782 = mhlo.constant dense<15> : tensor<ui32> loc(#loc664)
%6783 = "mhlo.broadcast_in_dim"(%6782) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6784 = mhlo.shift_right_logical %6777, %6783 : tensor<2097152xui32> loc(#loc667)
%6785 = mhlo.or %6781, %6784 : tensor<2097152xui32> loc(#loc668)
%6786 = mhlo.xor %6778, %6785 : tensor<2097152xui32> loc(#loc663)
%6787 = mhlo.add %6778, %6786 : tensor<2097152xui32> loc(#loc665)
%6788 = mhlo.constant dense<29> : tensor<ui32> loc(#loc664)
%6789 = "mhlo.broadcast_in_dim"(%6788) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6790 = mhlo.shift_left %6786, %6789 : tensor<2097152xui32> loc(#loc666)
%6791 = mhlo.constant dense<3> : tensor<ui32> loc(#loc664)
%6792 = "mhlo.broadcast_in_dim"(%6791) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6793 = mhlo.shift_right_logical %6786, %6792 : tensor<2097152xui32> loc(#loc667)
%6794 = mhlo.or %6790, %6793 : tensor<2097152xui32> loc(#loc668)
%6795 = mhlo.xor %6787, %6794 : tensor<2097152xui32> loc(#loc663)
%6796 = mhlo.add %6787, %6795 : tensor<2097152xui32> loc(#loc665)
%6797 = mhlo.constant dense<16> : tensor<ui32> loc(#loc664)
%6798 = "mhlo.broadcast_in_dim"(%6797) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6799 = mhlo.shift_left %6795, %6798 : tensor<2097152xui32> loc(#loc666)
%6800 = mhlo.constant dense<16> : tensor<ui32> loc(#loc664)
%6801 = "mhlo.broadcast_in_dim"(%6800) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6802 = mhlo.shift_right_logical %6795, %6801 : tensor<2097152xui32> loc(#loc667)
%6803 = mhlo.or %6799, %6802 : tensor<2097152xui32> loc(#loc668)
%6804 = mhlo.xor %6796, %6803 : tensor<2097152xui32> loc(#loc663)
%6805 = mhlo.add %6796, %6804 : tensor<2097152xui32> loc(#loc665)
%6806 = mhlo.constant dense<24> : tensor<ui32> loc(#loc664)
%6807 = "mhlo.broadcast_in_dim"(%6806) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6808 = mhlo.shift_left %6804, %6807 : tensor<2097152xui32> loc(#loc666)
%6809 = mhlo.constant dense<8> : tensor<ui32> loc(#loc664)
%6810 = "mhlo.broadcast_in_dim"(%6809) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6811 = mhlo.shift_right_logical %6804, %6810 : tensor<2097152xui32> loc(#loc667)
%6812 = mhlo.or %6808, %6811 : tensor<2097152xui32> loc(#loc668)
%6813 = mhlo.xor %6805, %6812 : tensor<2097152xui32> loc(#loc663)
%6814 = "mhlo.broadcast_in_dim"(%6730) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6815 = mhlo.add %6805, %6814 : tensor<2097152xui32> loc(#loc665)
%6816 = "mhlo.broadcast_in_dim"(%6723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6817 = mhlo.add %6813, %6816 : tensor<2097152xui32> loc(#loc665)
%6818 = mhlo.constant dense<2> : tensor<ui32> loc(#loc664)
%6819 = "mhlo.broadcast_in_dim"(%6818) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6820 = mhlo.add %6817, %6819 : tensor<2097152xui32> loc(#loc665)
%6821 = mhlo.add %6815, %6820 : tensor<2097152xui32> loc(#loc665)
%6822 = mhlo.constant dense<13> : tensor<ui32> loc(#loc664)
%6823 = "mhlo.broadcast_in_dim"(%6822) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6824 = mhlo.shift_left %6820, %6823 : tensor<2097152xui32> loc(#loc666)
%6825 = mhlo.constant dense<19> : tensor<ui32> loc(#loc664)
%6826 = "mhlo.broadcast_in_dim"(%6825) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6827 = mhlo.shift_right_logical %6820, %6826 : tensor<2097152xui32> loc(#loc667)
%6828 = mhlo.or %6824, %6827 : tensor<2097152xui32> loc(#loc668)
%6829 = mhlo.xor %6821, %6828 : tensor<2097152xui32> loc(#loc663)
%6830 = mhlo.add %6821, %6829 : tensor<2097152xui32> loc(#loc665)
%6831 = mhlo.constant dense<15> : tensor<ui32> loc(#loc664)
%6832 = "mhlo.broadcast_in_dim"(%6831) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6833 = mhlo.shift_left %6829, %6832 : tensor<2097152xui32> loc(#loc666)
%6834 = mhlo.constant dense<17> : tensor<ui32> loc(#loc664)
%6835 = "mhlo.broadcast_in_dim"(%6834) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6836 = mhlo.shift_right_logical %6829, %6835 : tensor<2097152xui32> loc(#loc667)
%6837 = mhlo.or %6833, %6836 : tensor<2097152xui32> loc(#loc668)
%6838 = mhlo.xor %6830, %6837 : tensor<2097152xui32> loc(#loc663)
%6839 = mhlo.add %6830, %6838 : tensor<2097152xui32> loc(#loc665)
%6840 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6841 = "mhlo.broadcast_in_dim"(%6840) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6842 = mhlo.shift_left %6838, %6841 : tensor<2097152xui32> loc(#loc666)
%6843 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6844 = "mhlo.broadcast_in_dim"(%6843) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6845 = mhlo.shift_right_logical %6838, %6844 : tensor<2097152xui32> loc(#loc667)
%6846 = mhlo.or %6842, %6845 : tensor<2097152xui32> loc(#loc668)
%6847 = mhlo.xor %6839, %6846 : tensor<2097152xui32> loc(#loc663)
%6848 = mhlo.add %6839, %6847 : tensor<2097152xui32> loc(#loc665)
%6849 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6850 = "mhlo.broadcast_in_dim"(%6849) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6851 = mhlo.shift_left %6847, %6850 : tensor<2097152xui32> loc(#loc666)
%6852 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6853 = "mhlo.broadcast_in_dim"(%6852) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6854 = mhlo.shift_right_logical %6847, %6853 : tensor<2097152xui32> loc(#loc667)
%6855 = mhlo.or %6851, %6854 : tensor<2097152xui32> loc(#loc668)
%6856 = mhlo.xor %6848, %6855 : tensor<2097152xui32> loc(#loc663)
%6857 = "mhlo.broadcast_in_dim"(%6723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6858 = mhlo.add %6848, %6857 : tensor<2097152xui32> loc(#loc665)
%6859 = "mhlo.broadcast_in_dim"(%6725) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6860 = mhlo.add %6856, %6859 : tensor<2097152xui32> loc(#loc665)
%6861 = mhlo.constant dense<3> : tensor<ui32> loc(#loc664)
%6862 = "mhlo.broadcast_in_dim"(%6861) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6863 = mhlo.add %6860, %6862 : tensor<2097152xui32> loc(#loc665)
%6864 = mhlo.add %6858, %6863 : tensor<2097152xui32> loc(#loc665)
%6865 = mhlo.constant dense<17> : tensor<ui32> loc(#loc664)
%6866 = "mhlo.broadcast_in_dim"(%6865) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6867 = mhlo.shift_left %6863, %6866 : tensor<2097152xui32> loc(#loc666)
%6868 = mhlo.constant dense<15> : tensor<ui32> loc(#loc664)
%6869 = "mhlo.broadcast_in_dim"(%6868) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6870 = mhlo.shift_right_logical %6863, %6869 : tensor<2097152xui32> loc(#loc667)
%6871 = mhlo.or %6867, %6870 : tensor<2097152xui32> loc(#loc668)
%6872 = mhlo.xor %6864, %6871 : tensor<2097152xui32> loc(#loc663)
%6873 = mhlo.add %6864, %6872 : tensor<2097152xui32> loc(#loc665)
%6874 = mhlo.constant dense<29> : tensor<ui32> loc(#loc664)
%6875 = "mhlo.broadcast_in_dim"(%6874) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6876 = mhlo.shift_left %6872, %6875 : tensor<2097152xui32> loc(#loc666)
%6877 = mhlo.constant dense<3> : tensor<ui32> loc(#loc664)
%6878 = "mhlo.broadcast_in_dim"(%6877) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6879 = mhlo.shift_right_logical %6872, %6878 : tensor<2097152xui32> loc(#loc667)
%6880 = mhlo.or %6876, %6879 : tensor<2097152xui32> loc(#loc668)
%6881 = mhlo.xor %6873, %6880 : tensor<2097152xui32> loc(#loc663)
%6882 = mhlo.add %6873, %6881 : tensor<2097152xui32> loc(#loc665)
%6883 = mhlo.constant dense<16> : tensor<ui32> loc(#loc664)
%6884 = "mhlo.broadcast_in_dim"(%6883) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6885 = mhlo.shift_left %6881, %6884 : tensor<2097152xui32> loc(#loc666)
%6886 = mhlo.constant dense<16> : tensor<ui32> loc(#loc664)
%6887 = "mhlo.broadcast_in_dim"(%6886) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6888 = mhlo.shift_right_logical %6881, %6887 : tensor<2097152xui32> loc(#loc667)
%6889 = mhlo.or %6885, %6888 : tensor<2097152xui32> loc(#loc668)
%6890 = mhlo.xor %6882, %6889 : tensor<2097152xui32> loc(#loc663)
%6891 = mhlo.add %6882, %6890 : tensor<2097152xui32> loc(#loc665)
%6892 = mhlo.constant dense<24> : tensor<ui32> loc(#loc664)
%6893 = "mhlo.broadcast_in_dim"(%6892) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6894 = mhlo.shift_left %6890, %6893 : tensor<2097152xui32> loc(#loc666)
%6895 = mhlo.constant dense<8> : tensor<ui32> loc(#loc664)
%6896 = "mhlo.broadcast_in_dim"(%6895) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6897 = mhlo.shift_right_logical %6890, %6896 : tensor<2097152xui32> loc(#loc667)
%6898 = mhlo.or %6894, %6897 : tensor<2097152xui32> loc(#loc668)
%6899 = mhlo.xor %6891, %6898 : tensor<2097152xui32> loc(#loc663)
%6900 = "mhlo.broadcast_in_dim"(%6725) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6901 = mhlo.add %6891, %6900 : tensor<2097152xui32> loc(#loc665)
%6902 = "mhlo.broadcast_in_dim"(%6730) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6903 = mhlo.add %6899, %6902 : tensor<2097152xui32> loc(#loc665)
%6904 = mhlo.constant dense<4> : tensor<ui32> loc(#loc664)
%6905 = "mhlo.broadcast_in_dim"(%6904) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6906 = mhlo.add %6903, %6905 : tensor<2097152xui32> loc(#loc665)
%6907 = mhlo.add %6901, %6906 : tensor<2097152xui32> loc(#loc665)
%6908 = mhlo.constant dense<13> : tensor<ui32> loc(#loc664)
%6909 = "mhlo.broadcast_in_dim"(%6908) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6910 = mhlo.shift_left %6906, %6909 : tensor<2097152xui32> loc(#loc666)
%6911 = mhlo.constant dense<19> : tensor<ui32> loc(#loc664)
%6912 = "mhlo.broadcast_in_dim"(%6911) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6913 = mhlo.shift_right_logical %6906, %6912 : tensor<2097152xui32> loc(#loc667)
%6914 = mhlo.or %6910, %6913 : tensor<2097152xui32> loc(#loc668)
%6915 = mhlo.xor %6907, %6914 : tensor<2097152xui32> loc(#loc663)
%6916 = mhlo.add %6907, %6915 : tensor<2097152xui32> loc(#loc665)
%6917 = mhlo.constant dense<15> : tensor<ui32> loc(#loc664)
%6918 = "mhlo.broadcast_in_dim"(%6917) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6919 = mhlo.shift_left %6915, %6918 : tensor<2097152xui32> loc(#loc666)
%6920 = mhlo.constant dense<17> : tensor<ui32> loc(#loc664)
%6921 = "mhlo.broadcast_in_dim"(%6920) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6922 = mhlo.shift_right_logical %6915, %6921 : tensor<2097152xui32> loc(#loc667)
%6923 = mhlo.or %6919, %6922 : tensor<2097152xui32> loc(#loc668)
%6924 = mhlo.xor %6916, %6923 : tensor<2097152xui32> loc(#loc663)
%6925 = mhlo.add %6916, %6924 : tensor<2097152xui32> loc(#loc665)
%6926 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6927 = "mhlo.broadcast_in_dim"(%6926) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6928 = mhlo.shift_left %6924, %6927 : tensor<2097152xui32> loc(#loc666)
%6929 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6930 = "mhlo.broadcast_in_dim"(%6929) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6931 = mhlo.shift_right_logical %6924, %6930 : tensor<2097152xui32> loc(#loc667)
%6932 = mhlo.or %6928, %6931 : tensor<2097152xui32> loc(#loc668)
%6933 = mhlo.xor %6925, %6932 : tensor<2097152xui32> loc(#loc663)
%6934 = mhlo.add %6925, %6933 : tensor<2097152xui32> loc(#loc665)
%6935 = mhlo.constant dense<6> : tensor<ui32> loc(#loc664)
%6936 = "mhlo.broadcast_in_dim"(%6935) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc666)
%6937 = mhlo.shift_left %6933, %6936 : tensor<2097152xui32> loc(#loc666)
%6938 = mhlo.constant dense<26> : tensor<ui32> loc(#loc664)
%6939 = "mhlo.broadcast_in_dim"(%6938) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc667)
%6940 = mhlo.shift_right_logical %6933, %6939 : tensor<2097152xui32> loc(#loc667)
%6941 = mhlo.or %6937, %6940 : tensor<2097152xui32> loc(#loc668)
%6942 = mhlo.xor %6934, %6941 : tensor<2097152xui32> loc(#loc663)
%6943 = "mhlo.broadcast_in_dim"(%6730) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6944 = mhlo.add %6934, %6943 : tensor<2097152xui32> loc(#loc665)
%6945 = "mhlo.broadcast_in_dim"(%6723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6946 = mhlo.add %6942, %6945 : tensor<2097152xui32> loc(#loc665)
%6947 = mhlo.constant dense<5> : tensor<ui32> loc(#loc664)
%6948 = "mhlo.broadcast_in_dim"(%6947) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc665)
%6949 = mhlo.add %6946, %6948 : tensor<2097152xui32> loc(#loc665)
%6950 = "mhlo.concatenate"(%6944, %6949) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc669)
%6951 = "mhlo.reshape"(%6950) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc670)
%6952 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%6953 = "mhlo.broadcast_in_dim"(%6952) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc667)
%6954 = mhlo.shift_right_logical %6951, %6953 : tensor<2048x2048xui32> loc(#loc667)
%6955 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%6956 = "mhlo.broadcast_in_dim"(%6955) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc668)
%6957 = mhlo.or %6954, %6956 : tensor<2048x2048xui32> loc(#loc668)
%6958 = "mhlo.bitcast_convert"(%6957) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc671)
%6959 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%6960 = "mhlo.broadcast_in_dim"(%6959) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc672)
%6961 = mhlo.subtract %6958, %6960 : tensor<2048x2048xf32> loc(#loc672)
%6962 = mhlo.subtract %6720, %6718 : tensor<1x1xf32> loc(#loc672)
%6963 = "mhlo.broadcast_in_dim"(%6962) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc673)
%6964 = mhlo.multiply %6961, %6963 : tensor<2048x2048xf32> loc(#loc673)
%6965 = "mhlo.broadcast_in_dim"(%6718) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc665)
%6966 = mhlo.add %6964, %6965 : tensor<2048x2048xf32> loc(#loc665)
%6967 = "mhlo.broadcast_in_dim"(%6718) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc674)
%6968 = mhlo.maximum %6967, %6966 : tensor<2048x2048xf32> loc(#loc674)
%6969 = func.call @erf_inv_22(%6968) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc675)
%6970 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%6971 = "mhlo.broadcast_in_dim"(%6970) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc673)
%6972 = mhlo.multiply %6969, %6971 : tensor<2048x2048xf32> loc(#loc673)
%6973 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%6974 = "mhlo.broadcast_in_dim"(%6973) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc673)
%6975 = mhlo.multiply %6972, %6974 : tensor<2048x2048xf32> loc(#loc673)
%6976 = mhlo.convert(%6975) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc676)
%6977 = "mhlo.dot_general"(%5473, %6976) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc677)
%6978 = "mhlo.reshape"(%5981) : (tensor<1x256x2048xf16>) -> tensor<1x256x32x64xf16> loc(#loc678)
%6979 = "mhlo.reshape"(%6479) : (tensor<1x256x2048xf16>) -> tensor<1x256x32x64xf16> loc(#loc678)
%6980 = "mhlo.reshape"(%6977) : (tensor<1x256x2048xf16>) -> tensor<1x256x32x64xf16> loc(#loc678)
%6981 = "mhlo.broadcast_in_dim"(%iterArg_0) {broadcast_dimensions = dense<[0, 3]> : tensor<2xi64>} : (tensor<1x256xi32>) -> tensor<1x1x1x256xi32> loc(#loc679)
%6982 = "mhlo.reshape"(%6981) : (tensor<1x1x1x256xi32>) -> tensor<1x1x256xi32> loc(#loc680)
%6983 = "mhlo.broadcast_in_dim"(%6982) {broadcast_dimensions = dense<[0, 1, 3]> : tensor<3xi64>} : (tensor<1x1x256xi32>) -> tensor<1x1x256x256xi32> loc(#loc681)
%6984 = mhlo.constant dense<0> : tensor<i32> loc(#loc531)
%6985 = "mhlo.broadcast_in_dim"(%6984) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<i32>) -> tensor<1x1x256x256xi32> loc(#loc682)
%6986 = "mhlo.compare"(%6983, %6985) {compare_type = #mhlo<"comparison_type SIGNED">, comparison_direction = #mhlo<"comparison_direction NE">} : (tensor<1x1x256x256xi32>, tensor<1x1x256x256xi32>) -> tensor<1x1x256x256xi1> loc(#loc682)
%6987 = mhlo.and %6986, %5483 : tensor<1x1x256x256xi1> loc(#loc683)
%6988 = mhlo.convert(%6987) : (tensor<1x1x256x256xi1>) -> tensor<1x1x256x256xf32> loc(#loc684)
%6989 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc531)
%6990 = "mhlo.broadcast_in_dim"(%6989) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc685)
%6991 = mhlo.constant dense<0.000000e+00> : tensor<f16> loc(#loc531)
%6992 = "mhlo.broadcast_in_dim"(%6991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc685)
%6993 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%6994 = "mhlo.broadcast_in_dim"(%6993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x256x256xf32> loc(#loc686)
%6995 = "mhlo.compare"(%6988, %6994) {compare_type = #mhlo<"comparison_type FLOAT">, comparison_direction = #mhlo<"comparison_direction GT">} : (tensor<1x1x256x256xf32>, tensor<1x1x256x256xf32>) -> tensor<1x1x256x256xi1> loc(#loc686)
%6996 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%6997 = "mhlo.broadcast_in_dim"(%6996) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x256x256xf32> loc(#loc687)
%6998 = mhlo.convert(%6997) : (tensor<1x1x256x256xf32>) -> tensor<1x1x256x256xf16> loc(#loc688)
%6999 = mhlo.constant dense<0xFF800000> : tensor<f32> loc(#loc531)
%7000 = "mhlo.broadcast_in_dim"(%6999) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1x256x256xf32> loc(#loc689)
%7001 = mhlo.convert(%7000) : (tensor<1x1x256x256xf32>) -> tensor<1x1x256x256xf16> loc(#loc690)
%7002 = "mhlo.select"(%6995, %6998, %7001) : (tensor<1x1x256x256xi1>, tensor<1x1x256x256xf16>, tensor<1x1x256x256xf16>) -> tensor<1x1x256x256xf16> loc(#loc691)
%7003 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc531)
%7004 = mhlo.sqrt %7003 : tensor<f32> loc(#loc692)
%7005 = mhlo.convert(%7004) : (tensor<f32>) -> tensor<f16> loc(#loc693)
%7006 = "mhlo.broadcast_in_dim"(%7005) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc694)
%7007 = mhlo.divide %6978, %7006 : tensor<1x256x32x64xf16> loc(#loc694)
%7008 = func.call @_einsum_23(%7007, %6979) : (tensor<1x256x32x64xf16>, tensor<1x256x32x64xf16>) -> tensor<1x32x256x256xf16> loc(#loc695)
%7009 = "mhlo.broadcast_in_dim"(%7002) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x1x256x256xf16>) -> tensor<1x32x256x256xf16> loc(#loc696)
%7010 = mhlo.add %7008, %7009 : tensor<1x32x256x256xf16> loc(#loc696)
%7011 = mhlo.constant dense<0xFC00> : tensor<f16> loc(#loc697)
%7012 = mhlo.reduce(%7010 init: %7011) across dimensions = [3] : (tensor<1x32x256x256xf16>, tensor<f16>) -> tensor<1x32x256xf16>
reducer(%arg47: tensor<f16> loc(unknown), %arg48: tensor<f16> loc(unknown)) {
%13358 = mhlo.maximum %arg47, %arg48 : tensor<f16> loc(#loc697)
"mhlo.return"(%13358) : (tensor<f16>) -> () loc(#loc697)
} loc(#loc697)
%7013 = "mhlo.broadcast_in_dim"(%7012) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x256xf16>) -> tensor<1x32x256x1xf16> loc(#loc698)
%7014 = "mhlo.broadcast_in_dim"(%7013) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x256x1xf16>) -> tensor<1x32x256x256xf16> loc(#loc699)
%7015 = mhlo.subtract %7010, %7014 : tensor<1x32x256x256xf16> loc(#loc699)
%7016 = mhlo.exponential %7015 : tensor<1x32x256x256xf16> loc(#loc700)
%7017 = mhlo.convert(%7016) : (tensor<1x32x256x256xf16>) -> tensor<1x32x256x256xf32> loc(#loc701)
%7018 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc702)
%7019 = mhlo.reduce(%7017 init: %7018) across dimensions = [3] : (tensor<1x32x256x256xf32>, tensor<f32>) -> tensor<1x32x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc702)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc702)
} loc(#loc702)
%7020 = "mhlo.broadcast_in_dim"(%7019) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x256xf32>) -> tensor<1x32x256x1xf32> loc(#loc698)
%7021 = mhlo.convert(%7020) : (tensor<1x32x256x1xf32>) -> tensor<1x32x256x1xf16> loc(#loc703)
%7022 = "mhlo.broadcast_in_dim"(%7021) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x256x1xf16>) -> tensor<1x32x256x256xf16> loc(#loc704)
%7023 = mhlo.divide %7016, %7022 : tensor<1x32x256x256xf16> loc(#loc704)
%7024 = func.call @_einsum_24(%7023, %6980) : (tensor<1x32x256x256xf16>, tensor<1x256x32x64xf16>) -> tensor<1x256x32x64xf16> loc(#loc705)
%7025 = "mhlo.reshape"(%7024) : (tensor<1x256x32x64xf16>) -> tensor<1x256x2048xf16> loc(#loc706)
%7026 = mhlo.constant dense<1156125830> : tensor<ui32> loc(#loc531)
%7027 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%7028 = mhlo.shift_right_logical %7026, %7027 : tensor<ui32> loc(#loc707)
%7029 = "mhlo.reshape"(%7028) : (tensor<ui32>) -> tensor<1xui32> loc(#loc708)
%7030 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%7031 = mhlo.and %7026, %7030 : tensor<ui32> loc(#loc709)
%7032 = "mhlo.reshape"(%7031) : (tensor<ui32>) -> tensor<1xui32> loc(#loc708)
%7033 = "mhlo.concatenate"(%7029, %7032) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc710)
%7034 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc711)
%7035 = "mhlo.reshape"(%7034) : (tensor<1xui32>) -> tensor<ui32> loc(#loc712)
%7036 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc713)
%7037 = "mhlo.reshape"(%7036) : (tensor<1xui32>) -> tensor<ui32> loc(#loc712)
%7038 = "mhlo.slice"(%7033) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc714)
%7039 = "mhlo.slice"(%7033) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc715)
%7040 = mhlo.xor %7035, %7037 : tensor<ui32> loc(#loc716)
%7041 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc717)
%7042 = mhlo.xor %7040, %7041 : tensor<ui32> loc(#loc716)
%7043 = "mhlo.broadcast_in_dim"(%7035) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7044 = mhlo.add %7038, %7043 : tensor<1xui32> loc(#loc718)
%7045 = "mhlo.broadcast_in_dim"(%7037) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7046 = mhlo.add %7039, %7045 : tensor<1xui32> loc(#loc718)
%7047 = mhlo.add %7044, %7046 : tensor<1xui32> loc(#loc718)
%7048 = mhlo.constant dense<13> : tensor<ui32> loc(#loc717)
%7049 = "mhlo.broadcast_in_dim"(%7048) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7050 = mhlo.shift_left %7046, %7049 : tensor<1xui32> loc(#loc719)
%7051 = mhlo.constant dense<19> : tensor<ui32> loc(#loc717)
%7052 = "mhlo.broadcast_in_dim"(%7051) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7053 = mhlo.shift_right_logical %7046, %7052 : tensor<1xui32> loc(#loc707)
%7054 = mhlo.or %7050, %7053 : tensor<1xui32> loc(#loc720)
%7055 = mhlo.xor %7047, %7054 : tensor<1xui32> loc(#loc716)
%7056 = mhlo.add %7047, %7055 : tensor<1xui32> loc(#loc718)
%7057 = mhlo.constant dense<15> : tensor<ui32> loc(#loc717)
%7058 = "mhlo.broadcast_in_dim"(%7057) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7059 = mhlo.shift_left %7055, %7058 : tensor<1xui32> loc(#loc719)
%7060 = mhlo.constant dense<17> : tensor<ui32> loc(#loc717)
%7061 = "mhlo.broadcast_in_dim"(%7060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7062 = mhlo.shift_right_logical %7055, %7061 : tensor<1xui32> loc(#loc707)
%7063 = mhlo.or %7059, %7062 : tensor<1xui32> loc(#loc720)
%7064 = mhlo.xor %7056, %7063 : tensor<1xui32> loc(#loc716)
%7065 = mhlo.add %7056, %7064 : tensor<1xui32> loc(#loc718)
%7066 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7067 = "mhlo.broadcast_in_dim"(%7066) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7068 = mhlo.shift_left %7064, %7067 : tensor<1xui32> loc(#loc719)
%7069 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7070 = "mhlo.broadcast_in_dim"(%7069) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7071 = mhlo.shift_right_logical %7064, %7070 : tensor<1xui32> loc(#loc707)
%7072 = mhlo.or %7068, %7071 : tensor<1xui32> loc(#loc720)
%7073 = mhlo.xor %7065, %7072 : tensor<1xui32> loc(#loc716)
%7074 = mhlo.add %7065, %7073 : tensor<1xui32> loc(#loc718)
%7075 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7076 = "mhlo.broadcast_in_dim"(%7075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7077 = mhlo.shift_left %7073, %7076 : tensor<1xui32> loc(#loc719)
%7078 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7079 = "mhlo.broadcast_in_dim"(%7078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7080 = mhlo.shift_right_logical %7073, %7079 : tensor<1xui32> loc(#loc707)
%7081 = mhlo.or %7077, %7080 : tensor<1xui32> loc(#loc720)
%7082 = mhlo.xor %7074, %7081 : tensor<1xui32> loc(#loc716)
%7083 = "mhlo.broadcast_in_dim"(%7037) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7084 = mhlo.add %7074, %7083 : tensor<1xui32> loc(#loc718)
%7085 = "mhlo.broadcast_in_dim"(%7042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7086 = mhlo.add %7082, %7085 : tensor<1xui32> loc(#loc718)
%7087 = mhlo.constant dense<1> : tensor<ui32> loc(#loc717)
%7088 = "mhlo.broadcast_in_dim"(%7087) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7089 = mhlo.add %7086, %7088 : tensor<1xui32> loc(#loc718)
%7090 = mhlo.add %7084, %7089 : tensor<1xui32> loc(#loc718)
%7091 = mhlo.constant dense<17> : tensor<ui32> loc(#loc717)
%7092 = "mhlo.broadcast_in_dim"(%7091) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7093 = mhlo.shift_left %7089, %7092 : tensor<1xui32> loc(#loc719)
%7094 = mhlo.constant dense<15> : tensor<ui32> loc(#loc717)
%7095 = "mhlo.broadcast_in_dim"(%7094) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7096 = mhlo.shift_right_logical %7089, %7095 : tensor<1xui32> loc(#loc707)
%7097 = mhlo.or %7093, %7096 : tensor<1xui32> loc(#loc720)
%7098 = mhlo.xor %7090, %7097 : tensor<1xui32> loc(#loc716)
%7099 = mhlo.add %7090, %7098 : tensor<1xui32> loc(#loc718)
%7100 = mhlo.constant dense<29> : tensor<ui32> loc(#loc717)
%7101 = "mhlo.broadcast_in_dim"(%7100) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7102 = mhlo.shift_left %7098, %7101 : tensor<1xui32> loc(#loc719)
%7103 = mhlo.constant dense<3> : tensor<ui32> loc(#loc717)
%7104 = "mhlo.broadcast_in_dim"(%7103) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7105 = mhlo.shift_right_logical %7098, %7104 : tensor<1xui32> loc(#loc707)
%7106 = mhlo.or %7102, %7105 : tensor<1xui32> loc(#loc720)
%7107 = mhlo.xor %7099, %7106 : tensor<1xui32> loc(#loc716)
%7108 = mhlo.add %7099, %7107 : tensor<1xui32> loc(#loc718)
%7109 = mhlo.constant dense<16> : tensor<ui32> loc(#loc717)
%7110 = "mhlo.broadcast_in_dim"(%7109) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7111 = mhlo.shift_left %7107, %7110 : tensor<1xui32> loc(#loc719)
%7112 = mhlo.constant dense<16> : tensor<ui32> loc(#loc717)
%7113 = "mhlo.broadcast_in_dim"(%7112) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7114 = mhlo.shift_right_logical %7107, %7113 : tensor<1xui32> loc(#loc707)
%7115 = mhlo.or %7111, %7114 : tensor<1xui32> loc(#loc720)
%7116 = mhlo.xor %7108, %7115 : tensor<1xui32> loc(#loc716)
%7117 = mhlo.add %7108, %7116 : tensor<1xui32> loc(#loc718)
%7118 = mhlo.constant dense<24> : tensor<ui32> loc(#loc717)
%7119 = "mhlo.broadcast_in_dim"(%7118) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7120 = mhlo.shift_left %7116, %7119 : tensor<1xui32> loc(#loc719)
%7121 = mhlo.constant dense<8> : tensor<ui32> loc(#loc717)
%7122 = "mhlo.broadcast_in_dim"(%7121) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7123 = mhlo.shift_right_logical %7116, %7122 : tensor<1xui32> loc(#loc707)
%7124 = mhlo.or %7120, %7123 : tensor<1xui32> loc(#loc720)
%7125 = mhlo.xor %7117, %7124 : tensor<1xui32> loc(#loc716)
%7126 = "mhlo.broadcast_in_dim"(%7042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7127 = mhlo.add %7117, %7126 : tensor<1xui32> loc(#loc718)
%7128 = "mhlo.broadcast_in_dim"(%7035) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7129 = mhlo.add %7125, %7128 : tensor<1xui32> loc(#loc718)
%7130 = mhlo.constant dense<2> : tensor<ui32> loc(#loc717)
%7131 = "mhlo.broadcast_in_dim"(%7130) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7132 = mhlo.add %7129, %7131 : tensor<1xui32> loc(#loc718)
%7133 = mhlo.add %7127, %7132 : tensor<1xui32> loc(#loc718)
%7134 = mhlo.constant dense<13> : tensor<ui32> loc(#loc717)
%7135 = "mhlo.broadcast_in_dim"(%7134) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7136 = mhlo.shift_left %7132, %7135 : tensor<1xui32> loc(#loc719)
%7137 = mhlo.constant dense<19> : tensor<ui32> loc(#loc717)
%7138 = "mhlo.broadcast_in_dim"(%7137) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7139 = mhlo.shift_right_logical %7132, %7138 : tensor<1xui32> loc(#loc707)
%7140 = mhlo.or %7136, %7139 : tensor<1xui32> loc(#loc720)
%7141 = mhlo.xor %7133, %7140 : tensor<1xui32> loc(#loc716)
%7142 = mhlo.add %7133, %7141 : tensor<1xui32> loc(#loc718)
%7143 = mhlo.constant dense<15> : tensor<ui32> loc(#loc717)
%7144 = "mhlo.broadcast_in_dim"(%7143) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7145 = mhlo.shift_left %7141, %7144 : tensor<1xui32> loc(#loc719)
%7146 = mhlo.constant dense<17> : tensor<ui32> loc(#loc717)
%7147 = "mhlo.broadcast_in_dim"(%7146) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7148 = mhlo.shift_right_logical %7141, %7147 : tensor<1xui32> loc(#loc707)
%7149 = mhlo.or %7145, %7148 : tensor<1xui32> loc(#loc720)
%7150 = mhlo.xor %7142, %7149 : tensor<1xui32> loc(#loc716)
%7151 = mhlo.add %7142, %7150 : tensor<1xui32> loc(#loc718)
%7152 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7153 = "mhlo.broadcast_in_dim"(%7152) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7154 = mhlo.shift_left %7150, %7153 : tensor<1xui32> loc(#loc719)
%7155 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7156 = "mhlo.broadcast_in_dim"(%7155) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7157 = mhlo.shift_right_logical %7150, %7156 : tensor<1xui32> loc(#loc707)
%7158 = mhlo.or %7154, %7157 : tensor<1xui32> loc(#loc720)
%7159 = mhlo.xor %7151, %7158 : tensor<1xui32> loc(#loc716)
%7160 = mhlo.add %7151, %7159 : tensor<1xui32> loc(#loc718)
%7161 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7162 = "mhlo.broadcast_in_dim"(%7161) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7163 = mhlo.shift_left %7159, %7162 : tensor<1xui32> loc(#loc719)
%7164 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7165 = "mhlo.broadcast_in_dim"(%7164) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7166 = mhlo.shift_right_logical %7159, %7165 : tensor<1xui32> loc(#loc707)
%7167 = mhlo.or %7163, %7166 : tensor<1xui32> loc(#loc720)
%7168 = mhlo.xor %7160, %7167 : tensor<1xui32> loc(#loc716)
%7169 = "mhlo.broadcast_in_dim"(%7035) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7170 = mhlo.add %7160, %7169 : tensor<1xui32> loc(#loc718)
%7171 = "mhlo.broadcast_in_dim"(%7037) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7172 = mhlo.add %7168, %7171 : tensor<1xui32> loc(#loc718)
%7173 = mhlo.constant dense<3> : tensor<ui32> loc(#loc717)
%7174 = "mhlo.broadcast_in_dim"(%7173) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7175 = mhlo.add %7172, %7174 : tensor<1xui32> loc(#loc718)
%7176 = mhlo.add %7170, %7175 : tensor<1xui32> loc(#loc718)
%7177 = mhlo.constant dense<17> : tensor<ui32> loc(#loc717)
%7178 = "mhlo.broadcast_in_dim"(%7177) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7179 = mhlo.shift_left %7175, %7178 : tensor<1xui32> loc(#loc719)
%7180 = mhlo.constant dense<15> : tensor<ui32> loc(#loc717)
%7181 = "mhlo.broadcast_in_dim"(%7180) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7182 = mhlo.shift_right_logical %7175, %7181 : tensor<1xui32> loc(#loc707)
%7183 = mhlo.or %7179, %7182 : tensor<1xui32> loc(#loc720)
%7184 = mhlo.xor %7176, %7183 : tensor<1xui32> loc(#loc716)
%7185 = mhlo.add %7176, %7184 : tensor<1xui32> loc(#loc718)
%7186 = mhlo.constant dense<29> : tensor<ui32> loc(#loc717)
%7187 = "mhlo.broadcast_in_dim"(%7186) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7188 = mhlo.shift_left %7184, %7187 : tensor<1xui32> loc(#loc719)
%7189 = mhlo.constant dense<3> : tensor<ui32> loc(#loc717)
%7190 = "mhlo.broadcast_in_dim"(%7189) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7191 = mhlo.shift_right_logical %7184, %7190 : tensor<1xui32> loc(#loc707)
%7192 = mhlo.or %7188, %7191 : tensor<1xui32> loc(#loc720)
%7193 = mhlo.xor %7185, %7192 : tensor<1xui32> loc(#loc716)
%7194 = mhlo.add %7185, %7193 : tensor<1xui32> loc(#loc718)
%7195 = mhlo.constant dense<16> : tensor<ui32> loc(#loc717)
%7196 = "mhlo.broadcast_in_dim"(%7195) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7197 = mhlo.shift_left %7193, %7196 : tensor<1xui32> loc(#loc719)
%7198 = mhlo.constant dense<16> : tensor<ui32> loc(#loc717)
%7199 = "mhlo.broadcast_in_dim"(%7198) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7200 = mhlo.shift_right_logical %7193, %7199 : tensor<1xui32> loc(#loc707)
%7201 = mhlo.or %7197, %7200 : tensor<1xui32> loc(#loc720)
%7202 = mhlo.xor %7194, %7201 : tensor<1xui32> loc(#loc716)
%7203 = mhlo.add %7194, %7202 : tensor<1xui32> loc(#loc718)
%7204 = mhlo.constant dense<24> : tensor<ui32> loc(#loc717)
%7205 = "mhlo.broadcast_in_dim"(%7204) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7206 = mhlo.shift_left %7202, %7205 : tensor<1xui32> loc(#loc719)
%7207 = mhlo.constant dense<8> : tensor<ui32> loc(#loc717)
%7208 = "mhlo.broadcast_in_dim"(%7207) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7209 = mhlo.shift_right_logical %7202, %7208 : tensor<1xui32> loc(#loc707)
%7210 = mhlo.or %7206, %7209 : tensor<1xui32> loc(#loc720)
%7211 = mhlo.xor %7203, %7210 : tensor<1xui32> loc(#loc716)
%7212 = "mhlo.broadcast_in_dim"(%7037) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7213 = mhlo.add %7203, %7212 : tensor<1xui32> loc(#loc718)
%7214 = "mhlo.broadcast_in_dim"(%7042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7215 = mhlo.add %7211, %7214 : tensor<1xui32> loc(#loc718)
%7216 = mhlo.constant dense<4> : tensor<ui32> loc(#loc717)
%7217 = "mhlo.broadcast_in_dim"(%7216) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7218 = mhlo.add %7215, %7217 : tensor<1xui32> loc(#loc718)
%7219 = mhlo.add %7213, %7218 : tensor<1xui32> loc(#loc718)
%7220 = mhlo.constant dense<13> : tensor<ui32> loc(#loc717)
%7221 = "mhlo.broadcast_in_dim"(%7220) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7222 = mhlo.shift_left %7218, %7221 : tensor<1xui32> loc(#loc719)
%7223 = mhlo.constant dense<19> : tensor<ui32> loc(#loc717)
%7224 = "mhlo.broadcast_in_dim"(%7223) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7225 = mhlo.shift_right_logical %7218, %7224 : tensor<1xui32> loc(#loc707)
%7226 = mhlo.or %7222, %7225 : tensor<1xui32> loc(#loc720)
%7227 = mhlo.xor %7219, %7226 : tensor<1xui32> loc(#loc716)
%7228 = mhlo.add %7219, %7227 : tensor<1xui32> loc(#loc718)
%7229 = mhlo.constant dense<15> : tensor<ui32> loc(#loc717)
%7230 = "mhlo.broadcast_in_dim"(%7229) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7231 = mhlo.shift_left %7227, %7230 : tensor<1xui32> loc(#loc719)
%7232 = mhlo.constant dense<17> : tensor<ui32> loc(#loc717)
%7233 = "mhlo.broadcast_in_dim"(%7232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7234 = mhlo.shift_right_logical %7227, %7233 : tensor<1xui32> loc(#loc707)
%7235 = mhlo.or %7231, %7234 : tensor<1xui32> loc(#loc720)
%7236 = mhlo.xor %7228, %7235 : tensor<1xui32> loc(#loc716)
%7237 = mhlo.add %7228, %7236 : tensor<1xui32> loc(#loc718)
%7238 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7239 = "mhlo.broadcast_in_dim"(%7238) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7240 = mhlo.shift_left %7236, %7239 : tensor<1xui32> loc(#loc719)
%7241 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7242 = "mhlo.broadcast_in_dim"(%7241) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7243 = mhlo.shift_right_logical %7236, %7242 : tensor<1xui32> loc(#loc707)
%7244 = mhlo.or %7240, %7243 : tensor<1xui32> loc(#loc720)
%7245 = mhlo.xor %7237, %7244 : tensor<1xui32> loc(#loc716)
%7246 = mhlo.add %7237, %7245 : tensor<1xui32> loc(#loc718)
%7247 = mhlo.constant dense<6> : tensor<ui32> loc(#loc717)
%7248 = "mhlo.broadcast_in_dim"(%7247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc719)
%7249 = mhlo.shift_left %7245, %7248 : tensor<1xui32> loc(#loc719)
%7250 = mhlo.constant dense<26> : tensor<ui32> loc(#loc717)
%7251 = "mhlo.broadcast_in_dim"(%7250) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc707)
%7252 = mhlo.shift_right_logical %7245, %7251 : tensor<1xui32> loc(#loc707)
%7253 = mhlo.or %7249, %7252 : tensor<1xui32> loc(#loc720)
%7254 = mhlo.xor %7246, %7253 : tensor<1xui32> loc(#loc716)
%7255 = "mhlo.broadcast_in_dim"(%7042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7256 = mhlo.add %7246, %7255 : tensor<1xui32> loc(#loc718)
%7257 = "mhlo.broadcast_in_dim"(%7035) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7258 = mhlo.add %7254, %7257 : tensor<1xui32> loc(#loc718)
%7259 = mhlo.constant dense<5> : tensor<ui32> loc(#loc717)
%7260 = "mhlo.broadcast_in_dim"(%7259) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc718)
%7261 = mhlo.add %7258, %7260 : tensor<1xui32> loc(#loc718)
%7262 = "mhlo.concatenate"(%7256, %7261) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc710)
%7263 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%7264 = "mhlo.broadcast_in_dim"(%7263) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc721)
%7265 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%7266 = "mhlo.broadcast_in_dim"(%7265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc721)
%7267 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc722)
%7268 = "mhlo.slice"(%7262) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc723)
%7269 = "mhlo.reshape"(%7268) : (tensor<1xui32>) -> tensor<ui32> loc(#loc724)
%7270 = "mhlo.slice"(%7262) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc725)
%7271 = "mhlo.reshape"(%7270) : (tensor<1xui32>) -> tensor<ui32> loc(#loc724)
%7272 = "mhlo.slice"(%7267) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc726)
%7273 = "mhlo.slice"(%7267) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc727)
%7274 = mhlo.xor %7269, %7271 : tensor<ui32> loc(#loc728)
%7275 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc729)
%7276 = mhlo.xor %7274, %7275 : tensor<ui32> loc(#loc728)
%7277 = "mhlo.broadcast_in_dim"(%7269) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7278 = mhlo.add %7272, %7277 : tensor<2097152xui32> loc(#loc730)
%7279 = "mhlo.broadcast_in_dim"(%7271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7280 = mhlo.add %7273, %7279 : tensor<2097152xui32> loc(#loc730)
%7281 = mhlo.add %7278, %7280 : tensor<2097152xui32> loc(#loc730)
%7282 = mhlo.constant dense<13> : tensor<ui32> loc(#loc729)
%7283 = "mhlo.broadcast_in_dim"(%7282) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7284 = mhlo.shift_left %7280, %7283 : tensor<2097152xui32> loc(#loc731)
%7285 = mhlo.constant dense<19> : tensor<ui32> loc(#loc729)
%7286 = "mhlo.broadcast_in_dim"(%7285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7287 = mhlo.shift_right_logical %7280, %7286 : tensor<2097152xui32> loc(#loc732)
%7288 = mhlo.or %7284, %7287 : tensor<2097152xui32> loc(#loc733)
%7289 = mhlo.xor %7281, %7288 : tensor<2097152xui32> loc(#loc728)
%7290 = mhlo.add %7281, %7289 : tensor<2097152xui32> loc(#loc730)
%7291 = mhlo.constant dense<15> : tensor<ui32> loc(#loc729)
%7292 = "mhlo.broadcast_in_dim"(%7291) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7293 = mhlo.shift_left %7289, %7292 : tensor<2097152xui32> loc(#loc731)
%7294 = mhlo.constant dense<17> : tensor<ui32> loc(#loc729)
%7295 = "mhlo.broadcast_in_dim"(%7294) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7296 = mhlo.shift_right_logical %7289, %7295 : tensor<2097152xui32> loc(#loc732)
%7297 = mhlo.or %7293, %7296 : tensor<2097152xui32> loc(#loc733)
%7298 = mhlo.xor %7290, %7297 : tensor<2097152xui32> loc(#loc728)
%7299 = mhlo.add %7290, %7298 : tensor<2097152xui32> loc(#loc730)
%7300 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7301 = "mhlo.broadcast_in_dim"(%7300) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7302 = mhlo.shift_left %7298, %7301 : tensor<2097152xui32> loc(#loc731)
%7303 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7304 = "mhlo.broadcast_in_dim"(%7303) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7305 = mhlo.shift_right_logical %7298, %7304 : tensor<2097152xui32> loc(#loc732)
%7306 = mhlo.or %7302, %7305 : tensor<2097152xui32> loc(#loc733)
%7307 = mhlo.xor %7299, %7306 : tensor<2097152xui32> loc(#loc728)
%7308 = mhlo.add %7299, %7307 : tensor<2097152xui32> loc(#loc730)
%7309 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7310 = "mhlo.broadcast_in_dim"(%7309) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7311 = mhlo.shift_left %7307, %7310 : tensor<2097152xui32> loc(#loc731)
%7312 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7313 = "mhlo.broadcast_in_dim"(%7312) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7314 = mhlo.shift_right_logical %7307, %7313 : tensor<2097152xui32> loc(#loc732)
%7315 = mhlo.or %7311, %7314 : tensor<2097152xui32> loc(#loc733)
%7316 = mhlo.xor %7308, %7315 : tensor<2097152xui32> loc(#loc728)
%7317 = "mhlo.broadcast_in_dim"(%7271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7318 = mhlo.add %7308, %7317 : tensor<2097152xui32> loc(#loc730)
%7319 = "mhlo.broadcast_in_dim"(%7276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7320 = mhlo.add %7316, %7319 : tensor<2097152xui32> loc(#loc730)
%7321 = mhlo.constant dense<1> : tensor<ui32> loc(#loc729)
%7322 = "mhlo.broadcast_in_dim"(%7321) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7323 = mhlo.add %7320, %7322 : tensor<2097152xui32> loc(#loc730)
%7324 = mhlo.add %7318, %7323 : tensor<2097152xui32> loc(#loc730)
%7325 = mhlo.constant dense<17> : tensor<ui32> loc(#loc729)
%7326 = "mhlo.broadcast_in_dim"(%7325) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7327 = mhlo.shift_left %7323, %7326 : tensor<2097152xui32> loc(#loc731)
%7328 = mhlo.constant dense<15> : tensor<ui32> loc(#loc729)
%7329 = "mhlo.broadcast_in_dim"(%7328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7330 = mhlo.shift_right_logical %7323, %7329 : tensor<2097152xui32> loc(#loc732)
%7331 = mhlo.or %7327, %7330 : tensor<2097152xui32> loc(#loc733)
%7332 = mhlo.xor %7324, %7331 : tensor<2097152xui32> loc(#loc728)
%7333 = mhlo.add %7324, %7332 : tensor<2097152xui32> loc(#loc730)
%7334 = mhlo.constant dense<29> : tensor<ui32> loc(#loc729)
%7335 = "mhlo.broadcast_in_dim"(%7334) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7336 = mhlo.shift_left %7332, %7335 : tensor<2097152xui32> loc(#loc731)
%7337 = mhlo.constant dense<3> : tensor<ui32> loc(#loc729)
%7338 = "mhlo.broadcast_in_dim"(%7337) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7339 = mhlo.shift_right_logical %7332, %7338 : tensor<2097152xui32> loc(#loc732)
%7340 = mhlo.or %7336, %7339 : tensor<2097152xui32> loc(#loc733)
%7341 = mhlo.xor %7333, %7340 : tensor<2097152xui32> loc(#loc728)
%7342 = mhlo.add %7333, %7341 : tensor<2097152xui32> loc(#loc730)
%7343 = mhlo.constant dense<16> : tensor<ui32> loc(#loc729)
%7344 = "mhlo.broadcast_in_dim"(%7343) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7345 = mhlo.shift_left %7341, %7344 : tensor<2097152xui32> loc(#loc731)
%7346 = mhlo.constant dense<16> : tensor<ui32> loc(#loc729)
%7347 = "mhlo.broadcast_in_dim"(%7346) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7348 = mhlo.shift_right_logical %7341, %7347 : tensor<2097152xui32> loc(#loc732)
%7349 = mhlo.or %7345, %7348 : tensor<2097152xui32> loc(#loc733)
%7350 = mhlo.xor %7342, %7349 : tensor<2097152xui32> loc(#loc728)
%7351 = mhlo.add %7342, %7350 : tensor<2097152xui32> loc(#loc730)
%7352 = mhlo.constant dense<24> : tensor<ui32> loc(#loc729)
%7353 = "mhlo.broadcast_in_dim"(%7352) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7354 = mhlo.shift_left %7350, %7353 : tensor<2097152xui32> loc(#loc731)
%7355 = mhlo.constant dense<8> : tensor<ui32> loc(#loc729)
%7356 = "mhlo.broadcast_in_dim"(%7355) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7357 = mhlo.shift_right_logical %7350, %7356 : tensor<2097152xui32> loc(#loc732)
%7358 = mhlo.or %7354, %7357 : tensor<2097152xui32> loc(#loc733)
%7359 = mhlo.xor %7351, %7358 : tensor<2097152xui32> loc(#loc728)
%7360 = "mhlo.broadcast_in_dim"(%7276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7361 = mhlo.add %7351, %7360 : tensor<2097152xui32> loc(#loc730)
%7362 = "mhlo.broadcast_in_dim"(%7269) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7363 = mhlo.add %7359, %7362 : tensor<2097152xui32> loc(#loc730)
%7364 = mhlo.constant dense<2> : tensor<ui32> loc(#loc729)
%7365 = "mhlo.broadcast_in_dim"(%7364) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7366 = mhlo.add %7363, %7365 : tensor<2097152xui32> loc(#loc730)
%7367 = mhlo.add %7361, %7366 : tensor<2097152xui32> loc(#loc730)
%7368 = mhlo.constant dense<13> : tensor<ui32> loc(#loc729)
%7369 = "mhlo.broadcast_in_dim"(%7368) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7370 = mhlo.shift_left %7366, %7369 : tensor<2097152xui32> loc(#loc731)
%7371 = mhlo.constant dense<19> : tensor<ui32> loc(#loc729)
%7372 = "mhlo.broadcast_in_dim"(%7371) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7373 = mhlo.shift_right_logical %7366, %7372 : tensor<2097152xui32> loc(#loc732)
%7374 = mhlo.or %7370, %7373 : tensor<2097152xui32> loc(#loc733)
%7375 = mhlo.xor %7367, %7374 : tensor<2097152xui32> loc(#loc728)
%7376 = mhlo.add %7367, %7375 : tensor<2097152xui32> loc(#loc730)
%7377 = mhlo.constant dense<15> : tensor<ui32> loc(#loc729)
%7378 = "mhlo.broadcast_in_dim"(%7377) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7379 = mhlo.shift_left %7375, %7378 : tensor<2097152xui32> loc(#loc731)
%7380 = mhlo.constant dense<17> : tensor<ui32> loc(#loc729)
%7381 = "mhlo.broadcast_in_dim"(%7380) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7382 = mhlo.shift_right_logical %7375, %7381 : tensor<2097152xui32> loc(#loc732)
%7383 = mhlo.or %7379, %7382 : tensor<2097152xui32> loc(#loc733)
%7384 = mhlo.xor %7376, %7383 : tensor<2097152xui32> loc(#loc728)
%7385 = mhlo.add %7376, %7384 : tensor<2097152xui32> loc(#loc730)
%7386 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7387 = "mhlo.broadcast_in_dim"(%7386) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7388 = mhlo.shift_left %7384, %7387 : tensor<2097152xui32> loc(#loc731)
%7389 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7390 = "mhlo.broadcast_in_dim"(%7389) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7391 = mhlo.shift_right_logical %7384, %7390 : tensor<2097152xui32> loc(#loc732)
%7392 = mhlo.or %7388, %7391 : tensor<2097152xui32> loc(#loc733)
%7393 = mhlo.xor %7385, %7392 : tensor<2097152xui32> loc(#loc728)
%7394 = mhlo.add %7385, %7393 : tensor<2097152xui32> loc(#loc730)
%7395 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7396 = "mhlo.broadcast_in_dim"(%7395) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7397 = mhlo.shift_left %7393, %7396 : tensor<2097152xui32> loc(#loc731)
%7398 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7399 = "mhlo.broadcast_in_dim"(%7398) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7400 = mhlo.shift_right_logical %7393, %7399 : tensor<2097152xui32> loc(#loc732)
%7401 = mhlo.or %7397, %7400 : tensor<2097152xui32> loc(#loc733)
%7402 = mhlo.xor %7394, %7401 : tensor<2097152xui32> loc(#loc728)
%7403 = "mhlo.broadcast_in_dim"(%7269) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7404 = mhlo.add %7394, %7403 : tensor<2097152xui32> loc(#loc730)
%7405 = "mhlo.broadcast_in_dim"(%7271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7406 = mhlo.add %7402, %7405 : tensor<2097152xui32> loc(#loc730)
%7407 = mhlo.constant dense<3> : tensor<ui32> loc(#loc729)
%7408 = "mhlo.broadcast_in_dim"(%7407) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7409 = mhlo.add %7406, %7408 : tensor<2097152xui32> loc(#loc730)
%7410 = mhlo.add %7404, %7409 : tensor<2097152xui32> loc(#loc730)
%7411 = mhlo.constant dense<17> : tensor<ui32> loc(#loc729)
%7412 = "mhlo.broadcast_in_dim"(%7411) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7413 = mhlo.shift_left %7409, %7412 : tensor<2097152xui32> loc(#loc731)
%7414 = mhlo.constant dense<15> : tensor<ui32> loc(#loc729)
%7415 = "mhlo.broadcast_in_dim"(%7414) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7416 = mhlo.shift_right_logical %7409, %7415 : tensor<2097152xui32> loc(#loc732)
%7417 = mhlo.or %7413, %7416 : tensor<2097152xui32> loc(#loc733)
%7418 = mhlo.xor %7410, %7417 : tensor<2097152xui32> loc(#loc728)
%7419 = mhlo.add %7410, %7418 : tensor<2097152xui32> loc(#loc730)
%7420 = mhlo.constant dense<29> : tensor<ui32> loc(#loc729)
%7421 = "mhlo.broadcast_in_dim"(%7420) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7422 = mhlo.shift_left %7418, %7421 : tensor<2097152xui32> loc(#loc731)
%7423 = mhlo.constant dense<3> : tensor<ui32> loc(#loc729)
%7424 = "mhlo.broadcast_in_dim"(%7423) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7425 = mhlo.shift_right_logical %7418, %7424 : tensor<2097152xui32> loc(#loc732)
%7426 = mhlo.or %7422, %7425 : tensor<2097152xui32> loc(#loc733)
%7427 = mhlo.xor %7419, %7426 : tensor<2097152xui32> loc(#loc728)
%7428 = mhlo.add %7419, %7427 : tensor<2097152xui32> loc(#loc730)
%7429 = mhlo.constant dense<16> : tensor<ui32> loc(#loc729)
%7430 = "mhlo.broadcast_in_dim"(%7429) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7431 = mhlo.shift_left %7427, %7430 : tensor<2097152xui32> loc(#loc731)
%7432 = mhlo.constant dense<16> : tensor<ui32> loc(#loc729)
%7433 = "mhlo.broadcast_in_dim"(%7432) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7434 = mhlo.shift_right_logical %7427, %7433 : tensor<2097152xui32> loc(#loc732)
%7435 = mhlo.or %7431, %7434 : tensor<2097152xui32> loc(#loc733)
%7436 = mhlo.xor %7428, %7435 : tensor<2097152xui32> loc(#loc728)
%7437 = mhlo.add %7428, %7436 : tensor<2097152xui32> loc(#loc730)
%7438 = mhlo.constant dense<24> : tensor<ui32> loc(#loc729)
%7439 = "mhlo.broadcast_in_dim"(%7438) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7440 = mhlo.shift_left %7436, %7439 : tensor<2097152xui32> loc(#loc731)
%7441 = mhlo.constant dense<8> : tensor<ui32> loc(#loc729)
%7442 = "mhlo.broadcast_in_dim"(%7441) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7443 = mhlo.shift_right_logical %7436, %7442 : tensor<2097152xui32> loc(#loc732)
%7444 = mhlo.or %7440, %7443 : tensor<2097152xui32> loc(#loc733)
%7445 = mhlo.xor %7437, %7444 : tensor<2097152xui32> loc(#loc728)
%7446 = "mhlo.broadcast_in_dim"(%7271) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7447 = mhlo.add %7437, %7446 : tensor<2097152xui32> loc(#loc730)
%7448 = "mhlo.broadcast_in_dim"(%7276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7449 = mhlo.add %7445, %7448 : tensor<2097152xui32> loc(#loc730)
%7450 = mhlo.constant dense<4> : tensor<ui32> loc(#loc729)
%7451 = "mhlo.broadcast_in_dim"(%7450) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7452 = mhlo.add %7449, %7451 : tensor<2097152xui32> loc(#loc730)
%7453 = mhlo.add %7447, %7452 : tensor<2097152xui32> loc(#loc730)
%7454 = mhlo.constant dense<13> : tensor<ui32> loc(#loc729)
%7455 = "mhlo.broadcast_in_dim"(%7454) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7456 = mhlo.shift_left %7452, %7455 : tensor<2097152xui32> loc(#loc731)
%7457 = mhlo.constant dense<19> : tensor<ui32> loc(#loc729)
%7458 = "mhlo.broadcast_in_dim"(%7457) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7459 = mhlo.shift_right_logical %7452, %7458 : tensor<2097152xui32> loc(#loc732)
%7460 = mhlo.or %7456, %7459 : tensor<2097152xui32> loc(#loc733)
%7461 = mhlo.xor %7453, %7460 : tensor<2097152xui32> loc(#loc728)
%7462 = mhlo.add %7453, %7461 : tensor<2097152xui32> loc(#loc730)
%7463 = mhlo.constant dense<15> : tensor<ui32> loc(#loc729)
%7464 = "mhlo.broadcast_in_dim"(%7463) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7465 = mhlo.shift_left %7461, %7464 : tensor<2097152xui32> loc(#loc731)
%7466 = mhlo.constant dense<17> : tensor<ui32> loc(#loc729)
%7467 = "mhlo.broadcast_in_dim"(%7466) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7468 = mhlo.shift_right_logical %7461, %7467 : tensor<2097152xui32> loc(#loc732)
%7469 = mhlo.or %7465, %7468 : tensor<2097152xui32> loc(#loc733)
%7470 = mhlo.xor %7462, %7469 : tensor<2097152xui32> loc(#loc728)
%7471 = mhlo.add %7462, %7470 : tensor<2097152xui32> loc(#loc730)
%7472 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7473 = "mhlo.broadcast_in_dim"(%7472) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7474 = mhlo.shift_left %7470, %7473 : tensor<2097152xui32> loc(#loc731)
%7475 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7476 = "mhlo.broadcast_in_dim"(%7475) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7477 = mhlo.shift_right_logical %7470, %7476 : tensor<2097152xui32> loc(#loc732)
%7478 = mhlo.or %7474, %7477 : tensor<2097152xui32> loc(#loc733)
%7479 = mhlo.xor %7471, %7478 : tensor<2097152xui32> loc(#loc728)
%7480 = mhlo.add %7471, %7479 : tensor<2097152xui32> loc(#loc730)
%7481 = mhlo.constant dense<6> : tensor<ui32> loc(#loc729)
%7482 = "mhlo.broadcast_in_dim"(%7481) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc731)
%7483 = mhlo.shift_left %7479, %7482 : tensor<2097152xui32> loc(#loc731)
%7484 = mhlo.constant dense<26> : tensor<ui32> loc(#loc729)
%7485 = "mhlo.broadcast_in_dim"(%7484) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc732)
%7486 = mhlo.shift_right_logical %7479, %7485 : tensor<2097152xui32> loc(#loc732)
%7487 = mhlo.or %7483, %7486 : tensor<2097152xui32> loc(#loc733)
%7488 = mhlo.xor %7480, %7487 : tensor<2097152xui32> loc(#loc728)
%7489 = "mhlo.broadcast_in_dim"(%7276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7490 = mhlo.add %7480, %7489 : tensor<2097152xui32> loc(#loc730)
%7491 = "mhlo.broadcast_in_dim"(%7269) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7492 = mhlo.add %7488, %7491 : tensor<2097152xui32> loc(#loc730)
%7493 = mhlo.constant dense<5> : tensor<ui32> loc(#loc729)
%7494 = "mhlo.broadcast_in_dim"(%7493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc730)
%7495 = mhlo.add %7492, %7494 : tensor<2097152xui32> loc(#loc730)
%7496 = "mhlo.concatenate"(%7490, %7495) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc734)
%7497 = "mhlo.reshape"(%7496) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc735)
%7498 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%7499 = "mhlo.broadcast_in_dim"(%7498) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc732)
%7500 = mhlo.shift_right_logical %7497, %7499 : tensor<2048x2048xui32> loc(#loc732)
%7501 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%7502 = "mhlo.broadcast_in_dim"(%7501) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc733)
%7503 = mhlo.or %7500, %7502 : tensor<2048x2048xui32> loc(#loc733)
%7504 = "mhlo.bitcast_convert"(%7503) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc736)
%7505 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%7506 = "mhlo.broadcast_in_dim"(%7505) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc737)
%7507 = mhlo.subtract %7504, %7506 : tensor<2048x2048xf32> loc(#loc737)
%7508 = mhlo.subtract %7266, %7264 : tensor<1x1xf32> loc(#loc737)
%7509 = "mhlo.broadcast_in_dim"(%7508) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc738)
%7510 = mhlo.multiply %7507, %7509 : tensor<2048x2048xf32> loc(#loc738)
%7511 = "mhlo.broadcast_in_dim"(%7264) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc730)
%7512 = mhlo.add %7510, %7511 : tensor<2048x2048xf32> loc(#loc730)
%7513 = "mhlo.broadcast_in_dim"(%7264) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc739)
%7514 = mhlo.maximum %7513, %7512 : tensor<2048x2048xf32> loc(#loc739)
%7515 = func.call @erf_inv_22(%7514) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc740)
%7516 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%7517 = "mhlo.broadcast_in_dim"(%7516) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc738)
%7518 = mhlo.multiply %7515, %7517 : tensor<2048x2048xf32> loc(#loc738)
%7519 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%7520 = "mhlo.broadcast_in_dim"(%7519) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc738)
%7521 = mhlo.multiply %7518, %7520 : tensor<2048x2048xf32> loc(#loc738)
%7522 = mhlo.convert(%7521) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc741)
%7523 = "mhlo.dot_general"(%7025, %7522) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc742)
%7524 = mhlo.convert(%7523) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc743)
%7525 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc744)
%7526 = mhlo.reduce(%7524 init: %7525) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc744)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc744)
} loc(#loc744)
%7527 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%7528 = "mhlo.broadcast_in_dim"(%7527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc745)
%7529 = mhlo.divide %7526, %7528 : tensor<1x256xf32> loc(#loc745)
%7530 = mhlo.multiply %7524, %7524 : tensor<1x256x2048xf32> loc(#loc746)
%7531 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc747)
%7532 = mhlo.reduce(%7530 init: %7531) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc747)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc747)
} loc(#loc747)
%7533 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%7534 = "mhlo.broadcast_in_dim"(%7533) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc748)
%7535 = mhlo.divide %7532, %7534 : tensor<1x256xf32> loc(#loc748)
%7536 = mhlo.multiply %7529, %7529 : tensor<1x256xf32> loc(#loc746)
%7537 = mhlo.subtract %7535, %7536 : tensor<1x256xf32> loc(#loc749)
%7538 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%7539 = "mhlo.broadcast_in_dim"(%7538) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc750)
%7540 = mhlo.maximum %7539, %7537 : tensor<1x256xf32> loc(#loc750)
%7541 = "mhlo.reshape"(%7529) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc751)
%7542 = "mhlo.reshape"(%7540) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc752)
%7543 = mhlo.convert(%7523) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc753)
%7544 = "mhlo.broadcast_in_dim"(%7541) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc754)
%7545 = mhlo.subtract %7543, %7544 : tensor<1x256x2048xf32> loc(#loc754)
%7546 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc531)
%7547 = "mhlo.broadcast_in_dim"(%7546) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc755)
%7548 = mhlo.add %7542, %7547 : tensor<1x256x1xf32> loc(#loc755)
%7549 = mhlo.rsqrt %7548 : tensor<1x256x1xf32> loc(#loc756)
%7550 = mhlo.constant dense<3816890253> : tensor<ui32> loc(#loc531)
%7551 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%7552 = mhlo.shift_right_logical %7550, %7551 : tensor<ui32> loc(#loc757)
%7553 = "mhlo.reshape"(%7552) : (tensor<ui32>) -> tensor<1xui32> loc(#loc758)
%7554 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%7555 = mhlo.and %7550, %7554 : tensor<ui32> loc(#loc759)
%7556 = "mhlo.reshape"(%7555) : (tensor<ui32>) -> tensor<1xui32> loc(#loc758)
%7557 = "mhlo.concatenate"(%7553, %7556) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc760)
%7558 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc761)
%7559 = "mhlo.reshape"(%7558) : (tensor<1xui32>) -> tensor<ui32> loc(#loc762)
%7560 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc763)
%7561 = "mhlo.reshape"(%7560) : (tensor<1xui32>) -> tensor<ui32> loc(#loc762)
%7562 = "mhlo.slice"(%7557) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc764)
%7563 = "mhlo.slice"(%7557) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc765)
%7564 = mhlo.xor %7559, %7561 : tensor<ui32> loc(#loc766)
%7565 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc767)
%7566 = mhlo.xor %7564, %7565 : tensor<ui32> loc(#loc766)
%7567 = "mhlo.broadcast_in_dim"(%7559) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7568 = mhlo.add %7562, %7567 : tensor<1xui32> loc(#loc768)
%7569 = "mhlo.broadcast_in_dim"(%7561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7570 = mhlo.add %7563, %7569 : tensor<1xui32> loc(#loc768)
%7571 = mhlo.add %7568, %7570 : tensor<1xui32> loc(#loc768)
%7572 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7573 = "mhlo.broadcast_in_dim"(%7572) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7574 = mhlo.shift_left %7570, %7573 : tensor<1xui32> loc(#loc769)
%7575 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7576 = "mhlo.broadcast_in_dim"(%7575) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7577 = mhlo.shift_right_logical %7570, %7576 : tensor<1xui32> loc(#loc757)
%7578 = mhlo.or %7574, %7577 : tensor<1xui32> loc(#loc770)
%7579 = mhlo.xor %7571, %7578 : tensor<1xui32> loc(#loc766)
%7580 = mhlo.add %7571, %7579 : tensor<1xui32> loc(#loc768)
%7581 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7582 = "mhlo.broadcast_in_dim"(%7581) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7583 = mhlo.shift_left %7579, %7582 : tensor<1xui32> loc(#loc769)
%7584 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7585 = "mhlo.broadcast_in_dim"(%7584) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7586 = mhlo.shift_right_logical %7579, %7585 : tensor<1xui32> loc(#loc757)
%7587 = mhlo.or %7583, %7586 : tensor<1xui32> loc(#loc770)
%7588 = mhlo.xor %7580, %7587 : tensor<1xui32> loc(#loc766)
%7589 = mhlo.add %7580, %7588 : tensor<1xui32> loc(#loc768)
%7590 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7591 = "mhlo.broadcast_in_dim"(%7590) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7592 = mhlo.shift_left %7588, %7591 : tensor<1xui32> loc(#loc769)
%7593 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7594 = "mhlo.broadcast_in_dim"(%7593) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7595 = mhlo.shift_right_logical %7588, %7594 : tensor<1xui32> loc(#loc757)
%7596 = mhlo.or %7592, %7595 : tensor<1xui32> loc(#loc770)
%7597 = mhlo.xor %7589, %7596 : tensor<1xui32> loc(#loc766)
%7598 = mhlo.add %7589, %7597 : tensor<1xui32> loc(#loc768)
%7599 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7600 = "mhlo.broadcast_in_dim"(%7599) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7601 = mhlo.shift_left %7597, %7600 : tensor<1xui32> loc(#loc769)
%7602 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7603 = "mhlo.broadcast_in_dim"(%7602) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7604 = mhlo.shift_right_logical %7597, %7603 : tensor<1xui32> loc(#loc757)
%7605 = mhlo.or %7601, %7604 : tensor<1xui32> loc(#loc770)
%7606 = mhlo.xor %7598, %7605 : tensor<1xui32> loc(#loc766)
%7607 = "mhlo.broadcast_in_dim"(%7561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7608 = mhlo.add %7598, %7607 : tensor<1xui32> loc(#loc768)
%7609 = "mhlo.broadcast_in_dim"(%7566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7610 = mhlo.add %7606, %7609 : tensor<1xui32> loc(#loc768)
%7611 = mhlo.constant dense<1> : tensor<ui32> loc(#loc767)
%7612 = "mhlo.broadcast_in_dim"(%7611) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7613 = mhlo.add %7610, %7612 : tensor<1xui32> loc(#loc768)
%7614 = mhlo.add %7608, %7613 : tensor<1xui32> loc(#loc768)
%7615 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7616 = "mhlo.broadcast_in_dim"(%7615) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7617 = mhlo.shift_left %7613, %7616 : tensor<1xui32> loc(#loc769)
%7618 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7619 = "mhlo.broadcast_in_dim"(%7618) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7620 = mhlo.shift_right_logical %7613, %7619 : tensor<1xui32> loc(#loc757)
%7621 = mhlo.or %7617, %7620 : tensor<1xui32> loc(#loc770)
%7622 = mhlo.xor %7614, %7621 : tensor<1xui32> loc(#loc766)
%7623 = mhlo.add %7614, %7622 : tensor<1xui32> loc(#loc768)
%7624 = mhlo.constant dense<29> : tensor<ui32> loc(#loc767)
%7625 = "mhlo.broadcast_in_dim"(%7624) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7626 = mhlo.shift_left %7622, %7625 : tensor<1xui32> loc(#loc769)
%7627 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7628 = "mhlo.broadcast_in_dim"(%7627) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7629 = mhlo.shift_right_logical %7622, %7628 : tensor<1xui32> loc(#loc757)
%7630 = mhlo.or %7626, %7629 : tensor<1xui32> loc(#loc770)
%7631 = mhlo.xor %7623, %7630 : tensor<1xui32> loc(#loc766)
%7632 = mhlo.add %7623, %7631 : tensor<1xui32> loc(#loc768)
%7633 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7634 = "mhlo.broadcast_in_dim"(%7633) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7635 = mhlo.shift_left %7631, %7634 : tensor<1xui32> loc(#loc769)
%7636 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7637 = "mhlo.broadcast_in_dim"(%7636) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7638 = mhlo.shift_right_logical %7631, %7637 : tensor<1xui32> loc(#loc757)
%7639 = mhlo.or %7635, %7638 : tensor<1xui32> loc(#loc770)
%7640 = mhlo.xor %7632, %7639 : tensor<1xui32> loc(#loc766)
%7641 = mhlo.add %7632, %7640 : tensor<1xui32> loc(#loc768)
%7642 = mhlo.constant dense<24> : tensor<ui32> loc(#loc767)
%7643 = "mhlo.broadcast_in_dim"(%7642) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7644 = mhlo.shift_left %7640, %7643 : tensor<1xui32> loc(#loc769)
%7645 = mhlo.constant dense<8> : tensor<ui32> loc(#loc767)
%7646 = "mhlo.broadcast_in_dim"(%7645) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7647 = mhlo.shift_right_logical %7640, %7646 : tensor<1xui32> loc(#loc757)
%7648 = mhlo.or %7644, %7647 : tensor<1xui32> loc(#loc770)
%7649 = mhlo.xor %7641, %7648 : tensor<1xui32> loc(#loc766)
%7650 = "mhlo.broadcast_in_dim"(%7566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7651 = mhlo.add %7641, %7650 : tensor<1xui32> loc(#loc768)
%7652 = "mhlo.broadcast_in_dim"(%7559) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7653 = mhlo.add %7649, %7652 : tensor<1xui32> loc(#loc768)
%7654 = mhlo.constant dense<2> : tensor<ui32> loc(#loc767)
%7655 = "mhlo.broadcast_in_dim"(%7654) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7656 = mhlo.add %7653, %7655 : tensor<1xui32> loc(#loc768)
%7657 = mhlo.add %7651, %7656 : tensor<1xui32> loc(#loc768)
%7658 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7659 = "mhlo.broadcast_in_dim"(%7658) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7660 = mhlo.shift_left %7656, %7659 : tensor<1xui32> loc(#loc769)
%7661 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7662 = "mhlo.broadcast_in_dim"(%7661) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7663 = mhlo.shift_right_logical %7656, %7662 : tensor<1xui32> loc(#loc757)
%7664 = mhlo.or %7660, %7663 : tensor<1xui32> loc(#loc770)
%7665 = mhlo.xor %7657, %7664 : tensor<1xui32> loc(#loc766)
%7666 = mhlo.add %7657, %7665 : tensor<1xui32> loc(#loc768)
%7667 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7668 = "mhlo.broadcast_in_dim"(%7667) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7669 = mhlo.shift_left %7665, %7668 : tensor<1xui32> loc(#loc769)
%7670 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7671 = "mhlo.broadcast_in_dim"(%7670) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7672 = mhlo.shift_right_logical %7665, %7671 : tensor<1xui32> loc(#loc757)
%7673 = mhlo.or %7669, %7672 : tensor<1xui32> loc(#loc770)
%7674 = mhlo.xor %7666, %7673 : tensor<1xui32> loc(#loc766)
%7675 = mhlo.add %7666, %7674 : tensor<1xui32> loc(#loc768)
%7676 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7677 = "mhlo.broadcast_in_dim"(%7676) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7678 = mhlo.shift_left %7674, %7677 : tensor<1xui32> loc(#loc769)
%7679 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7680 = "mhlo.broadcast_in_dim"(%7679) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7681 = mhlo.shift_right_logical %7674, %7680 : tensor<1xui32> loc(#loc757)
%7682 = mhlo.or %7678, %7681 : tensor<1xui32> loc(#loc770)
%7683 = mhlo.xor %7675, %7682 : tensor<1xui32> loc(#loc766)
%7684 = mhlo.add %7675, %7683 : tensor<1xui32> loc(#loc768)
%7685 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7686 = "mhlo.broadcast_in_dim"(%7685) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7687 = mhlo.shift_left %7683, %7686 : tensor<1xui32> loc(#loc769)
%7688 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7689 = "mhlo.broadcast_in_dim"(%7688) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7690 = mhlo.shift_right_logical %7683, %7689 : tensor<1xui32> loc(#loc757)
%7691 = mhlo.or %7687, %7690 : tensor<1xui32> loc(#loc770)
%7692 = mhlo.xor %7684, %7691 : tensor<1xui32> loc(#loc766)
%7693 = "mhlo.broadcast_in_dim"(%7559) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7694 = mhlo.add %7684, %7693 : tensor<1xui32> loc(#loc768)
%7695 = "mhlo.broadcast_in_dim"(%7561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7696 = mhlo.add %7692, %7695 : tensor<1xui32> loc(#loc768)
%7697 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7698 = "mhlo.broadcast_in_dim"(%7697) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7699 = mhlo.add %7696, %7698 : tensor<1xui32> loc(#loc768)
%7700 = mhlo.add %7694, %7699 : tensor<1xui32> loc(#loc768)
%7701 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7702 = "mhlo.broadcast_in_dim"(%7701) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7703 = mhlo.shift_left %7699, %7702 : tensor<1xui32> loc(#loc769)
%7704 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7705 = "mhlo.broadcast_in_dim"(%7704) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7706 = mhlo.shift_right_logical %7699, %7705 : tensor<1xui32> loc(#loc757)
%7707 = mhlo.or %7703, %7706 : tensor<1xui32> loc(#loc770)
%7708 = mhlo.xor %7700, %7707 : tensor<1xui32> loc(#loc766)
%7709 = mhlo.add %7700, %7708 : tensor<1xui32> loc(#loc768)
%7710 = mhlo.constant dense<29> : tensor<ui32> loc(#loc767)
%7711 = "mhlo.broadcast_in_dim"(%7710) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7712 = mhlo.shift_left %7708, %7711 : tensor<1xui32> loc(#loc769)
%7713 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7714 = "mhlo.broadcast_in_dim"(%7713) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7715 = mhlo.shift_right_logical %7708, %7714 : tensor<1xui32> loc(#loc757)
%7716 = mhlo.or %7712, %7715 : tensor<1xui32> loc(#loc770)
%7717 = mhlo.xor %7709, %7716 : tensor<1xui32> loc(#loc766)
%7718 = mhlo.add %7709, %7717 : tensor<1xui32> loc(#loc768)
%7719 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7720 = "mhlo.broadcast_in_dim"(%7719) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7721 = mhlo.shift_left %7717, %7720 : tensor<1xui32> loc(#loc769)
%7722 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7723 = "mhlo.broadcast_in_dim"(%7722) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7724 = mhlo.shift_right_logical %7717, %7723 : tensor<1xui32> loc(#loc757)
%7725 = mhlo.or %7721, %7724 : tensor<1xui32> loc(#loc770)
%7726 = mhlo.xor %7718, %7725 : tensor<1xui32> loc(#loc766)
%7727 = mhlo.add %7718, %7726 : tensor<1xui32> loc(#loc768)
%7728 = mhlo.constant dense<24> : tensor<ui32> loc(#loc767)
%7729 = "mhlo.broadcast_in_dim"(%7728) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7730 = mhlo.shift_left %7726, %7729 : tensor<1xui32> loc(#loc769)
%7731 = mhlo.constant dense<8> : tensor<ui32> loc(#loc767)
%7732 = "mhlo.broadcast_in_dim"(%7731) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7733 = mhlo.shift_right_logical %7726, %7732 : tensor<1xui32> loc(#loc757)
%7734 = mhlo.or %7730, %7733 : tensor<1xui32> loc(#loc770)
%7735 = mhlo.xor %7727, %7734 : tensor<1xui32> loc(#loc766)
%7736 = "mhlo.broadcast_in_dim"(%7561) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7737 = mhlo.add %7727, %7736 : tensor<1xui32> loc(#loc768)
%7738 = "mhlo.broadcast_in_dim"(%7566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7739 = mhlo.add %7735, %7738 : tensor<1xui32> loc(#loc768)
%7740 = mhlo.constant dense<4> : tensor<ui32> loc(#loc767)
%7741 = "mhlo.broadcast_in_dim"(%7740) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7742 = mhlo.add %7739, %7741 : tensor<1xui32> loc(#loc768)
%7743 = mhlo.add %7737, %7742 : tensor<1xui32> loc(#loc768)
%7744 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7745 = "mhlo.broadcast_in_dim"(%7744) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7746 = mhlo.shift_left %7742, %7745 : tensor<1xui32> loc(#loc769)
%7747 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7748 = "mhlo.broadcast_in_dim"(%7747) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7749 = mhlo.shift_right_logical %7742, %7748 : tensor<1xui32> loc(#loc757)
%7750 = mhlo.or %7746, %7749 : tensor<1xui32> loc(#loc770)
%7751 = mhlo.xor %7743, %7750 : tensor<1xui32> loc(#loc766)
%7752 = mhlo.add %7743, %7751 : tensor<1xui32> loc(#loc768)
%7753 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7754 = "mhlo.broadcast_in_dim"(%7753) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7755 = mhlo.shift_left %7751, %7754 : tensor<1xui32> loc(#loc769)
%7756 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7757 = "mhlo.broadcast_in_dim"(%7756) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7758 = mhlo.shift_right_logical %7751, %7757 : tensor<1xui32> loc(#loc757)
%7759 = mhlo.or %7755, %7758 : tensor<1xui32> loc(#loc770)
%7760 = mhlo.xor %7752, %7759 : tensor<1xui32> loc(#loc766)
%7761 = mhlo.add %7752, %7760 : tensor<1xui32> loc(#loc768)
%7762 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7763 = "mhlo.broadcast_in_dim"(%7762) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7764 = mhlo.shift_left %7760, %7763 : tensor<1xui32> loc(#loc769)
%7765 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7766 = "mhlo.broadcast_in_dim"(%7765) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7767 = mhlo.shift_right_logical %7760, %7766 : tensor<1xui32> loc(#loc757)
%7768 = mhlo.or %7764, %7767 : tensor<1xui32> loc(#loc770)
%7769 = mhlo.xor %7761, %7768 : tensor<1xui32> loc(#loc766)
%7770 = mhlo.add %7761, %7769 : tensor<1xui32> loc(#loc768)
%7771 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7772 = "mhlo.broadcast_in_dim"(%7771) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7773 = mhlo.shift_left %7769, %7772 : tensor<1xui32> loc(#loc769)
%7774 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7775 = "mhlo.broadcast_in_dim"(%7774) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7776 = mhlo.shift_right_logical %7769, %7775 : tensor<1xui32> loc(#loc757)
%7777 = mhlo.or %7773, %7776 : tensor<1xui32> loc(#loc770)
%7778 = mhlo.xor %7770, %7777 : tensor<1xui32> loc(#loc766)
%7779 = "mhlo.broadcast_in_dim"(%7566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7780 = mhlo.add %7770, %7779 : tensor<1xui32> loc(#loc768)
%7781 = "mhlo.broadcast_in_dim"(%7559) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7782 = mhlo.add %7778, %7781 : tensor<1xui32> loc(#loc768)
%7783 = mhlo.constant dense<5> : tensor<ui32> loc(#loc767)
%7784 = "mhlo.broadcast_in_dim"(%7783) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7785 = mhlo.add %7782, %7784 : tensor<1xui32> loc(#loc768)
%7786 = "mhlo.concatenate"(%7780, %7785) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc760)
%7787 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%7788 = "mhlo.broadcast_in_dim"(%7787) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc771)
%7789 = "mhlo.reshape"(%7788) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc772)
%7790 = "mhlo.broadcast_in_dim"(%7549) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc773)
%7791 = "mhlo.broadcast_in_dim"(%7789) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc773)
%7792 = mhlo.multiply %7790, %7791 : tensor<1x256x2048xf32> loc(#loc773)
%7793 = mhlo.multiply %7545, %7792 : tensor<1x256x2048xf32> loc(#loc774)
%7794 = mhlo.constant dense<278488581> : tensor<ui32> loc(#loc531)
%7795 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%7796 = mhlo.shift_right_logical %7794, %7795 : tensor<ui32> loc(#loc757)
%7797 = "mhlo.reshape"(%7796) : (tensor<ui32>) -> tensor<1xui32> loc(#loc758)
%7798 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%7799 = mhlo.and %7794, %7798 : tensor<ui32> loc(#loc759)
%7800 = "mhlo.reshape"(%7799) : (tensor<ui32>) -> tensor<1xui32> loc(#loc758)
%7801 = "mhlo.concatenate"(%7797, %7800) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc760)
%7802 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc761)
%7803 = "mhlo.reshape"(%7802) : (tensor<1xui32>) -> tensor<ui32> loc(#loc762)
%7804 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc763)
%7805 = "mhlo.reshape"(%7804) : (tensor<1xui32>) -> tensor<ui32> loc(#loc762)
%7806 = "mhlo.slice"(%7801) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc764)
%7807 = "mhlo.slice"(%7801) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc765)
%7808 = mhlo.xor %7803, %7805 : tensor<ui32> loc(#loc766)
%7809 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc767)
%7810 = mhlo.xor %7808, %7809 : tensor<ui32> loc(#loc766)
%7811 = "mhlo.broadcast_in_dim"(%7803) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7812 = mhlo.add %7806, %7811 : tensor<1xui32> loc(#loc768)
%7813 = "mhlo.broadcast_in_dim"(%7805) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7814 = mhlo.add %7807, %7813 : tensor<1xui32> loc(#loc768)
%7815 = mhlo.add %7812, %7814 : tensor<1xui32> loc(#loc768)
%7816 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7817 = "mhlo.broadcast_in_dim"(%7816) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7818 = mhlo.shift_left %7814, %7817 : tensor<1xui32> loc(#loc769)
%7819 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7820 = "mhlo.broadcast_in_dim"(%7819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7821 = mhlo.shift_right_logical %7814, %7820 : tensor<1xui32> loc(#loc757)
%7822 = mhlo.or %7818, %7821 : tensor<1xui32> loc(#loc770)
%7823 = mhlo.xor %7815, %7822 : tensor<1xui32> loc(#loc766)
%7824 = mhlo.add %7815, %7823 : tensor<1xui32> loc(#loc768)
%7825 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7826 = "mhlo.broadcast_in_dim"(%7825) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7827 = mhlo.shift_left %7823, %7826 : tensor<1xui32> loc(#loc769)
%7828 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7829 = "mhlo.broadcast_in_dim"(%7828) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7830 = mhlo.shift_right_logical %7823, %7829 : tensor<1xui32> loc(#loc757)
%7831 = mhlo.or %7827, %7830 : tensor<1xui32> loc(#loc770)
%7832 = mhlo.xor %7824, %7831 : tensor<1xui32> loc(#loc766)
%7833 = mhlo.add %7824, %7832 : tensor<1xui32> loc(#loc768)
%7834 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7835 = "mhlo.broadcast_in_dim"(%7834) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7836 = mhlo.shift_left %7832, %7835 : tensor<1xui32> loc(#loc769)
%7837 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7838 = "mhlo.broadcast_in_dim"(%7837) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7839 = mhlo.shift_right_logical %7832, %7838 : tensor<1xui32> loc(#loc757)
%7840 = mhlo.or %7836, %7839 : tensor<1xui32> loc(#loc770)
%7841 = mhlo.xor %7833, %7840 : tensor<1xui32> loc(#loc766)
%7842 = mhlo.add %7833, %7841 : tensor<1xui32> loc(#loc768)
%7843 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7844 = "mhlo.broadcast_in_dim"(%7843) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7845 = mhlo.shift_left %7841, %7844 : tensor<1xui32> loc(#loc769)
%7846 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7847 = "mhlo.broadcast_in_dim"(%7846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7848 = mhlo.shift_right_logical %7841, %7847 : tensor<1xui32> loc(#loc757)
%7849 = mhlo.or %7845, %7848 : tensor<1xui32> loc(#loc770)
%7850 = mhlo.xor %7842, %7849 : tensor<1xui32> loc(#loc766)
%7851 = "mhlo.broadcast_in_dim"(%7805) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7852 = mhlo.add %7842, %7851 : tensor<1xui32> loc(#loc768)
%7853 = "mhlo.broadcast_in_dim"(%7810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7854 = mhlo.add %7850, %7853 : tensor<1xui32> loc(#loc768)
%7855 = mhlo.constant dense<1> : tensor<ui32> loc(#loc767)
%7856 = "mhlo.broadcast_in_dim"(%7855) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7857 = mhlo.add %7854, %7856 : tensor<1xui32> loc(#loc768)
%7858 = mhlo.add %7852, %7857 : tensor<1xui32> loc(#loc768)
%7859 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7860 = "mhlo.broadcast_in_dim"(%7859) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7861 = mhlo.shift_left %7857, %7860 : tensor<1xui32> loc(#loc769)
%7862 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7863 = "mhlo.broadcast_in_dim"(%7862) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7864 = mhlo.shift_right_logical %7857, %7863 : tensor<1xui32> loc(#loc757)
%7865 = mhlo.or %7861, %7864 : tensor<1xui32> loc(#loc770)
%7866 = mhlo.xor %7858, %7865 : tensor<1xui32> loc(#loc766)
%7867 = mhlo.add %7858, %7866 : tensor<1xui32> loc(#loc768)
%7868 = mhlo.constant dense<29> : tensor<ui32> loc(#loc767)
%7869 = "mhlo.broadcast_in_dim"(%7868) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7870 = mhlo.shift_left %7866, %7869 : tensor<1xui32> loc(#loc769)
%7871 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7872 = "mhlo.broadcast_in_dim"(%7871) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7873 = mhlo.shift_right_logical %7866, %7872 : tensor<1xui32> loc(#loc757)
%7874 = mhlo.or %7870, %7873 : tensor<1xui32> loc(#loc770)
%7875 = mhlo.xor %7867, %7874 : tensor<1xui32> loc(#loc766)
%7876 = mhlo.add %7867, %7875 : tensor<1xui32> loc(#loc768)
%7877 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7878 = "mhlo.broadcast_in_dim"(%7877) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7879 = mhlo.shift_left %7875, %7878 : tensor<1xui32> loc(#loc769)
%7880 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7881 = "mhlo.broadcast_in_dim"(%7880) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7882 = mhlo.shift_right_logical %7875, %7881 : tensor<1xui32> loc(#loc757)
%7883 = mhlo.or %7879, %7882 : tensor<1xui32> loc(#loc770)
%7884 = mhlo.xor %7876, %7883 : tensor<1xui32> loc(#loc766)
%7885 = mhlo.add %7876, %7884 : tensor<1xui32> loc(#loc768)
%7886 = mhlo.constant dense<24> : tensor<ui32> loc(#loc767)
%7887 = "mhlo.broadcast_in_dim"(%7886) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7888 = mhlo.shift_left %7884, %7887 : tensor<1xui32> loc(#loc769)
%7889 = mhlo.constant dense<8> : tensor<ui32> loc(#loc767)
%7890 = "mhlo.broadcast_in_dim"(%7889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7891 = mhlo.shift_right_logical %7884, %7890 : tensor<1xui32> loc(#loc757)
%7892 = mhlo.or %7888, %7891 : tensor<1xui32> loc(#loc770)
%7893 = mhlo.xor %7885, %7892 : tensor<1xui32> loc(#loc766)
%7894 = "mhlo.broadcast_in_dim"(%7810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7895 = mhlo.add %7885, %7894 : tensor<1xui32> loc(#loc768)
%7896 = "mhlo.broadcast_in_dim"(%7803) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7897 = mhlo.add %7893, %7896 : tensor<1xui32> loc(#loc768)
%7898 = mhlo.constant dense<2> : tensor<ui32> loc(#loc767)
%7899 = "mhlo.broadcast_in_dim"(%7898) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7900 = mhlo.add %7897, %7899 : tensor<1xui32> loc(#loc768)
%7901 = mhlo.add %7895, %7900 : tensor<1xui32> loc(#loc768)
%7902 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7903 = "mhlo.broadcast_in_dim"(%7902) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7904 = mhlo.shift_left %7900, %7903 : tensor<1xui32> loc(#loc769)
%7905 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7906 = "mhlo.broadcast_in_dim"(%7905) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7907 = mhlo.shift_right_logical %7900, %7906 : tensor<1xui32> loc(#loc757)
%7908 = mhlo.or %7904, %7907 : tensor<1xui32> loc(#loc770)
%7909 = mhlo.xor %7901, %7908 : tensor<1xui32> loc(#loc766)
%7910 = mhlo.add %7901, %7909 : tensor<1xui32> loc(#loc768)
%7911 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7912 = "mhlo.broadcast_in_dim"(%7911) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7913 = mhlo.shift_left %7909, %7912 : tensor<1xui32> loc(#loc769)
%7914 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7915 = "mhlo.broadcast_in_dim"(%7914) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7916 = mhlo.shift_right_logical %7909, %7915 : tensor<1xui32> loc(#loc757)
%7917 = mhlo.or %7913, %7916 : tensor<1xui32> loc(#loc770)
%7918 = mhlo.xor %7910, %7917 : tensor<1xui32> loc(#loc766)
%7919 = mhlo.add %7910, %7918 : tensor<1xui32> loc(#loc768)
%7920 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7921 = "mhlo.broadcast_in_dim"(%7920) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7922 = mhlo.shift_left %7918, %7921 : tensor<1xui32> loc(#loc769)
%7923 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7924 = "mhlo.broadcast_in_dim"(%7923) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7925 = mhlo.shift_right_logical %7918, %7924 : tensor<1xui32> loc(#loc757)
%7926 = mhlo.or %7922, %7925 : tensor<1xui32> loc(#loc770)
%7927 = mhlo.xor %7919, %7926 : tensor<1xui32> loc(#loc766)
%7928 = mhlo.add %7919, %7927 : tensor<1xui32> loc(#loc768)
%7929 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%7930 = "mhlo.broadcast_in_dim"(%7929) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7931 = mhlo.shift_left %7927, %7930 : tensor<1xui32> loc(#loc769)
%7932 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%7933 = "mhlo.broadcast_in_dim"(%7932) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7934 = mhlo.shift_right_logical %7927, %7933 : tensor<1xui32> loc(#loc757)
%7935 = mhlo.or %7931, %7934 : tensor<1xui32> loc(#loc770)
%7936 = mhlo.xor %7928, %7935 : tensor<1xui32> loc(#loc766)
%7937 = "mhlo.broadcast_in_dim"(%7803) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7938 = mhlo.add %7928, %7937 : tensor<1xui32> loc(#loc768)
%7939 = "mhlo.broadcast_in_dim"(%7805) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7940 = mhlo.add %7936, %7939 : tensor<1xui32> loc(#loc768)
%7941 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7942 = "mhlo.broadcast_in_dim"(%7941) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7943 = mhlo.add %7940, %7942 : tensor<1xui32> loc(#loc768)
%7944 = mhlo.add %7938, %7943 : tensor<1xui32> loc(#loc768)
%7945 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%7946 = "mhlo.broadcast_in_dim"(%7945) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7947 = mhlo.shift_left %7943, %7946 : tensor<1xui32> loc(#loc769)
%7948 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7949 = "mhlo.broadcast_in_dim"(%7948) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7950 = mhlo.shift_right_logical %7943, %7949 : tensor<1xui32> loc(#loc757)
%7951 = mhlo.or %7947, %7950 : tensor<1xui32> loc(#loc770)
%7952 = mhlo.xor %7944, %7951 : tensor<1xui32> loc(#loc766)
%7953 = mhlo.add %7944, %7952 : tensor<1xui32> loc(#loc768)
%7954 = mhlo.constant dense<29> : tensor<ui32> loc(#loc767)
%7955 = "mhlo.broadcast_in_dim"(%7954) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7956 = mhlo.shift_left %7952, %7955 : tensor<1xui32> loc(#loc769)
%7957 = mhlo.constant dense<3> : tensor<ui32> loc(#loc767)
%7958 = "mhlo.broadcast_in_dim"(%7957) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7959 = mhlo.shift_right_logical %7952, %7958 : tensor<1xui32> loc(#loc757)
%7960 = mhlo.or %7956, %7959 : tensor<1xui32> loc(#loc770)
%7961 = mhlo.xor %7953, %7960 : tensor<1xui32> loc(#loc766)
%7962 = mhlo.add %7953, %7961 : tensor<1xui32> loc(#loc768)
%7963 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7964 = "mhlo.broadcast_in_dim"(%7963) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7965 = mhlo.shift_left %7961, %7964 : tensor<1xui32> loc(#loc769)
%7966 = mhlo.constant dense<16> : tensor<ui32> loc(#loc767)
%7967 = "mhlo.broadcast_in_dim"(%7966) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7968 = mhlo.shift_right_logical %7961, %7967 : tensor<1xui32> loc(#loc757)
%7969 = mhlo.or %7965, %7968 : tensor<1xui32> loc(#loc770)
%7970 = mhlo.xor %7962, %7969 : tensor<1xui32> loc(#loc766)
%7971 = mhlo.add %7962, %7970 : tensor<1xui32> loc(#loc768)
%7972 = mhlo.constant dense<24> : tensor<ui32> loc(#loc767)
%7973 = "mhlo.broadcast_in_dim"(%7972) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7974 = mhlo.shift_left %7970, %7973 : tensor<1xui32> loc(#loc769)
%7975 = mhlo.constant dense<8> : tensor<ui32> loc(#loc767)
%7976 = "mhlo.broadcast_in_dim"(%7975) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7977 = mhlo.shift_right_logical %7970, %7976 : tensor<1xui32> loc(#loc757)
%7978 = mhlo.or %7974, %7977 : tensor<1xui32> loc(#loc770)
%7979 = mhlo.xor %7971, %7978 : tensor<1xui32> loc(#loc766)
%7980 = "mhlo.broadcast_in_dim"(%7805) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7981 = mhlo.add %7971, %7980 : tensor<1xui32> loc(#loc768)
%7982 = "mhlo.broadcast_in_dim"(%7810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7983 = mhlo.add %7979, %7982 : tensor<1xui32> loc(#loc768)
%7984 = mhlo.constant dense<4> : tensor<ui32> loc(#loc767)
%7985 = "mhlo.broadcast_in_dim"(%7984) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%7986 = mhlo.add %7983, %7985 : tensor<1xui32> loc(#loc768)
%7987 = mhlo.add %7981, %7986 : tensor<1xui32> loc(#loc768)
%7988 = mhlo.constant dense<13> : tensor<ui32> loc(#loc767)
%7989 = "mhlo.broadcast_in_dim"(%7988) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7990 = mhlo.shift_left %7986, %7989 : tensor<1xui32> loc(#loc769)
%7991 = mhlo.constant dense<19> : tensor<ui32> loc(#loc767)
%7992 = "mhlo.broadcast_in_dim"(%7991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%7993 = mhlo.shift_right_logical %7986, %7992 : tensor<1xui32> loc(#loc757)
%7994 = mhlo.or %7990, %7993 : tensor<1xui32> loc(#loc770)
%7995 = mhlo.xor %7987, %7994 : tensor<1xui32> loc(#loc766)
%7996 = mhlo.add %7987, %7995 : tensor<1xui32> loc(#loc768)
%7997 = mhlo.constant dense<15> : tensor<ui32> loc(#loc767)
%7998 = "mhlo.broadcast_in_dim"(%7997) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%7999 = mhlo.shift_left %7995, %7998 : tensor<1xui32> loc(#loc769)
%8000 = mhlo.constant dense<17> : tensor<ui32> loc(#loc767)
%8001 = "mhlo.broadcast_in_dim"(%8000) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%8002 = mhlo.shift_right_logical %7995, %8001 : tensor<1xui32> loc(#loc757)
%8003 = mhlo.or %7999, %8002 : tensor<1xui32> loc(#loc770)
%8004 = mhlo.xor %7996, %8003 : tensor<1xui32> loc(#loc766)
%8005 = mhlo.add %7996, %8004 : tensor<1xui32> loc(#loc768)
%8006 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%8007 = "mhlo.broadcast_in_dim"(%8006) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%8008 = mhlo.shift_left %8004, %8007 : tensor<1xui32> loc(#loc769)
%8009 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%8010 = "mhlo.broadcast_in_dim"(%8009) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%8011 = mhlo.shift_right_logical %8004, %8010 : tensor<1xui32> loc(#loc757)
%8012 = mhlo.or %8008, %8011 : tensor<1xui32> loc(#loc770)
%8013 = mhlo.xor %8005, %8012 : tensor<1xui32> loc(#loc766)
%8014 = mhlo.add %8005, %8013 : tensor<1xui32> loc(#loc768)
%8015 = mhlo.constant dense<6> : tensor<ui32> loc(#loc767)
%8016 = "mhlo.broadcast_in_dim"(%8015) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc769)
%8017 = mhlo.shift_left %8013, %8016 : tensor<1xui32> loc(#loc769)
%8018 = mhlo.constant dense<26> : tensor<ui32> loc(#loc767)
%8019 = "mhlo.broadcast_in_dim"(%8018) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc757)
%8020 = mhlo.shift_right_logical %8013, %8019 : tensor<1xui32> loc(#loc757)
%8021 = mhlo.or %8017, %8020 : tensor<1xui32> loc(#loc770)
%8022 = mhlo.xor %8014, %8021 : tensor<1xui32> loc(#loc766)
%8023 = "mhlo.broadcast_in_dim"(%7810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%8024 = mhlo.add %8014, %8023 : tensor<1xui32> loc(#loc768)
%8025 = "mhlo.broadcast_in_dim"(%7803) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%8026 = mhlo.add %8022, %8025 : tensor<1xui32> loc(#loc768)
%8027 = mhlo.constant dense<5> : tensor<ui32> loc(#loc767)
%8028 = "mhlo.broadcast_in_dim"(%8027) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc768)
%8029 = mhlo.add %8026, %8028 : tensor<1xui32> loc(#loc768)
%8030 = "mhlo.concatenate"(%8024, %8029) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc760)
%8031 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%8032 = "mhlo.broadcast_in_dim"(%8031) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc771)
%8033 = "mhlo.reshape"(%8032) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc775)
%8034 = "mhlo.broadcast_in_dim"(%8033) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc776)
%8035 = mhlo.add %7793, %8034 : tensor<1x256x2048xf32> loc(#loc776)
%8036 = mhlo.convert(%8035) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc777)
%8037 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc531)
%8038 = "mhlo.broadcast_in_dim"(%8037) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x2048xf16> loc(#loc778)
%8039 = mhlo.multiply %iterArg_3, %8038 : tensor<1x256x2048xf16> loc(#loc778)
%8040 = mhlo.add %8039, %8036 : tensor<1x256x2048xf16> loc(#loc779)
%8041 = mhlo.convert(%8040) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc780)
%8042 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc781)
%8043 = mhlo.reduce(%8041 init: %8042) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc781)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc781)
} loc(#loc781)
%8044 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%8045 = "mhlo.broadcast_in_dim"(%8044) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc782)
%8046 = mhlo.divide %8043, %8045 : tensor<1x256xf32> loc(#loc782)
%8047 = mhlo.multiply %8041, %8041 : tensor<1x256x2048xf32> loc(#loc783)
%8048 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc784)
%8049 = mhlo.reduce(%8047 init: %8048) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc784)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc784)
} loc(#loc784)
%8050 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%8051 = "mhlo.broadcast_in_dim"(%8050) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc785)
%8052 = mhlo.divide %8049, %8051 : tensor<1x256xf32> loc(#loc785)
%8053 = mhlo.multiply %8046, %8046 : tensor<1x256xf32> loc(#loc783)
%8054 = mhlo.subtract %8052, %8053 : tensor<1x256xf32> loc(#loc786)
%8055 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%8056 = "mhlo.broadcast_in_dim"(%8055) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc787)
%8057 = mhlo.maximum %8056, %8054 : tensor<1x256xf32> loc(#loc787)
%8058 = "mhlo.reshape"(%8046) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc788)
%8059 = "mhlo.reshape"(%8057) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc789)
%8060 = mhlo.convert(%8040) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc790)
%8061 = "mhlo.broadcast_in_dim"(%8058) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc791)
%8062 = mhlo.subtract %8060, %8061 : tensor<1x256x2048xf32> loc(#loc791)
%8063 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc531)
%8064 = "mhlo.broadcast_in_dim"(%8063) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc792)
%8065 = mhlo.add %8059, %8064 : tensor<1x256x1xf32> loc(#loc792)
%8066 = mhlo.rsqrt %8065 : tensor<1x256x1xf32> loc(#loc793)
%8067 = "mhlo.broadcast_in_dim"(%8066) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc794)
%8068 = mhlo.multiply %8062, %8067 : tensor<1x256x2048xf32> loc(#loc794)
%8069 = mhlo.constant dense<4268539516> : tensor<ui32> loc(#loc531)
%8070 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%8071 = mhlo.shift_right_logical %8069, %8070 : tensor<ui32> loc(#loc795)
%8072 = "mhlo.reshape"(%8071) : (tensor<ui32>) -> tensor<1xui32> loc(#loc796)
%8073 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%8074 = mhlo.and %8069, %8073 : tensor<ui32> loc(#loc797)
%8075 = "mhlo.reshape"(%8074) : (tensor<ui32>) -> tensor<1xui32> loc(#loc796)
%8076 = "mhlo.concatenate"(%8072, %8075) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc798)
%8077 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc799)
%8078 = "mhlo.reshape"(%8077) : (tensor<1xui32>) -> tensor<ui32> loc(#loc800)
%8079 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc801)
%8080 = "mhlo.reshape"(%8079) : (tensor<1xui32>) -> tensor<ui32> loc(#loc800)
%8081 = "mhlo.slice"(%8076) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc802)
%8082 = "mhlo.slice"(%8076) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc803)
%8083 = mhlo.xor %8078, %8080 : tensor<ui32> loc(#loc804)
%8084 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc805)
%8085 = mhlo.xor %8083, %8084 : tensor<ui32> loc(#loc804)
%8086 = "mhlo.broadcast_in_dim"(%8078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8087 = mhlo.add %8081, %8086 : tensor<1xui32> loc(#loc806)
%8088 = "mhlo.broadcast_in_dim"(%8080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8089 = mhlo.add %8082, %8088 : tensor<1xui32> loc(#loc806)
%8090 = mhlo.add %8087, %8089 : tensor<1xui32> loc(#loc806)
%8091 = mhlo.constant dense<13> : tensor<ui32> loc(#loc805)
%8092 = "mhlo.broadcast_in_dim"(%8091) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8093 = mhlo.shift_left %8089, %8092 : tensor<1xui32> loc(#loc807)
%8094 = mhlo.constant dense<19> : tensor<ui32> loc(#loc805)
%8095 = "mhlo.broadcast_in_dim"(%8094) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8096 = mhlo.shift_right_logical %8089, %8095 : tensor<1xui32> loc(#loc795)
%8097 = mhlo.or %8093, %8096 : tensor<1xui32> loc(#loc808)
%8098 = mhlo.xor %8090, %8097 : tensor<1xui32> loc(#loc804)
%8099 = mhlo.add %8090, %8098 : tensor<1xui32> loc(#loc806)
%8100 = mhlo.constant dense<15> : tensor<ui32> loc(#loc805)
%8101 = "mhlo.broadcast_in_dim"(%8100) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8102 = mhlo.shift_left %8098, %8101 : tensor<1xui32> loc(#loc807)
%8103 = mhlo.constant dense<17> : tensor<ui32> loc(#loc805)
%8104 = "mhlo.broadcast_in_dim"(%8103) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8105 = mhlo.shift_right_logical %8098, %8104 : tensor<1xui32> loc(#loc795)
%8106 = mhlo.or %8102, %8105 : tensor<1xui32> loc(#loc808)
%8107 = mhlo.xor %8099, %8106 : tensor<1xui32> loc(#loc804)
%8108 = mhlo.add %8099, %8107 : tensor<1xui32> loc(#loc806)
%8109 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8110 = "mhlo.broadcast_in_dim"(%8109) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8111 = mhlo.shift_left %8107, %8110 : tensor<1xui32> loc(#loc807)
%8112 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8113 = "mhlo.broadcast_in_dim"(%8112) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8114 = mhlo.shift_right_logical %8107, %8113 : tensor<1xui32> loc(#loc795)
%8115 = mhlo.or %8111, %8114 : tensor<1xui32> loc(#loc808)
%8116 = mhlo.xor %8108, %8115 : tensor<1xui32> loc(#loc804)
%8117 = mhlo.add %8108, %8116 : tensor<1xui32> loc(#loc806)
%8118 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8119 = "mhlo.broadcast_in_dim"(%8118) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8120 = mhlo.shift_left %8116, %8119 : tensor<1xui32> loc(#loc807)
%8121 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8122 = "mhlo.broadcast_in_dim"(%8121) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8123 = mhlo.shift_right_logical %8116, %8122 : tensor<1xui32> loc(#loc795)
%8124 = mhlo.or %8120, %8123 : tensor<1xui32> loc(#loc808)
%8125 = mhlo.xor %8117, %8124 : tensor<1xui32> loc(#loc804)
%8126 = "mhlo.broadcast_in_dim"(%8080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8127 = mhlo.add %8117, %8126 : tensor<1xui32> loc(#loc806)
%8128 = "mhlo.broadcast_in_dim"(%8085) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8129 = mhlo.add %8125, %8128 : tensor<1xui32> loc(#loc806)
%8130 = mhlo.constant dense<1> : tensor<ui32> loc(#loc805)
%8131 = "mhlo.broadcast_in_dim"(%8130) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8132 = mhlo.add %8129, %8131 : tensor<1xui32> loc(#loc806)
%8133 = mhlo.add %8127, %8132 : tensor<1xui32> loc(#loc806)
%8134 = mhlo.constant dense<17> : tensor<ui32> loc(#loc805)
%8135 = "mhlo.broadcast_in_dim"(%8134) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8136 = mhlo.shift_left %8132, %8135 : tensor<1xui32> loc(#loc807)
%8137 = mhlo.constant dense<15> : tensor<ui32> loc(#loc805)
%8138 = "mhlo.broadcast_in_dim"(%8137) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8139 = mhlo.shift_right_logical %8132, %8138 : tensor<1xui32> loc(#loc795)
%8140 = mhlo.or %8136, %8139 : tensor<1xui32> loc(#loc808)
%8141 = mhlo.xor %8133, %8140 : tensor<1xui32> loc(#loc804)
%8142 = mhlo.add %8133, %8141 : tensor<1xui32> loc(#loc806)
%8143 = mhlo.constant dense<29> : tensor<ui32> loc(#loc805)
%8144 = "mhlo.broadcast_in_dim"(%8143) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8145 = mhlo.shift_left %8141, %8144 : tensor<1xui32> loc(#loc807)
%8146 = mhlo.constant dense<3> : tensor<ui32> loc(#loc805)
%8147 = "mhlo.broadcast_in_dim"(%8146) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8148 = mhlo.shift_right_logical %8141, %8147 : tensor<1xui32> loc(#loc795)
%8149 = mhlo.or %8145, %8148 : tensor<1xui32> loc(#loc808)
%8150 = mhlo.xor %8142, %8149 : tensor<1xui32> loc(#loc804)
%8151 = mhlo.add %8142, %8150 : tensor<1xui32> loc(#loc806)
%8152 = mhlo.constant dense<16> : tensor<ui32> loc(#loc805)
%8153 = "mhlo.broadcast_in_dim"(%8152) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8154 = mhlo.shift_left %8150, %8153 : tensor<1xui32> loc(#loc807)
%8155 = mhlo.constant dense<16> : tensor<ui32> loc(#loc805)
%8156 = "mhlo.broadcast_in_dim"(%8155) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8157 = mhlo.shift_right_logical %8150, %8156 : tensor<1xui32> loc(#loc795)
%8158 = mhlo.or %8154, %8157 : tensor<1xui32> loc(#loc808)
%8159 = mhlo.xor %8151, %8158 : tensor<1xui32> loc(#loc804)
%8160 = mhlo.add %8151, %8159 : tensor<1xui32> loc(#loc806)
%8161 = mhlo.constant dense<24> : tensor<ui32> loc(#loc805)
%8162 = "mhlo.broadcast_in_dim"(%8161) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8163 = mhlo.shift_left %8159, %8162 : tensor<1xui32> loc(#loc807)
%8164 = mhlo.constant dense<8> : tensor<ui32> loc(#loc805)
%8165 = "mhlo.broadcast_in_dim"(%8164) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8166 = mhlo.shift_right_logical %8159, %8165 : tensor<1xui32> loc(#loc795)
%8167 = mhlo.or %8163, %8166 : tensor<1xui32> loc(#loc808)
%8168 = mhlo.xor %8160, %8167 : tensor<1xui32> loc(#loc804)
%8169 = "mhlo.broadcast_in_dim"(%8085) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8170 = mhlo.add %8160, %8169 : tensor<1xui32> loc(#loc806)
%8171 = "mhlo.broadcast_in_dim"(%8078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8172 = mhlo.add %8168, %8171 : tensor<1xui32> loc(#loc806)
%8173 = mhlo.constant dense<2> : tensor<ui32> loc(#loc805)
%8174 = "mhlo.broadcast_in_dim"(%8173) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8175 = mhlo.add %8172, %8174 : tensor<1xui32> loc(#loc806)
%8176 = mhlo.add %8170, %8175 : tensor<1xui32> loc(#loc806)
%8177 = mhlo.constant dense<13> : tensor<ui32> loc(#loc805)
%8178 = "mhlo.broadcast_in_dim"(%8177) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8179 = mhlo.shift_left %8175, %8178 : tensor<1xui32> loc(#loc807)
%8180 = mhlo.constant dense<19> : tensor<ui32> loc(#loc805)
%8181 = "mhlo.broadcast_in_dim"(%8180) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8182 = mhlo.shift_right_logical %8175, %8181 : tensor<1xui32> loc(#loc795)
%8183 = mhlo.or %8179, %8182 : tensor<1xui32> loc(#loc808)
%8184 = mhlo.xor %8176, %8183 : tensor<1xui32> loc(#loc804)
%8185 = mhlo.add %8176, %8184 : tensor<1xui32> loc(#loc806)
%8186 = mhlo.constant dense<15> : tensor<ui32> loc(#loc805)
%8187 = "mhlo.broadcast_in_dim"(%8186) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8188 = mhlo.shift_left %8184, %8187 : tensor<1xui32> loc(#loc807)
%8189 = mhlo.constant dense<17> : tensor<ui32> loc(#loc805)
%8190 = "mhlo.broadcast_in_dim"(%8189) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8191 = mhlo.shift_right_logical %8184, %8190 : tensor<1xui32> loc(#loc795)
%8192 = mhlo.or %8188, %8191 : tensor<1xui32> loc(#loc808)
%8193 = mhlo.xor %8185, %8192 : tensor<1xui32> loc(#loc804)
%8194 = mhlo.add %8185, %8193 : tensor<1xui32> loc(#loc806)
%8195 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8196 = "mhlo.broadcast_in_dim"(%8195) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8197 = mhlo.shift_left %8193, %8196 : tensor<1xui32> loc(#loc807)
%8198 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8199 = "mhlo.broadcast_in_dim"(%8198) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8200 = mhlo.shift_right_logical %8193, %8199 : tensor<1xui32> loc(#loc795)
%8201 = mhlo.or %8197, %8200 : tensor<1xui32> loc(#loc808)
%8202 = mhlo.xor %8194, %8201 : tensor<1xui32> loc(#loc804)
%8203 = mhlo.add %8194, %8202 : tensor<1xui32> loc(#loc806)
%8204 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8205 = "mhlo.broadcast_in_dim"(%8204) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8206 = mhlo.shift_left %8202, %8205 : tensor<1xui32> loc(#loc807)
%8207 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8208 = "mhlo.broadcast_in_dim"(%8207) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8209 = mhlo.shift_right_logical %8202, %8208 : tensor<1xui32> loc(#loc795)
%8210 = mhlo.or %8206, %8209 : tensor<1xui32> loc(#loc808)
%8211 = mhlo.xor %8203, %8210 : tensor<1xui32> loc(#loc804)
%8212 = "mhlo.broadcast_in_dim"(%8078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8213 = mhlo.add %8203, %8212 : tensor<1xui32> loc(#loc806)
%8214 = "mhlo.broadcast_in_dim"(%8080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8215 = mhlo.add %8211, %8214 : tensor<1xui32> loc(#loc806)
%8216 = mhlo.constant dense<3> : tensor<ui32> loc(#loc805)
%8217 = "mhlo.broadcast_in_dim"(%8216) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8218 = mhlo.add %8215, %8217 : tensor<1xui32> loc(#loc806)
%8219 = mhlo.add %8213, %8218 : tensor<1xui32> loc(#loc806)
%8220 = mhlo.constant dense<17> : tensor<ui32> loc(#loc805)
%8221 = "mhlo.broadcast_in_dim"(%8220) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8222 = mhlo.shift_left %8218, %8221 : tensor<1xui32> loc(#loc807)
%8223 = mhlo.constant dense<15> : tensor<ui32> loc(#loc805)
%8224 = "mhlo.broadcast_in_dim"(%8223) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8225 = mhlo.shift_right_logical %8218, %8224 : tensor<1xui32> loc(#loc795)
%8226 = mhlo.or %8222, %8225 : tensor<1xui32> loc(#loc808)
%8227 = mhlo.xor %8219, %8226 : tensor<1xui32> loc(#loc804)
%8228 = mhlo.add %8219, %8227 : tensor<1xui32> loc(#loc806)
%8229 = mhlo.constant dense<29> : tensor<ui32> loc(#loc805)
%8230 = "mhlo.broadcast_in_dim"(%8229) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8231 = mhlo.shift_left %8227, %8230 : tensor<1xui32> loc(#loc807)
%8232 = mhlo.constant dense<3> : tensor<ui32> loc(#loc805)
%8233 = "mhlo.broadcast_in_dim"(%8232) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8234 = mhlo.shift_right_logical %8227, %8233 : tensor<1xui32> loc(#loc795)
%8235 = mhlo.or %8231, %8234 : tensor<1xui32> loc(#loc808)
%8236 = mhlo.xor %8228, %8235 : tensor<1xui32> loc(#loc804)
%8237 = mhlo.add %8228, %8236 : tensor<1xui32> loc(#loc806)
%8238 = mhlo.constant dense<16> : tensor<ui32> loc(#loc805)
%8239 = "mhlo.broadcast_in_dim"(%8238) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8240 = mhlo.shift_left %8236, %8239 : tensor<1xui32> loc(#loc807)
%8241 = mhlo.constant dense<16> : tensor<ui32> loc(#loc805)
%8242 = "mhlo.broadcast_in_dim"(%8241) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8243 = mhlo.shift_right_logical %8236, %8242 : tensor<1xui32> loc(#loc795)
%8244 = mhlo.or %8240, %8243 : tensor<1xui32> loc(#loc808)
%8245 = mhlo.xor %8237, %8244 : tensor<1xui32> loc(#loc804)
%8246 = mhlo.add %8237, %8245 : tensor<1xui32> loc(#loc806)
%8247 = mhlo.constant dense<24> : tensor<ui32> loc(#loc805)
%8248 = "mhlo.broadcast_in_dim"(%8247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8249 = mhlo.shift_left %8245, %8248 : tensor<1xui32> loc(#loc807)
%8250 = mhlo.constant dense<8> : tensor<ui32> loc(#loc805)
%8251 = "mhlo.broadcast_in_dim"(%8250) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8252 = mhlo.shift_right_logical %8245, %8251 : tensor<1xui32> loc(#loc795)
%8253 = mhlo.or %8249, %8252 : tensor<1xui32> loc(#loc808)
%8254 = mhlo.xor %8246, %8253 : tensor<1xui32> loc(#loc804)
%8255 = "mhlo.broadcast_in_dim"(%8080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8256 = mhlo.add %8246, %8255 : tensor<1xui32> loc(#loc806)
%8257 = "mhlo.broadcast_in_dim"(%8085) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8258 = mhlo.add %8254, %8257 : tensor<1xui32> loc(#loc806)
%8259 = mhlo.constant dense<4> : tensor<ui32> loc(#loc805)
%8260 = "mhlo.broadcast_in_dim"(%8259) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8261 = mhlo.add %8258, %8260 : tensor<1xui32> loc(#loc806)
%8262 = mhlo.add %8256, %8261 : tensor<1xui32> loc(#loc806)
%8263 = mhlo.constant dense<13> : tensor<ui32> loc(#loc805)
%8264 = "mhlo.broadcast_in_dim"(%8263) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8265 = mhlo.shift_left %8261, %8264 : tensor<1xui32> loc(#loc807)
%8266 = mhlo.constant dense<19> : tensor<ui32> loc(#loc805)
%8267 = "mhlo.broadcast_in_dim"(%8266) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8268 = mhlo.shift_right_logical %8261, %8267 : tensor<1xui32> loc(#loc795)
%8269 = mhlo.or %8265, %8268 : tensor<1xui32> loc(#loc808)
%8270 = mhlo.xor %8262, %8269 : tensor<1xui32> loc(#loc804)
%8271 = mhlo.add %8262, %8270 : tensor<1xui32> loc(#loc806)
%8272 = mhlo.constant dense<15> : tensor<ui32> loc(#loc805)
%8273 = "mhlo.broadcast_in_dim"(%8272) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8274 = mhlo.shift_left %8270, %8273 : tensor<1xui32> loc(#loc807)
%8275 = mhlo.constant dense<17> : tensor<ui32> loc(#loc805)
%8276 = "mhlo.broadcast_in_dim"(%8275) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8277 = mhlo.shift_right_logical %8270, %8276 : tensor<1xui32> loc(#loc795)
%8278 = mhlo.or %8274, %8277 : tensor<1xui32> loc(#loc808)
%8279 = mhlo.xor %8271, %8278 : tensor<1xui32> loc(#loc804)
%8280 = mhlo.add %8271, %8279 : tensor<1xui32> loc(#loc806)
%8281 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8282 = "mhlo.broadcast_in_dim"(%8281) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8283 = mhlo.shift_left %8279, %8282 : tensor<1xui32> loc(#loc807)
%8284 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8285 = "mhlo.broadcast_in_dim"(%8284) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8286 = mhlo.shift_right_logical %8279, %8285 : tensor<1xui32> loc(#loc795)
%8287 = mhlo.or %8283, %8286 : tensor<1xui32> loc(#loc808)
%8288 = mhlo.xor %8280, %8287 : tensor<1xui32> loc(#loc804)
%8289 = mhlo.add %8280, %8288 : tensor<1xui32> loc(#loc806)
%8290 = mhlo.constant dense<6> : tensor<ui32> loc(#loc805)
%8291 = "mhlo.broadcast_in_dim"(%8290) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc807)
%8292 = mhlo.shift_left %8288, %8291 : tensor<1xui32> loc(#loc807)
%8293 = mhlo.constant dense<26> : tensor<ui32> loc(#loc805)
%8294 = "mhlo.broadcast_in_dim"(%8293) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc795)
%8295 = mhlo.shift_right_logical %8288, %8294 : tensor<1xui32> loc(#loc795)
%8296 = mhlo.or %8292, %8295 : tensor<1xui32> loc(#loc808)
%8297 = mhlo.xor %8289, %8296 : tensor<1xui32> loc(#loc804)
%8298 = "mhlo.broadcast_in_dim"(%8085) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8299 = mhlo.add %8289, %8298 : tensor<1xui32> loc(#loc806)
%8300 = "mhlo.broadcast_in_dim"(%8078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8301 = mhlo.add %8297, %8300 : tensor<1xui32> loc(#loc806)
%8302 = mhlo.constant dense<5> : tensor<ui32> loc(#loc805)
%8303 = "mhlo.broadcast_in_dim"(%8302) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc806)
%8304 = mhlo.add %8301, %8303 : tensor<1xui32> loc(#loc806)
%8305 = "mhlo.concatenate"(%8299, %8304) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc798)
%8306 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%8307 = "mhlo.broadcast_in_dim"(%8306) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc809)
%8308 = "mhlo.reshape"(%8307) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc810)
%8309 = "mhlo.broadcast_in_dim"(%8308) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc811)
%8310 = mhlo.add %8068, %8309 : tensor<1x256x2048xf32> loc(#loc811)
%8311 = mhlo.convert(%8310) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc812)
%8312 = mhlo.constant dense<3646408819> : tensor<ui32> loc(#loc531)
%8313 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%8314 = mhlo.shift_right_logical %8312, %8313 : tensor<ui32> loc(#loc813)
%8315 = "mhlo.reshape"(%8314) : (tensor<ui32>) -> tensor<1xui32> loc(#loc814)
%8316 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%8317 = mhlo.and %8312, %8316 : tensor<ui32> loc(#loc815)
%8318 = "mhlo.reshape"(%8317) : (tensor<ui32>) -> tensor<1xui32> loc(#loc814)
%8319 = "mhlo.concatenate"(%8315, %8318) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc816)
%8320 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc817)
%8321 = "mhlo.reshape"(%8320) : (tensor<1xui32>) -> tensor<ui32> loc(#loc818)
%8322 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc819)
%8323 = "mhlo.reshape"(%8322) : (tensor<1xui32>) -> tensor<ui32> loc(#loc818)
%8324 = "mhlo.slice"(%8319) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc820)
%8325 = "mhlo.slice"(%8319) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc821)
%8326 = mhlo.xor %8321, %8323 : tensor<ui32> loc(#loc822)
%8327 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc823)
%8328 = mhlo.xor %8326, %8327 : tensor<ui32> loc(#loc822)
%8329 = "mhlo.broadcast_in_dim"(%8321) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8330 = mhlo.add %8324, %8329 : tensor<1xui32> loc(#loc824)
%8331 = "mhlo.broadcast_in_dim"(%8323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8332 = mhlo.add %8325, %8331 : tensor<1xui32> loc(#loc824)
%8333 = mhlo.add %8330, %8332 : tensor<1xui32> loc(#loc824)
%8334 = mhlo.constant dense<13> : tensor<ui32> loc(#loc823)
%8335 = "mhlo.broadcast_in_dim"(%8334) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8336 = mhlo.shift_left %8332, %8335 : tensor<1xui32> loc(#loc825)
%8337 = mhlo.constant dense<19> : tensor<ui32> loc(#loc823)
%8338 = "mhlo.broadcast_in_dim"(%8337) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8339 = mhlo.shift_right_logical %8332, %8338 : tensor<1xui32> loc(#loc813)
%8340 = mhlo.or %8336, %8339 : tensor<1xui32> loc(#loc826)
%8341 = mhlo.xor %8333, %8340 : tensor<1xui32> loc(#loc822)
%8342 = mhlo.add %8333, %8341 : tensor<1xui32> loc(#loc824)
%8343 = mhlo.constant dense<15> : tensor<ui32> loc(#loc823)
%8344 = "mhlo.broadcast_in_dim"(%8343) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8345 = mhlo.shift_left %8341, %8344 : tensor<1xui32> loc(#loc825)
%8346 = mhlo.constant dense<17> : tensor<ui32> loc(#loc823)
%8347 = "mhlo.broadcast_in_dim"(%8346) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8348 = mhlo.shift_right_logical %8341, %8347 : tensor<1xui32> loc(#loc813)
%8349 = mhlo.or %8345, %8348 : tensor<1xui32> loc(#loc826)
%8350 = mhlo.xor %8342, %8349 : tensor<1xui32> loc(#loc822)
%8351 = mhlo.add %8342, %8350 : tensor<1xui32> loc(#loc824)
%8352 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8353 = "mhlo.broadcast_in_dim"(%8352) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8354 = mhlo.shift_left %8350, %8353 : tensor<1xui32> loc(#loc825)
%8355 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8356 = "mhlo.broadcast_in_dim"(%8355) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8357 = mhlo.shift_right_logical %8350, %8356 : tensor<1xui32> loc(#loc813)
%8358 = mhlo.or %8354, %8357 : tensor<1xui32> loc(#loc826)
%8359 = mhlo.xor %8351, %8358 : tensor<1xui32> loc(#loc822)
%8360 = mhlo.add %8351, %8359 : tensor<1xui32> loc(#loc824)
%8361 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8362 = "mhlo.broadcast_in_dim"(%8361) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8363 = mhlo.shift_left %8359, %8362 : tensor<1xui32> loc(#loc825)
%8364 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8365 = "mhlo.broadcast_in_dim"(%8364) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8366 = mhlo.shift_right_logical %8359, %8365 : tensor<1xui32> loc(#loc813)
%8367 = mhlo.or %8363, %8366 : tensor<1xui32> loc(#loc826)
%8368 = mhlo.xor %8360, %8367 : tensor<1xui32> loc(#loc822)
%8369 = "mhlo.broadcast_in_dim"(%8323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8370 = mhlo.add %8360, %8369 : tensor<1xui32> loc(#loc824)
%8371 = "mhlo.broadcast_in_dim"(%8328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8372 = mhlo.add %8368, %8371 : tensor<1xui32> loc(#loc824)
%8373 = mhlo.constant dense<1> : tensor<ui32> loc(#loc823)
%8374 = "mhlo.broadcast_in_dim"(%8373) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8375 = mhlo.add %8372, %8374 : tensor<1xui32> loc(#loc824)
%8376 = mhlo.add %8370, %8375 : tensor<1xui32> loc(#loc824)
%8377 = mhlo.constant dense<17> : tensor<ui32> loc(#loc823)
%8378 = "mhlo.broadcast_in_dim"(%8377) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8379 = mhlo.shift_left %8375, %8378 : tensor<1xui32> loc(#loc825)
%8380 = mhlo.constant dense<15> : tensor<ui32> loc(#loc823)
%8381 = "mhlo.broadcast_in_dim"(%8380) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8382 = mhlo.shift_right_logical %8375, %8381 : tensor<1xui32> loc(#loc813)
%8383 = mhlo.or %8379, %8382 : tensor<1xui32> loc(#loc826)
%8384 = mhlo.xor %8376, %8383 : tensor<1xui32> loc(#loc822)
%8385 = mhlo.add %8376, %8384 : tensor<1xui32> loc(#loc824)
%8386 = mhlo.constant dense<29> : tensor<ui32> loc(#loc823)
%8387 = "mhlo.broadcast_in_dim"(%8386) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8388 = mhlo.shift_left %8384, %8387 : tensor<1xui32> loc(#loc825)
%8389 = mhlo.constant dense<3> : tensor<ui32> loc(#loc823)
%8390 = "mhlo.broadcast_in_dim"(%8389) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8391 = mhlo.shift_right_logical %8384, %8390 : tensor<1xui32> loc(#loc813)
%8392 = mhlo.or %8388, %8391 : tensor<1xui32> loc(#loc826)
%8393 = mhlo.xor %8385, %8392 : tensor<1xui32> loc(#loc822)
%8394 = mhlo.add %8385, %8393 : tensor<1xui32> loc(#loc824)
%8395 = mhlo.constant dense<16> : tensor<ui32> loc(#loc823)
%8396 = "mhlo.broadcast_in_dim"(%8395) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8397 = mhlo.shift_left %8393, %8396 : tensor<1xui32> loc(#loc825)
%8398 = mhlo.constant dense<16> : tensor<ui32> loc(#loc823)
%8399 = "mhlo.broadcast_in_dim"(%8398) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8400 = mhlo.shift_right_logical %8393, %8399 : tensor<1xui32> loc(#loc813)
%8401 = mhlo.or %8397, %8400 : tensor<1xui32> loc(#loc826)
%8402 = mhlo.xor %8394, %8401 : tensor<1xui32> loc(#loc822)
%8403 = mhlo.add %8394, %8402 : tensor<1xui32> loc(#loc824)
%8404 = mhlo.constant dense<24> : tensor<ui32> loc(#loc823)
%8405 = "mhlo.broadcast_in_dim"(%8404) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8406 = mhlo.shift_left %8402, %8405 : tensor<1xui32> loc(#loc825)
%8407 = mhlo.constant dense<8> : tensor<ui32> loc(#loc823)
%8408 = "mhlo.broadcast_in_dim"(%8407) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8409 = mhlo.shift_right_logical %8402, %8408 : tensor<1xui32> loc(#loc813)
%8410 = mhlo.or %8406, %8409 : tensor<1xui32> loc(#loc826)
%8411 = mhlo.xor %8403, %8410 : tensor<1xui32> loc(#loc822)
%8412 = "mhlo.broadcast_in_dim"(%8328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8413 = mhlo.add %8403, %8412 : tensor<1xui32> loc(#loc824)
%8414 = "mhlo.broadcast_in_dim"(%8321) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8415 = mhlo.add %8411, %8414 : tensor<1xui32> loc(#loc824)
%8416 = mhlo.constant dense<2> : tensor<ui32> loc(#loc823)
%8417 = "mhlo.broadcast_in_dim"(%8416) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8418 = mhlo.add %8415, %8417 : tensor<1xui32> loc(#loc824)
%8419 = mhlo.add %8413, %8418 : tensor<1xui32> loc(#loc824)
%8420 = mhlo.constant dense<13> : tensor<ui32> loc(#loc823)
%8421 = "mhlo.broadcast_in_dim"(%8420) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8422 = mhlo.shift_left %8418, %8421 : tensor<1xui32> loc(#loc825)
%8423 = mhlo.constant dense<19> : tensor<ui32> loc(#loc823)
%8424 = "mhlo.broadcast_in_dim"(%8423) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8425 = mhlo.shift_right_logical %8418, %8424 : tensor<1xui32> loc(#loc813)
%8426 = mhlo.or %8422, %8425 : tensor<1xui32> loc(#loc826)
%8427 = mhlo.xor %8419, %8426 : tensor<1xui32> loc(#loc822)
%8428 = mhlo.add %8419, %8427 : tensor<1xui32> loc(#loc824)
%8429 = mhlo.constant dense<15> : tensor<ui32> loc(#loc823)
%8430 = "mhlo.broadcast_in_dim"(%8429) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8431 = mhlo.shift_left %8427, %8430 : tensor<1xui32> loc(#loc825)
%8432 = mhlo.constant dense<17> : tensor<ui32> loc(#loc823)
%8433 = "mhlo.broadcast_in_dim"(%8432) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8434 = mhlo.shift_right_logical %8427, %8433 : tensor<1xui32> loc(#loc813)
%8435 = mhlo.or %8431, %8434 : tensor<1xui32> loc(#loc826)
%8436 = mhlo.xor %8428, %8435 : tensor<1xui32> loc(#loc822)
%8437 = mhlo.add %8428, %8436 : tensor<1xui32> loc(#loc824)
%8438 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8439 = "mhlo.broadcast_in_dim"(%8438) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8440 = mhlo.shift_left %8436, %8439 : tensor<1xui32> loc(#loc825)
%8441 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8442 = "mhlo.broadcast_in_dim"(%8441) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8443 = mhlo.shift_right_logical %8436, %8442 : tensor<1xui32> loc(#loc813)
%8444 = mhlo.or %8440, %8443 : tensor<1xui32> loc(#loc826)
%8445 = mhlo.xor %8437, %8444 : tensor<1xui32> loc(#loc822)
%8446 = mhlo.add %8437, %8445 : tensor<1xui32> loc(#loc824)
%8447 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8448 = "mhlo.broadcast_in_dim"(%8447) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8449 = mhlo.shift_left %8445, %8448 : tensor<1xui32> loc(#loc825)
%8450 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8451 = "mhlo.broadcast_in_dim"(%8450) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8452 = mhlo.shift_right_logical %8445, %8451 : tensor<1xui32> loc(#loc813)
%8453 = mhlo.or %8449, %8452 : tensor<1xui32> loc(#loc826)
%8454 = mhlo.xor %8446, %8453 : tensor<1xui32> loc(#loc822)
%8455 = "mhlo.broadcast_in_dim"(%8321) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8456 = mhlo.add %8446, %8455 : tensor<1xui32> loc(#loc824)
%8457 = "mhlo.broadcast_in_dim"(%8323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8458 = mhlo.add %8454, %8457 : tensor<1xui32> loc(#loc824)
%8459 = mhlo.constant dense<3> : tensor<ui32> loc(#loc823)
%8460 = "mhlo.broadcast_in_dim"(%8459) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8461 = mhlo.add %8458, %8460 : tensor<1xui32> loc(#loc824)
%8462 = mhlo.add %8456, %8461 : tensor<1xui32> loc(#loc824)
%8463 = mhlo.constant dense<17> : tensor<ui32> loc(#loc823)
%8464 = "mhlo.broadcast_in_dim"(%8463) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8465 = mhlo.shift_left %8461, %8464 : tensor<1xui32> loc(#loc825)
%8466 = mhlo.constant dense<15> : tensor<ui32> loc(#loc823)
%8467 = "mhlo.broadcast_in_dim"(%8466) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8468 = mhlo.shift_right_logical %8461, %8467 : tensor<1xui32> loc(#loc813)
%8469 = mhlo.or %8465, %8468 : tensor<1xui32> loc(#loc826)
%8470 = mhlo.xor %8462, %8469 : tensor<1xui32> loc(#loc822)
%8471 = mhlo.add %8462, %8470 : tensor<1xui32> loc(#loc824)
%8472 = mhlo.constant dense<29> : tensor<ui32> loc(#loc823)
%8473 = "mhlo.broadcast_in_dim"(%8472) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8474 = mhlo.shift_left %8470, %8473 : tensor<1xui32> loc(#loc825)
%8475 = mhlo.constant dense<3> : tensor<ui32> loc(#loc823)
%8476 = "mhlo.broadcast_in_dim"(%8475) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8477 = mhlo.shift_right_logical %8470, %8476 : tensor<1xui32> loc(#loc813)
%8478 = mhlo.or %8474, %8477 : tensor<1xui32> loc(#loc826)
%8479 = mhlo.xor %8471, %8478 : tensor<1xui32> loc(#loc822)
%8480 = mhlo.add %8471, %8479 : tensor<1xui32> loc(#loc824)
%8481 = mhlo.constant dense<16> : tensor<ui32> loc(#loc823)
%8482 = "mhlo.broadcast_in_dim"(%8481) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8483 = mhlo.shift_left %8479, %8482 : tensor<1xui32> loc(#loc825)
%8484 = mhlo.constant dense<16> : tensor<ui32> loc(#loc823)
%8485 = "mhlo.broadcast_in_dim"(%8484) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8486 = mhlo.shift_right_logical %8479, %8485 : tensor<1xui32> loc(#loc813)
%8487 = mhlo.or %8483, %8486 : tensor<1xui32> loc(#loc826)
%8488 = mhlo.xor %8480, %8487 : tensor<1xui32> loc(#loc822)
%8489 = mhlo.add %8480, %8488 : tensor<1xui32> loc(#loc824)
%8490 = mhlo.constant dense<24> : tensor<ui32> loc(#loc823)
%8491 = "mhlo.broadcast_in_dim"(%8490) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8492 = mhlo.shift_left %8488, %8491 : tensor<1xui32> loc(#loc825)
%8493 = mhlo.constant dense<8> : tensor<ui32> loc(#loc823)
%8494 = "mhlo.broadcast_in_dim"(%8493) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8495 = mhlo.shift_right_logical %8488, %8494 : tensor<1xui32> loc(#loc813)
%8496 = mhlo.or %8492, %8495 : tensor<1xui32> loc(#loc826)
%8497 = mhlo.xor %8489, %8496 : tensor<1xui32> loc(#loc822)
%8498 = "mhlo.broadcast_in_dim"(%8323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8499 = mhlo.add %8489, %8498 : tensor<1xui32> loc(#loc824)
%8500 = "mhlo.broadcast_in_dim"(%8328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8501 = mhlo.add %8497, %8500 : tensor<1xui32> loc(#loc824)
%8502 = mhlo.constant dense<4> : tensor<ui32> loc(#loc823)
%8503 = "mhlo.broadcast_in_dim"(%8502) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8504 = mhlo.add %8501, %8503 : tensor<1xui32> loc(#loc824)
%8505 = mhlo.add %8499, %8504 : tensor<1xui32> loc(#loc824)
%8506 = mhlo.constant dense<13> : tensor<ui32> loc(#loc823)
%8507 = "mhlo.broadcast_in_dim"(%8506) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8508 = mhlo.shift_left %8504, %8507 : tensor<1xui32> loc(#loc825)
%8509 = mhlo.constant dense<19> : tensor<ui32> loc(#loc823)
%8510 = "mhlo.broadcast_in_dim"(%8509) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8511 = mhlo.shift_right_logical %8504, %8510 : tensor<1xui32> loc(#loc813)
%8512 = mhlo.or %8508, %8511 : tensor<1xui32> loc(#loc826)
%8513 = mhlo.xor %8505, %8512 : tensor<1xui32> loc(#loc822)
%8514 = mhlo.add %8505, %8513 : tensor<1xui32> loc(#loc824)
%8515 = mhlo.constant dense<15> : tensor<ui32> loc(#loc823)
%8516 = "mhlo.broadcast_in_dim"(%8515) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8517 = mhlo.shift_left %8513, %8516 : tensor<1xui32> loc(#loc825)
%8518 = mhlo.constant dense<17> : tensor<ui32> loc(#loc823)
%8519 = "mhlo.broadcast_in_dim"(%8518) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8520 = mhlo.shift_right_logical %8513, %8519 : tensor<1xui32> loc(#loc813)
%8521 = mhlo.or %8517, %8520 : tensor<1xui32> loc(#loc826)
%8522 = mhlo.xor %8514, %8521 : tensor<1xui32> loc(#loc822)
%8523 = mhlo.add %8514, %8522 : tensor<1xui32> loc(#loc824)
%8524 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8525 = "mhlo.broadcast_in_dim"(%8524) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8526 = mhlo.shift_left %8522, %8525 : tensor<1xui32> loc(#loc825)
%8527 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8528 = "mhlo.broadcast_in_dim"(%8527) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8529 = mhlo.shift_right_logical %8522, %8528 : tensor<1xui32> loc(#loc813)
%8530 = mhlo.or %8526, %8529 : tensor<1xui32> loc(#loc826)
%8531 = mhlo.xor %8523, %8530 : tensor<1xui32> loc(#loc822)
%8532 = mhlo.add %8523, %8531 : tensor<1xui32> loc(#loc824)
%8533 = mhlo.constant dense<6> : tensor<ui32> loc(#loc823)
%8534 = "mhlo.broadcast_in_dim"(%8533) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc825)
%8535 = mhlo.shift_left %8531, %8534 : tensor<1xui32> loc(#loc825)
%8536 = mhlo.constant dense<26> : tensor<ui32> loc(#loc823)
%8537 = "mhlo.broadcast_in_dim"(%8536) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc813)
%8538 = mhlo.shift_right_logical %8531, %8537 : tensor<1xui32> loc(#loc813)
%8539 = mhlo.or %8535, %8538 : tensor<1xui32> loc(#loc826)
%8540 = mhlo.xor %8532, %8539 : tensor<1xui32> loc(#loc822)
%8541 = "mhlo.broadcast_in_dim"(%8328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8542 = mhlo.add %8532, %8541 : tensor<1xui32> loc(#loc824)
%8543 = "mhlo.broadcast_in_dim"(%8321) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8544 = mhlo.add %8540, %8543 : tensor<1xui32> loc(#loc824)
%8545 = mhlo.constant dense<5> : tensor<ui32> loc(#loc823)
%8546 = "mhlo.broadcast_in_dim"(%8545) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc824)
%8547 = mhlo.add %8544, %8546 : tensor<1xui32> loc(#loc824)
%8548 = "mhlo.concatenate"(%8542, %8547) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc816)
%8549 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%8550 = "mhlo.broadcast_in_dim"(%8549) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc827)
%8551 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%8552 = "mhlo.broadcast_in_dim"(%8551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc827)
%8553 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc828)
%8554 = "mhlo.slice"(%8548) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc829)
%8555 = "mhlo.reshape"(%8554) : (tensor<1xui32>) -> tensor<ui32> loc(#loc830)
%8556 = "mhlo.slice"(%8548) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc831)
%8557 = "mhlo.reshape"(%8556) : (tensor<1xui32>) -> tensor<ui32> loc(#loc830)
%8558 = "mhlo.slice"(%8553) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc832)
%8559 = "mhlo.slice"(%8553) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc833)
%8560 = mhlo.xor %8555, %8557 : tensor<ui32> loc(#loc834)
%8561 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc835)
%8562 = mhlo.xor %8560, %8561 : tensor<ui32> loc(#loc834)
%8563 = "mhlo.broadcast_in_dim"(%8555) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8564 = mhlo.add %8558, %8563 : tensor<2097152xui32> loc(#loc836)
%8565 = "mhlo.broadcast_in_dim"(%8557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8566 = mhlo.add %8559, %8565 : tensor<2097152xui32> loc(#loc836)
%8567 = mhlo.add %8564, %8566 : tensor<2097152xui32> loc(#loc836)
%8568 = mhlo.constant dense<13> : tensor<ui32> loc(#loc835)
%8569 = "mhlo.broadcast_in_dim"(%8568) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8570 = mhlo.shift_left %8566, %8569 : tensor<2097152xui32> loc(#loc837)
%8571 = mhlo.constant dense<19> : tensor<ui32> loc(#loc835)
%8572 = "mhlo.broadcast_in_dim"(%8571) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8573 = mhlo.shift_right_logical %8566, %8572 : tensor<2097152xui32> loc(#loc838)
%8574 = mhlo.or %8570, %8573 : tensor<2097152xui32> loc(#loc839)
%8575 = mhlo.xor %8567, %8574 : tensor<2097152xui32> loc(#loc834)
%8576 = mhlo.add %8567, %8575 : tensor<2097152xui32> loc(#loc836)
%8577 = mhlo.constant dense<15> : tensor<ui32> loc(#loc835)
%8578 = "mhlo.broadcast_in_dim"(%8577) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8579 = mhlo.shift_left %8575, %8578 : tensor<2097152xui32> loc(#loc837)
%8580 = mhlo.constant dense<17> : tensor<ui32> loc(#loc835)
%8581 = "mhlo.broadcast_in_dim"(%8580) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8582 = mhlo.shift_right_logical %8575, %8581 : tensor<2097152xui32> loc(#loc838)
%8583 = mhlo.or %8579, %8582 : tensor<2097152xui32> loc(#loc839)
%8584 = mhlo.xor %8576, %8583 : tensor<2097152xui32> loc(#loc834)
%8585 = mhlo.add %8576, %8584 : tensor<2097152xui32> loc(#loc836)
%8586 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8587 = "mhlo.broadcast_in_dim"(%8586) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8588 = mhlo.shift_left %8584, %8587 : tensor<2097152xui32> loc(#loc837)
%8589 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8590 = "mhlo.broadcast_in_dim"(%8589) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8591 = mhlo.shift_right_logical %8584, %8590 : tensor<2097152xui32> loc(#loc838)
%8592 = mhlo.or %8588, %8591 : tensor<2097152xui32> loc(#loc839)
%8593 = mhlo.xor %8585, %8592 : tensor<2097152xui32> loc(#loc834)
%8594 = mhlo.add %8585, %8593 : tensor<2097152xui32> loc(#loc836)
%8595 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8596 = "mhlo.broadcast_in_dim"(%8595) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8597 = mhlo.shift_left %8593, %8596 : tensor<2097152xui32> loc(#loc837)
%8598 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8599 = "mhlo.broadcast_in_dim"(%8598) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8600 = mhlo.shift_right_logical %8593, %8599 : tensor<2097152xui32> loc(#loc838)
%8601 = mhlo.or %8597, %8600 : tensor<2097152xui32> loc(#loc839)
%8602 = mhlo.xor %8594, %8601 : tensor<2097152xui32> loc(#loc834)
%8603 = "mhlo.broadcast_in_dim"(%8557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8604 = mhlo.add %8594, %8603 : tensor<2097152xui32> loc(#loc836)
%8605 = "mhlo.broadcast_in_dim"(%8562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8606 = mhlo.add %8602, %8605 : tensor<2097152xui32> loc(#loc836)
%8607 = mhlo.constant dense<1> : tensor<ui32> loc(#loc835)
%8608 = "mhlo.broadcast_in_dim"(%8607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8609 = mhlo.add %8606, %8608 : tensor<2097152xui32> loc(#loc836)
%8610 = mhlo.add %8604, %8609 : tensor<2097152xui32> loc(#loc836)
%8611 = mhlo.constant dense<17> : tensor<ui32> loc(#loc835)
%8612 = "mhlo.broadcast_in_dim"(%8611) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8613 = mhlo.shift_left %8609, %8612 : tensor<2097152xui32> loc(#loc837)
%8614 = mhlo.constant dense<15> : tensor<ui32> loc(#loc835)
%8615 = "mhlo.broadcast_in_dim"(%8614) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8616 = mhlo.shift_right_logical %8609, %8615 : tensor<2097152xui32> loc(#loc838)
%8617 = mhlo.or %8613, %8616 : tensor<2097152xui32> loc(#loc839)
%8618 = mhlo.xor %8610, %8617 : tensor<2097152xui32> loc(#loc834)
%8619 = mhlo.add %8610, %8618 : tensor<2097152xui32> loc(#loc836)
%8620 = mhlo.constant dense<29> : tensor<ui32> loc(#loc835)
%8621 = "mhlo.broadcast_in_dim"(%8620) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8622 = mhlo.shift_left %8618, %8621 : tensor<2097152xui32> loc(#loc837)
%8623 = mhlo.constant dense<3> : tensor<ui32> loc(#loc835)
%8624 = "mhlo.broadcast_in_dim"(%8623) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8625 = mhlo.shift_right_logical %8618, %8624 : tensor<2097152xui32> loc(#loc838)
%8626 = mhlo.or %8622, %8625 : tensor<2097152xui32> loc(#loc839)
%8627 = mhlo.xor %8619, %8626 : tensor<2097152xui32> loc(#loc834)
%8628 = mhlo.add %8619, %8627 : tensor<2097152xui32> loc(#loc836)
%8629 = mhlo.constant dense<16> : tensor<ui32> loc(#loc835)
%8630 = "mhlo.broadcast_in_dim"(%8629) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8631 = mhlo.shift_left %8627, %8630 : tensor<2097152xui32> loc(#loc837)
%8632 = mhlo.constant dense<16> : tensor<ui32> loc(#loc835)
%8633 = "mhlo.broadcast_in_dim"(%8632) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8634 = mhlo.shift_right_logical %8627, %8633 : tensor<2097152xui32> loc(#loc838)
%8635 = mhlo.or %8631, %8634 : tensor<2097152xui32> loc(#loc839)
%8636 = mhlo.xor %8628, %8635 : tensor<2097152xui32> loc(#loc834)
%8637 = mhlo.add %8628, %8636 : tensor<2097152xui32> loc(#loc836)
%8638 = mhlo.constant dense<24> : tensor<ui32> loc(#loc835)
%8639 = "mhlo.broadcast_in_dim"(%8638) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8640 = mhlo.shift_left %8636, %8639 : tensor<2097152xui32> loc(#loc837)
%8641 = mhlo.constant dense<8> : tensor<ui32> loc(#loc835)
%8642 = "mhlo.broadcast_in_dim"(%8641) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8643 = mhlo.shift_right_logical %8636, %8642 : tensor<2097152xui32> loc(#loc838)
%8644 = mhlo.or %8640, %8643 : tensor<2097152xui32> loc(#loc839)
%8645 = mhlo.xor %8637, %8644 : tensor<2097152xui32> loc(#loc834)
%8646 = "mhlo.broadcast_in_dim"(%8562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8647 = mhlo.add %8637, %8646 : tensor<2097152xui32> loc(#loc836)
%8648 = "mhlo.broadcast_in_dim"(%8555) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8649 = mhlo.add %8645, %8648 : tensor<2097152xui32> loc(#loc836)
%8650 = mhlo.constant dense<2> : tensor<ui32> loc(#loc835)
%8651 = "mhlo.broadcast_in_dim"(%8650) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8652 = mhlo.add %8649, %8651 : tensor<2097152xui32> loc(#loc836)
%8653 = mhlo.add %8647, %8652 : tensor<2097152xui32> loc(#loc836)
%8654 = mhlo.constant dense<13> : tensor<ui32> loc(#loc835)
%8655 = "mhlo.broadcast_in_dim"(%8654) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8656 = mhlo.shift_left %8652, %8655 : tensor<2097152xui32> loc(#loc837)
%8657 = mhlo.constant dense<19> : tensor<ui32> loc(#loc835)
%8658 = "mhlo.broadcast_in_dim"(%8657) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8659 = mhlo.shift_right_logical %8652, %8658 : tensor<2097152xui32> loc(#loc838)
%8660 = mhlo.or %8656, %8659 : tensor<2097152xui32> loc(#loc839)
%8661 = mhlo.xor %8653, %8660 : tensor<2097152xui32> loc(#loc834)
%8662 = mhlo.add %8653, %8661 : tensor<2097152xui32> loc(#loc836)
%8663 = mhlo.constant dense<15> : tensor<ui32> loc(#loc835)
%8664 = "mhlo.broadcast_in_dim"(%8663) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8665 = mhlo.shift_left %8661, %8664 : tensor<2097152xui32> loc(#loc837)
%8666 = mhlo.constant dense<17> : tensor<ui32> loc(#loc835)
%8667 = "mhlo.broadcast_in_dim"(%8666) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8668 = mhlo.shift_right_logical %8661, %8667 : tensor<2097152xui32> loc(#loc838)
%8669 = mhlo.or %8665, %8668 : tensor<2097152xui32> loc(#loc839)
%8670 = mhlo.xor %8662, %8669 : tensor<2097152xui32> loc(#loc834)
%8671 = mhlo.add %8662, %8670 : tensor<2097152xui32> loc(#loc836)
%8672 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8673 = "mhlo.broadcast_in_dim"(%8672) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8674 = mhlo.shift_left %8670, %8673 : tensor<2097152xui32> loc(#loc837)
%8675 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8676 = "mhlo.broadcast_in_dim"(%8675) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8677 = mhlo.shift_right_logical %8670, %8676 : tensor<2097152xui32> loc(#loc838)
%8678 = mhlo.or %8674, %8677 : tensor<2097152xui32> loc(#loc839)
%8679 = mhlo.xor %8671, %8678 : tensor<2097152xui32> loc(#loc834)
%8680 = mhlo.add %8671, %8679 : tensor<2097152xui32> loc(#loc836)
%8681 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8682 = "mhlo.broadcast_in_dim"(%8681) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8683 = mhlo.shift_left %8679, %8682 : tensor<2097152xui32> loc(#loc837)
%8684 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8685 = "mhlo.broadcast_in_dim"(%8684) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8686 = mhlo.shift_right_logical %8679, %8685 : tensor<2097152xui32> loc(#loc838)
%8687 = mhlo.or %8683, %8686 : tensor<2097152xui32> loc(#loc839)
%8688 = mhlo.xor %8680, %8687 : tensor<2097152xui32> loc(#loc834)
%8689 = "mhlo.broadcast_in_dim"(%8555) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8690 = mhlo.add %8680, %8689 : tensor<2097152xui32> loc(#loc836)
%8691 = "mhlo.broadcast_in_dim"(%8557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8692 = mhlo.add %8688, %8691 : tensor<2097152xui32> loc(#loc836)
%8693 = mhlo.constant dense<3> : tensor<ui32> loc(#loc835)
%8694 = "mhlo.broadcast_in_dim"(%8693) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8695 = mhlo.add %8692, %8694 : tensor<2097152xui32> loc(#loc836)
%8696 = mhlo.add %8690, %8695 : tensor<2097152xui32> loc(#loc836)
%8697 = mhlo.constant dense<17> : tensor<ui32> loc(#loc835)
%8698 = "mhlo.broadcast_in_dim"(%8697) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8699 = mhlo.shift_left %8695, %8698 : tensor<2097152xui32> loc(#loc837)
%8700 = mhlo.constant dense<15> : tensor<ui32> loc(#loc835)
%8701 = "mhlo.broadcast_in_dim"(%8700) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8702 = mhlo.shift_right_logical %8695, %8701 : tensor<2097152xui32> loc(#loc838)
%8703 = mhlo.or %8699, %8702 : tensor<2097152xui32> loc(#loc839)
%8704 = mhlo.xor %8696, %8703 : tensor<2097152xui32> loc(#loc834)
%8705 = mhlo.add %8696, %8704 : tensor<2097152xui32> loc(#loc836)
%8706 = mhlo.constant dense<29> : tensor<ui32> loc(#loc835)
%8707 = "mhlo.broadcast_in_dim"(%8706) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8708 = mhlo.shift_left %8704, %8707 : tensor<2097152xui32> loc(#loc837)
%8709 = mhlo.constant dense<3> : tensor<ui32> loc(#loc835)
%8710 = "mhlo.broadcast_in_dim"(%8709) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8711 = mhlo.shift_right_logical %8704, %8710 : tensor<2097152xui32> loc(#loc838)
%8712 = mhlo.or %8708, %8711 : tensor<2097152xui32> loc(#loc839)
%8713 = mhlo.xor %8705, %8712 : tensor<2097152xui32> loc(#loc834)
%8714 = mhlo.add %8705, %8713 : tensor<2097152xui32> loc(#loc836)
%8715 = mhlo.constant dense<16> : tensor<ui32> loc(#loc835)
%8716 = "mhlo.broadcast_in_dim"(%8715) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8717 = mhlo.shift_left %8713, %8716 : tensor<2097152xui32> loc(#loc837)
%8718 = mhlo.constant dense<16> : tensor<ui32> loc(#loc835)
%8719 = "mhlo.broadcast_in_dim"(%8718) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8720 = mhlo.shift_right_logical %8713, %8719 : tensor<2097152xui32> loc(#loc838)
%8721 = mhlo.or %8717, %8720 : tensor<2097152xui32> loc(#loc839)
%8722 = mhlo.xor %8714, %8721 : tensor<2097152xui32> loc(#loc834)
%8723 = mhlo.add %8714, %8722 : tensor<2097152xui32> loc(#loc836)
%8724 = mhlo.constant dense<24> : tensor<ui32> loc(#loc835)
%8725 = "mhlo.broadcast_in_dim"(%8724) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8726 = mhlo.shift_left %8722, %8725 : tensor<2097152xui32> loc(#loc837)
%8727 = mhlo.constant dense<8> : tensor<ui32> loc(#loc835)
%8728 = "mhlo.broadcast_in_dim"(%8727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8729 = mhlo.shift_right_logical %8722, %8728 : tensor<2097152xui32> loc(#loc838)
%8730 = mhlo.or %8726, %8729 : tensor<2097152xui32> loc(#loc839)
%8731 = mhlo.xor %8723, %8730 : tensor<2097152xui32> loc(#loc834)
%8732 = "mhlo.broadcast_in_dim"(%8557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8733 = mhlo.add %8723, %8732 : tensor<2097152xui32> loc(#loc836)
%8734 = "mhlo.broadcast_in_dim"(%8562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8735 = mhlo.add %8731, %8734 : tensor<2097152xui32> loc(#loc836)
%8736 = mhlo.constant dense<4> : tensor<ui32> loc(#loc835)
%8737 = "mhlo.broadcast_in_dim"(%8736) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8738 = mhlo.add %8735, %8737 : tensor<2097152xui32> loc(#loc836)
%8739 = mhlo.add %8733, %8738 : tensor<2097152xui32> loc(#loc836)
%8740 = mhlo.constant dense<13> : tensor<ui32> loc(#loc835)
%8741 = "mhlo.broadcast_in_dim"(%8740) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8742 = mhlo.shift_left %8738, %8741 : tensor<2097152xui32> loc(#loc837)
%8743 = mhlo.constant dense<19> : tensor<ui32> loc(#loc835)
%8744 = "mhlo.broadcast_in_dim"(%8743) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8745 = mhlo.shift_right_logical %8738, %8744 : tensor<2097152xui32> loc(#loc838)
%8746 = mhlo.or %8742, %8745 : tensor<2097152xui32> loc(#loc839)
%8747 = mhlo.xor %8739, %8746 : tensor<2097152xui32> loc(#loc834)
%8748 = mhlo.add %8739, %8747 : tensor<2097152xui32> loc(#loc836)
%8749 = mhlo.constant dense<15> : tensor<ui32> loc(#loc835)
%8750 = "mhlo.broadcast_in_dim"(%8749) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8751 = mhlo.shift_left %8747, %8750 : tensor<2097152xui32> loc(#loc837)
%8752 = mhlo.constant dense<17> : tensor<ui32> loc(#loc835)
%8753 = "mhlo.broadcast_in_dim"(%8752) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8754 = mhlo.shift_right_logical %8747, %8753 : tensor<2097152xui32> loc(#loc838)
%8755 = mhlo.or %8751, %8754 : tensor<2097152xui32> loc(#loc839)
%8756 = mhlo.xor %8748, %8755 : tensor<2097152xui32> loc(#loc834)
%8757 = mhlo.add %8748, %8756 : tensor<2097152xui32> loc(#loc836)
%8758 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8759 = "mhlo.broadcast_in_dim"(%8758) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8760 = mhlo.shift_left %8756, %8759 : tensor<2097152xui32> loc(#loc837)
%8761 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8762 = "mhlo.broadcast_in_dim"(%8761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8763 = mhlo.shift_right_logical %8756, %8762 : tensor<2097152xui32> loc(#loc838)
%8764 = mhlo.or %8760, %8763 : tensor<2097152xui32> loc(#loc839)
%8765 = mhlo.xor %8757, %8764 : tensor<2097152xui32> loc(#loc834)
%8766 = mhlo.add %8757, %8765 : tensor<2097152xui32> loc(#loc836)
%8767 = mhlo.constant dense<6> : tensor<ui32> loc(#loc835)
%8768 = "mhlo.broadcast_in_dim"(%8767) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc837)
%8769 = mhlo.shift_left %8765, %8768 : tensor<2097152xui32> loc(#loc837)
%8770 = mhlo.constant dense<26> : tensor<ui32> loc(#loc835)
%8771 = "mhlo.broadcast_in_dim"(%8770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc838)
%8772 = mhlo.shift_right_logical %8765, %8771 : tensor<2097152xui32> loc(#loc838)
%8773 = mhlo.or %8769, %8772 : tensor<2097152xui32> loc(#loc839)
%8774 = mhlo.xor %8766, %8773 : tensor<2097152xui32> loc(#loc834)
%8775 = "mhlo.broadcast_in_dim"(%8562) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8776 = mhlo.add %8766, %8775 : tensor<2097152xui32> loc(#loc836)
%8777 = "mhlo.broadcast_in_dim"(%8555) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8778 = mhlo.add %8774, %8777 : tensor<2097152xui32> loc(#loc836)
%8779 = mhlo.constant dense<5> : tensor<ui32> loc(#loc835)
%8780 = "mhlo.broadcast_in_dim"(%8779) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc836)
%8781 = mhlo.add %8778, %8780 : tensor<2097152xui32> loc(#loc836)
%8782 = "mhlo.concatenate"(%8776, %8781) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc840)
%8783 = "mhlo.reshape"(%8782) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc841)
%8784 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%8785 = "mhlo.broadcast_in_dim"(%8784) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc838)
%8786 = mhlo.shift_right_logical %8783, %8785 : tensor<2048x2048xui32> loc(#loc838)
%8787 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%8788 = "mhlo.broadcast_in_dim"(%8787) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc839)
%8789 = mhlo.or %8786, %8788 : tensor<2048x2048xui32> loc(#loc839)
%8790 = "mhlo.bitcast_convert"(%8789) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc842)
%8791 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%8792 = "mhlo.broadcast_in_dim"(%8791) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc843)
%8793 = mhlo.subtract %8790, %8792 : tensor<2048x2048xf32> loc(#loc843)
%8794 = mhlo.subtract %8552, %8550 : tensor<1x1xf32> loc(#loc843)
%8795 = "mhlo.broadcast_in_dim"(%8794) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc844)
%8796 = mhlo.multiply %8793, %8795 : tensor<2048x2048xf32> loc(#loc844)
%8797 = "mhlo.broadcast_in_dim"(%8550) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc836)
%8798 = mhlo.add %8796, %8797 : tensor<2048x2048xf32> loc(#loc836)
%8799 = "mhlo.broadcast_in_dim"(%8550) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc845)
%8800 = mhlo.maximum %8799, %8798 : tensor<2048x2048xf32> loc(#loc845)
%8801 = func.call @erf_inv_22(%8800) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc846)
%8802 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%8803 = "mhlo.broadcast_in_dim"(%8802) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc844)
%8804 = mhlo.multiply %8801, %8803 : tensor<2048x2048xf32> loc(#loc844)
%8805 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%8806 = "mhlo.broadcast_in_dim"(%8805) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc844)
%8807 = mhlo.multiply %8804, %8806 : tensor<2048x2048xf32> loc(#loc844)
%8808 = mhlo.convert(%8807) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc847)
%8809 = "mhlo.dot_general"(%8311, %8808) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc848)
%8810 = mhlo.constant dense<299804320> : tensor<ui32> loc(#loc531)
%8811 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%8812 = mhlo.shift_right_logical %8810, %8811 : tensor<ui32> loc(#loc849)
%8813 = "mhlo.reshape"(%8812) : (tensor<ui32>) -> tensor<1xui32> loc(#loc850)
%8814 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%8815 = mhlo.and %8810, %8814 : tensor<ui32> loc(#loc851)
%8816 = "mhlo.reshape"(%8815) : (tensor<ui32>) -> tensor<1xui32> loc(#loc850)
%8817 = "mhlo.concatenate"(%8813, %8816) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc852)
%8818 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc853)
%8819 = "mhlo.reshape"(%8818) : (tensor<1xui32>) -> tensor<ui32> loc(#loc854)
%8820 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc855)
%8821 = "mhlo.reshape"(%8820) : (tensor<1xui32>) -> tensor<ui32> loc(#loc854)
%8822 = "mhlo.slice"(%8817) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc856)
%8823 = "mhlo.slice"(%8817) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc857)
%8824 = mhlo.xor %8819, %8821 : tensor<ui32> loc(#loc858)
%8825 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc859)
%8826 = mhlo.xor %8824, %8825 : tensor<ui32> loc(#loc858)
%8827 = "mhlo.broadcast_in_dim"(%8819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8828 = mhlo.add %8822, %8827 : tensor<1xui32> loc(#loc860)
%8829 = "mhlo.broadcast_in_dim"(%8821) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8830 = mhlo.add %8823, %8829 : tensor<1xui32> loc(#loc860)
%8831 = mhlo.add %8828, %8830 : tensor<1xui32> loc(#loc860)
%8832 = mhlo.constant dense<13> : tensor<ui32> loc(#loc859)
%8833 = "mhlo.broadcast_in_dim"(%8832) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8834 = mhlo.shift_left %8830, %8833 : tensor<1xui32> loc(#loc861)
%8835 = mhlo.constant dense<19> : tensor<ui32> loc(#loc859)
%8836 = "mhlo.broadcast_in_dim"(%8835) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8837 = mhlo.shift_right_logical %8830, %8836 : tensor<1xui32> loc(#loc849)
%8838 = mhlo.or %8834, %8837 : tensor<1xui32> loc(#loc862)
%8839 = mhlo.xor %8831, %8838 : tensor<1xui32> loc(#loc858)
%8840 = mhlo.add %8831, %8839 : tensor<1xui32> loc(#loc860)
%8841 = mhlo.constant dense<15> : tensor<ui32> loc(#loc859)
%8842 = "mhlo.broadcast_in_dim"(%8841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8843 = mhlo.shift_left %8839, %8842 : tensor<1xui32> loc(#loc861)
%8844 = mhlo.constant dense<17> : tensor<ui32> loc(#loc859)
%8845 = "mhlo.broadcast_in_dim"(%8844) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8846 = mhlo.shift_right_logical %8839, %8845 : tensor<1xui32> loc(#loc849)
%8847 = mhlo.or %8843, %8846 : tensor<1xui32> loc(#loc862)
%8848 = mhlo.xor %8840, %8847 : tensor<1xui32> loc(#loc858)
%8849 = mhlo.add %8840, %8848 : tensor<1xui32> loc(#loc860)
%8850 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%8851 = "mhlo.broadcast_in_dim"(%8850) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8852 = mhlo.shift_left %8848, %8851 : tensor<1xui32> loc(#loc861)
%8853 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%8854 = "mhlo.broadcast_in_dim"(%8853) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8855 = mhlo.shift_right_logical %8848, %8854 : tensor<1xui32> loc(#loc849)
%8856 = mhlo.or %8852, %8855 : tensor<1xui32> loc(#loc862)
%8857 = mhlo.xor %8849, %8856 : tensor<1xui32> loc(#loc858)
%8858 = mhlo.add %8849, %8857 : tensor<1xui32> loc(#loc860)
%8859 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%8860 = "mhlo.broadcast_in_dim"(%8859) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8861 = mhlo.shift_left %8857, %8860 : tensor<1xui32> loc(#loc861)
%8862 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%8863 = "mhlo.broadcast_in_dim"(%8862) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8864 = mhlo.shift_right_logical %8857, %8863 : tensor<1xui32> loc(#loc849)
%8865 = mhlo.or %8861, %8864 : tensor<1xui32> loc(#loc862)
%8866 = mhlo.xor %8858, %8865 : tensor<1xui32> loc(#loc858)
%8867 = "mhlo.broadcast_in_dim"(%8821) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8868 = mhlo.add %8858, %8867 : tensor<1xui32> loc(#loc860)
%8869 = "mhlo.broadcast_in_dim"(%8826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8870 = mhlo.add %8866, %8869 : tensor<1xui32> loc(#loc860)
%8871 = mhlo.constant dense<1> : tensor<ui32> loc(#loc859)
%8872 = "mhlo.broadcast_in_dim"(%8871) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8873 = mhlo.add %8870, %8872 : tensor<1xui32> loc(#loc860)
%8874 = mhlo.add %8868, %8873 : tensor<1xui32> loc(#loc860)
%8875 = mhlo.constant dense<17> : tensor<ui32> loc(#loc859)
%8876 = "mhlo.broadcast_in_dim"(%8875) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8877 = mhlo.shift_left %8873, %8876 : tensor<1xui32> loc(#loc861)
%8878 = mhlo.constant dense<15> : tensor<ui32> loc(#loc859)
%8879 = "mhlo.broadcast_in_dim"(%8878) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8880 = mhlo.shift_right_logical %8873, %8879 : tensor<1xui32> loc(#loc849)
%8881 = mhlo.or %8877, %8880 : tensor<1xui32> loc(#loc862)
%8882 = mhlo.xor %8874, %8881 : tensor<1xui32> loc(#loc858)
%8883 = mhlo.add %8874, %8882 : tensor<1xui32> loc(#loc860)
%8884 = mhlo.constant dense<29> : tensor<ui32> loc(#loc859)
%8885 = "mhlo.broadcast_in_dim"(%8884) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8886 = mhlo.shift_left %8882, %8885 : tensor<1xui32> loc(#loc861)
%8887 = mhlo.constant dense<3> : tensor<ui32> loc(#loc859)
%8888 = "mhlo.broadcast_in_dim"(%8887) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8889 = mhlo.shift_right_logical %8882, %8888 : tensor<1xui32> loc(#loc849)
%8890 = mhlo.or %8886, %8889 : tensor<1xui32> loc(#loc862)
%8891 = mhlo.xor %8883, %8890 : tensor<1xui32> loc(#loc858)
%8892 = mhlo.add %8883, %8891 : tensor<1xui32> loc(#loc860)
%8893 = mhlo.constant dense<16> : tensor<ui32> loc(#loc859)
%8894 = "mhlo.broadcast_in_dim"(%8893) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8895 = mhlo.shift_left %8891, %8894 : tensor<1xui32> loc(#loc861)
%8896 = mhlo.constant dense<16> : tensor<ui32> loc(#loc859)
%8897 = "mhlo.broadcast_in_dim"(%8896) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8898 = mhlo.shift_right_logical %8891, %8897 : tensor<1xui32> loc(#loc849)
%8899 = mhlo.or %8895, %8898 : tensor<1xui32> loc(#loc862)
%8900 = mhlo.xor %8892, %8899 : tensor<1xui32> loc(#loc858)
%8901 = mhlo.add %8892, %8900 : tensor<1xui32> loc(#loc860)
%8902 = mhlo.constant dense<24> : tensor<ui32> loc(#loc859)
%8903 = "mhlo.broadcast_in_dim"(%8902) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8904 = mhlo.shift_left %8900, %8903 : tensor<1xui32> loc(#loc861)
%8905 = mhlo.constant dense<8> : tensor<ui32> loc(#loc859)
%8906 = "mhlo.broadcast_in_dim"(%8905) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8907 = mhlo.shift_right_logical %8900, %8906 : tensor<1xui32> loc(#loc849)
%8908 = mhlo.or %8904, %8907 : tensor<1xui32> loc(#loc862)
%8909 = mhlo.xor %8901, %8908 : tensor<1xui32> loc(#loc858)
%8910 = "mhlo.broadcast_in_dim"(%8826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8911 = mhlo.add %8901, %8910 : tensor<1xui32> loc(#loc860)
%8912 = "mhlo.broadcast_in_dim"(%8819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8913 = mhlo.add %8909, %8912 : tensor<1xui32> loc(#loc860)
%8914 = mhlo.constant dense<2> : tensor<ui32> loc(#loc859)
%8915 = "mhlo.broadcast_in_dim"(%8914) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8916 = mhlo.add %8913, %8915 : tensor<1xui32> loc(#loc860)
%8917 = mhlo.add %8911, %8916 : tensor<1xui32> loc(#loc860)
%8918 = mhlo.constant dense<13> : tensor<ui32> loc(#loc859)
%8919 = "mhlo.broadcast_in_dim"(%8918) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8920 = mhlo.shift_left %8916, %8919 : tensor<1xui32> loc(#loc861)
%8921 = mhlo.constant dense<19> : tensor<ui32> loc(#loc859)
%8922 = "mhlo.broadcast_in_dim"(%8921) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8923 = mhlo.shift_right_logical %8916, %8922 : tensor<1xui32> loc(#loc849)
%8924 = mhlo.or %8920, %8923 : tensor<1xui32> loc(#loc862)
%8925 = mhlo.xor %8917, %8924 : tensor<1xui32> loc(#loc858)
%8926 = mhlo.add %8917, %8925 : tensor<1xui32> loc(#loc860)
%8927 = mhlo.constant dense<15> : tensor<ui32> loc(#loc859)
%8928 = "mhlo.broadcast_in_dim"(%8927) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8929 = mhlo.shift_left %8925, %8928 : tensor<1xui32> loc(#loc861)
%8930 = mhlo.constant dense<17> : tensor<ui32> loc(#loc859)
%8931 = "mhlo.broadcast_in_dim"(%8930) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8932 = mhlo.shift_right_logical %8925, %8931 : tensor<1xui32> loc(#loc849)
%8933 = mhlo.or %8929, %8932 : tensor<1xui32> loc(#loc862)
%8934 = mhlo.xor %8926, %8933 : tensor<1xui32> loc(#loc858)
%8935 = mhlo.add %8926, %8934 : tensor<1xui32> loc(#loc860)
%8936 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%8937 = "mhlo.broadcast_in_dim"(%8936) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8938 = mhlo.shift_left %8934, %8937 : tensor<1xui32> loc(#loc861)
%8939 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%8940 = "mhlo.broadcast_in_dim"(%8939) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8941 = mhlo.shift_right_logical %8934, %8940 : tensor<1xui32> loc(#loc849)
%8942 = mhlo.or %8938, %8941 : tensor<1xui32> loc(#loc862)
%8943 = mhlo.xor %8935, %8942 : tensor<1xui32> loc(#loc858)
%8944 = mhlo.add %8935, %8943 : tensor<1xui32> loc(#loc860)
%8945 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%8946 = "mhlo.broadcast_in_dim"(%8945) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8947 = mhlo.shift_left %8943, %8946 : tensor<1xui32> loc(#loc861)
%8948 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%8949 = "mhlo.broadcast_in_dim"(%8948) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8950 = mhlo.shift_right_logical %8943, %8949 : tensor<1xui32> loc(#loc849)
%8951 = mhlo.or %8947, %8950 : tensor<1xui32> loc(#loc862)
%8952 = mhlo.xor %8944, %8951 : tensor<1xui32> loc(#loc858)
%8953 = "mhlo.broadcast_in_dim"(%8819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8954 = mhlo.add %8944, %8953 : tensor<1xui32> loc(#loc860)
%8955 = "mhlo.broadcast_in_dim"(%8821) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8956 = mhlo.add %8952, %8955 : tensor<1xui32> loc(#loc860)
%8957 = mhlo.constant dense<3> : tensor<ui32> loc(#loc859)
%8958 = "mhlo.broadcast_in_dim"(%8957) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8959 = mhlo.add %8956, %8958 : tensor<1xui32> loc(#loc860)
%8960 = mhlo.add %8954, %8959 : tensor<1xui32> loc(#loc860)
%8961 = mhlo.constant dense<17> : tensor<ui32> loc(#loc859)
%8962 = "mhlo.broadcast_in_dim"(%8961) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8963 = mhlo.shift_left %8959, %8962 : tensor<1xui32> loc(#loc861)
%8964 = mhlo.constant dense<15> : tensor<ui32> loc(#loc859)
%8965 = "mhlo.broadcast_in_dim"(%8964) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8966 = mhlo.shift_right_logical %8959, %8965 : tensor<1xui32> loc(#loc849)
%8967 = mhlo.or %8963, %8966 : tensor<1xui32> loc(#loc862)
%8968 = mhlo.xor %8960, %8967 : tensor<1xui32> loc(#loc858)
%8969 = mhlo.add %8960, %8968 : tensor<1xui32> loc(#loc860)
%8970 = mhlo.constant dense<29> : tensor<ui32> loc(#loc859)
%8971 = "mhlo.broadcast_in_dim"(%8970) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8972 = mhlo.shift_left %8968, %8971 : tensor<1xui32> loc(#loc861)
%8973 = mhlo.constant dense<3> : tensor<ui32> loc(#loc859)
%8974 = "mhlo.broadcast_in_dim"(%8973) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8975 = mhlo.shift_right_logical %8968, %8974 : tensor<1xui32> loc(#loc849)
%8976 = mhlo.or %8972, %8975 : tensor<1xui32> loc(#loc862)
%8977 = mhlo.xor %8969, %8976 : tensor<1xui32> loc(#loc858)
%8978 = mhlo.add %8969, %8977 : tensor<1xui32> loc(#loc860)
%8979 = mhlo.constant dense<16> : tensor<ui32> loc(#loc859)
%8980 = "mhlo.broadcast_in_dim"(%8979) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8981 = mhlo.shift_left %8977, %8980 : tensor<1xui32> loc(#loc861)
%8982 = mhlo.constant dense<16> : tensor<ui32> loc(#loc859)
%8983 = "mhlo.broadcast_in_dim"(%8982) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8984 = mhlo.shift_right_logical %8977, %8983 : tensor<1xui32> loc(#loc849)
%8985 = mhlo.or %8981, %8984 : tensor<1xui32> loc(#loc862)
%8986 = mhlo.xor %8978, %8985 : tensor<1xui32> loc(#loc858)
%8987 = mhlo.add %8978, %8986 : tensor<1xui32> loc(#loc860)
%8988 = mhlo.constant dense<24> : tensor<ui32> loc(#loc859)
%8989 = "mhlo.broadcast_in_dim"(%8988) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%8990 = mhlo.shift_left %8986, %8989 : tensor<1xui32> loc(#loc861)
%8991 = mhlo.constant dense<8> : tensor<ui32> loc(#loc859)
%8992 = "mhlo.broadcast_in_dim"(%8991) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%8993 = mhlo.shift_right_logical %8986, %8992 : tensor<1xui32> loc(#loc849)
%8994 = mhlo.or %8990, %8993 : tensor<1xui32> loc(#loc862)
%8995 = mhlo.xor %8987, %8994 : tensor<1xui32> loc(#loc858)
%8996 = "mhlo.broadcast_in_dim"(%8821) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8997 = mhlo.add %8987, %8996 : tensor<1xui32> loc(#loc860)
%8998 = "mhlo.broadcast_in_dim"(%8826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%8999 = mhlo.add %8995, %8998 : tensor<1xui32> loc(#loc860)
%9000 = mhlo.constant dense<4> : tensor<ui32> loc(#loc859)
%9001 = "mhlo.broadcast_in_dim"(%9000) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%9002 = mhlo.add %8999, %9001 : tensor<1xui32> loc(#loc860)
%9003 = mhlo.add %8997, %9002 : tensor<1xui32> loc(#loc860)
%9004 = mhlo.constant dense<13> : tensor<ui32> loc(#loc859)
%9005 = "mhlo.broadcast_in_dim"(%9004) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%9006 = mhlo.shift_left %9002, %9005 : tensor<1xui32> loc(#loc861)
%9007 = mhlo.constant dense<19> : tensor<ui32> loc(#loc859)
%9008 = "mhlo.broadcast_in_dim"(%9007) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%9009 = mhlo.shift_right_logical %9002, %9008 : tensor<1xui32> loc(#loc849)
%9010 = mhlo.or %9006, %9009 : tensor<1xui32> loc(#loc862)
%9011 = mhlo.xor %9003, %9010 : tensor<1xui32> loc(#loc858)
%9012 = mhlo.add %9003, %9011 : tensor<1xui32> loc(#loc860)
%9013 = mhlo.constant dense<15> : tensor<ui32> loc(#loc859)
%9014 = "mhlo.broadcast_in_dim"(%9013) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%9015 = mhlo.shift_left %9011, %9014 : tensor<1xui32> loc(#loc861)
%9016 = mhlo.constant dense<17> : tensor<ui32> loc(#loc859)
%9017 = "mhlo.broadcast_in_dim"(%9016) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%9018 = mhlo.shift_right_logical %9011, %9017 : tensor<1xui32> loc(#loc849)
%9019 = mhlo.or %9015, %9018 : tensor<1xui32> loc(#loc862)
%9020 = mhlo.xor %9012, %9019 : tensor<1xui32> loc(#loc858)
%9021 = mhlo.add %9012, %9020 : tensor<1xui32> loc(#loc860)
%9022 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%9023 = "mhlo.broadcast_in_dim"(%9022) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%9024 = mhlo.shift_left %9020, %9023 : tensor<1xui32> loc(#loc861)
%9025 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%9026 = "mhlo.broadcast_in_dim"(%9025) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%9027 = mhlo.shift_right_logical %9020, %9026 : tensor<1xui32> loc(#loc849)
%9028 = mhlo.or %9024, %9027 : tensor<1xui32> loc(#loc862)
%9029 = mhlo.xor %9021, %9028 : tensor<1xui32> loc(#loc858)
%9030 = mhlo.add %9021, %9029 : tensor<1xui32> loc(#loc860)
%9031 = mhlo.constant dense<6> : tensor<ui32> loc(#loc859)
%9032 = "mhlo.broadcast_in_dim"(%9031) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc861)
%9033 = mhlo.shift_left %9029, %9032 : tensor<1xui32> loc(#loc861)
%9034 = mhlo.constant dense<26> : tensor<ui32> loc(#loc859)
%9035 = "mhlo.broadcast_in_dim"(%9034) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc849)
%9036 = mhlo.shift_right_logical %9029, %9035 : tensor<1xui32> loc(#loc849)
%9037 = mhlo.or %9033, %9036 : tensor<1xui32> loc(#loc862)
%9038 = mhlo.xor %9030, %9037 : tensor<1xui32> loc(#loc858)
%9039 = "mhlo.broadcast_in_dim"(%8826) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%9040 = mhlo.add %9030, %9039 : tensor<1xui32> loc(#loc860)
%9041 = "mhlo.broadcast_in_dim"(%8819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%9042 = mhlo.add %9038, %9041 : tensor<1xui32> loc(#loc860)
%9043 = mhlo.constant dense<5> : tensor<ui32> loc(#loc859)
%9044 = "mhlo.broadcast_in_dim"(%9043) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc860)
%9045 = mhlo.add %9042, %9044 : tensor<1xui32> loc(#loc860)
%9046 = "mhlo.concatenate"(%9040, %9045) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc852)
%9047 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%9048 = "mhlo.broadcast_in_dim"(%9047) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc863)
%9049 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%9050 = "mhlo.broadcast_in_dim"(%9049) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc863)
%9051 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc864)
%9052 = "mhlo.slice"(%9046) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc865)
%9053 = "mhlo.reshape"(%9052) : (tensor<1xui32>) -> tensor<ui32> loc(#loc866)
%9054 = "mhlo.slice"(%9046) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc867)
%9055 = "mhlo.reshape"(%9054) : (tensor<1xui32>) -> tensor<ui32> loc(#loc866)
%9056 = "mhlo.slice"(%9051) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc868)
%9057 = "mhlo.slice"(%9051) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc869)
%9058 = mhlo.xor %9053, %9055 : tensor<ui32> loc(#loc870)
%9059 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc871)
%9060 = mhlo.xor %9058, %9059 : tensor<ui32> loc(#loc870)
%9061 = "mhlo.broadcast_in_dim"(%9053) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9062 = mhlo.add %9056, %9061 : tensor<2097152xui32> loc(#loc872)
%9063 = "mhlo.broadcast_in_dim"(%9055) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9064 = mhlo.add %9057, %9063 : tensor<2097152xui32> loc(#loc872)
%9065 = mhlo.add %9062, %9064 : tensor<2097152xui32> loc(#loc872)
%9066 = mhlo.constant dense<13> : tensor<ui32> loc(#loc871)
%9067 = "mhlo.broadcast_in_dim"(%9066) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9068 = mhlo.shift_left %9064, %9067 : tensor<2097152xui32> loc(#loc873)
%9069 = mhlo.constant dense<19> : tensor<ui32> loc(#loc871)
%9070 = "mhlo.broadcast_in_dim"(%9069) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9071 = mhlo.shift_right_logical %9064, %9070 : tensor<2097152xui32> loc(#loc874)
%9072 = mhlo.or %9068, %9071 : tensor<2097152xui32> loc(#loc875)
%9073 = mhlo.xor %9065, %9072 : tensor<2097152xui32> loc(#loc870)
%9074 = mhlo.add %9065, %9073 : tensor<2097152xui32> loc(#loc872)
%9075 = mhlo.constant dense<15> : tensor<ui32> loc(#loc871)
%9076 = "mhlo.broadcast_in_dim"(%9075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9077 = mhlo.shift_left %9073, %9076 : tensor<2097152xui32> loc(#loc873)
%9078 = mhlo.constant dense<17> : tensor<ui32> loc(#loc871)
%9079 = "mhlo.broadcast_in_dim"(%9078) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9080 = mhlo.shift_right_logical %9073, %9079 : tensor<2097152xui32> loc(#loc874)
%9081 = mhlo.or %9077, %9080 : tensor<2097152xui32> loc(#loc875)
%9082 = mhlo.xor %9074, %9081 : tensor<2097152xui32> loc(#loc870)
%9083 = mhlo.add %9074, %9082 : tensor<2097152xui32> loc(#loc872)
%9084 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9085 = "mhlo.broadcast_in_dim"(%9084) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9086 = mhlo.shift_left %9082, %9085 : tensor<2097152xui32> loc(#loc873)
%9087 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9088 = "mhlo.broadcast_in_dim"(%9087) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9089 = mhlo.shift_right_logical %9082, %9088 : tensor<2097152xui32> loc(#loc874)
%9090 = mhlo.or %9086, %9089 : tensor<2097152xui32> loc(#loc875)
%9091 = mhlo.xor %9083, %9090 : tensor<2097152xui32> loc(#loc870)
%9092 = mhlo.add %9083, %9091 : tensor<2097152xui32> loc(#loc872)
%9093 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9094 = "mhlo.broadcast_in_dim"(%9093) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9095 = mhlo.shift_left %9091, %9094 : tensor<2097152xui32> loc(#loc873)
%9096 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9097 = "mhlo.broadcast_in_dim"(%9096) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9098 = mhlo.shift_right_logical %9091, %9097 : tensor<2097152xui32> loc(#loc874)
%9099 = mhlo.or %9095, %9098 : tensor<2097152xui32> loc(#loc875)
%9100 = mhlo.xor %9092, %9099 : tensor<2097152xui32> loc(#loc870)
%9101 = "mhlo.broadcast_in_dim"(%9055) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9102 = mhlo.add %9092, %9101 : tensor<2097152xui32> loc(#loc872)
%9103 = "mhlo.broadcast_in_dim"(%9060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9104 = mhlo.add %9100, %9103 : tensor<2097152xui32> loc(#loc872)
%9105 = mhlo.constant dense<1> : tensor<ui32> loc(#loc871)
%9106 = "mhlo.broadcast_in_dim"(%9105) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9107 = mhlo.add %9104, %9106 : tensor<2097152xui32> loc(#loc872)
%9108 = mhlo.add %9102, %9107 : tensor<2097152xui32> loc(#loc872)
%9109 = mhlo.constant dense<17> : tensor<ui32> loc(#loc871)
%9110 = "mhlo.broadcast_in_dim"(%9109) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9111 = mhlo.shift_left %9107, %9110 : tensor<2097152xui32> loc(#loc873)
%9112 = mhlo.constant dense<15> : tensor<ui32> loc(#loc871)
%9113 = "mhlo.broadcast_in_dim"(%9112) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9114 = mhlo.shift_right_logical %9107, %9113 : tensor<2097152xui32> loc(#loc874)
%9115 = mhlo.or %9111, %9114 : tensor<2097152xui32> loc(#loc875)
%9116 = mhlo.xor %9108, %9115 : tensor<2097152xui32> loc(#loc870)
%9117 = mhlo.add %9108, %9116 : tensor<2097152xui32> loc(#loc872)
%9118 = mhlo.constant dense<29> : tensor<ui32> loc(#loc871)
%9119 = "mhlo.broadcast_in_dim"(%9118) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9120 = mhlo.shift_left %9116, %9119 : tensor<2097152xui32> loc(#loc873)
%9121 = mhlo.constant dense<3> : tensor<ui32> loc(#loc871)
%9122 = "mhlo.broadcast_in_dim"(%9121) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9123 = mhlo.shift_right_logical %9116, %9122 : tensor<2097152xui32> loc(#loc874)
%9124 = mhlo.or %9120, %9123 : tensor<2097152xui32> loc(#loc875)
%9125 = mhlo.xor %9117, %9124 : tensor<2097152xui32> loc(#loc870)
%9126 = mhlo.add %9117, %9125 : tensor<2097152xui32> loc(#loc872)
%9127 = mhlo.constant dense<16> : tensor<ui32> loc(#loc871)
%9128 = "mhlo.broadcast_in_dim"(%9127) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9129 = mhlo.shift_left %9125, %9128 : tensor<2097152xui32> loc(#loc873)
%9130 = mhlo.constant dense<16> : tensor<ui32> loc(#loc871)
%9131 = "mhlo.broadcast_in_dim"(%9130) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9132 = mhlo.shift_right_logical %9125, %9131 : tensor<2097152xui32> loc(#loc874)
%9133 = mhlo.or %9129, %9132 : tensor<2097152xui32> loc(#loc875)
%9134 = mhlo.xor %9126, %9133 : tensor<2097152xui32> loc(#loc870)
%9135 = mhlo.add %9126, %9134 : tensor<2097152xui32> loc(#loc872)
%9136 = mhlo.constant dense<24> : tensor<ui32> loc(#loc871)
%9137 = "mhlo.broadcast_in_dim"(%9136) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9138 = mhlo.shift_left %9134, %9137 : tensor<2097152xui32> loc(#loc873)
%9139 = mhlo.constant dense<8> : tensor<ui32> loc(#loc871)
%9140 = "mhlo.broadcast_in_dim"(%9139) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9141 = mhlo.shift_right_logical %9134, %9140 : tensor<2097152xui32> loc(#loc874)
%9142 = mhlo.or %9138, %9141 : tensor<2097152xui32> loc(#loc875)
%9143 = mhlo.xor %9135, %9142 : tensor<2097152xui32> loc(#loc870)
%9144 = "mhlo.broadcast_in_dim"(%9060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9145 = mhlo.add %9135, %9144 : tensor<2097152xui32> loc(#loc872)
%9146 = "mhlo.broadcast_in_dim"(%9053) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9147 = mhlo.add %9143, %9146 : tensor<2097152xui32> loc(#loc872)
%9148 = mhlo.constant dense<2> : tensor<ui32> loc(#loc871)
%9149 = "mhlo.broadcast_in_dim"(%9148) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9150 = mhlo.add %9147, %9149 : tensor<2097152xui32> loc(#loc872)
%9151 = mhlo.add %9145, %9150 : tensor<2097152xui32> loc(#loc872)
%9152 = mhlo.constant dense<13> : tensor<ui32> loc(#loc871)
%9153 = "mhlo.broadcast_in_dim"(%9152) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9154 = mhlo.shift_left %9150, %9153 : tensor<2097152xui32> loc(#loc873)
%9155 = mhlo.constant dense<19> : tensor<ui32> loc(#loc871)
%9156 = "mhlo.broadcast_in_dim"(%9155) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9157 = mhlo.shift_right_logical %9150, %9156 : tensor<2097152xui32> loc(#loc874)
%9158 = mhlo.or %9154, %9157 : tensor<2097152xui32> loc(#loc875)
%9159 = mhlo.xor %9151, %9158 : tensor<2097152xui32> loc(#loc870)
%9160 = mhlo.add %9151, %9159 : tensor<2097152xui32> loc(#loc872)
%9161 = mhlo.constant dense<15> : tensor<ui32> loc(#loc871)
%9162 = "mhlo.broadcast_in_dim"(%9161) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9163 = mhlo.shift_left %9159, %9162 : tensor<2097152xui32> loc(#loc873)
%9164 = mhlo.constant dense<17> : tensor<ui32> loc(#loc871)
%9165 = "mhlo.broadcast_in_dim"(%9164) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9166 = mhlo.shift_right_logical %9159, %9165 : tensor<2097152xui32> loc(#loc874)
%9167 = mhlo.or %9163, %9166 : tensor<2097152xui32> loc(#loc875)
%9168 = mhlo.xor %9160, %9167 : tensor<2097152xui32> loc(#loc870)
%9169 = mhlo.add %9160, %9168 : tensor<2097152xui32> loc(#loc872)
%9170 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9171 = "mhlo.broadcast_in_dim"(%9170) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9172 = mhlo.shift_left %9168, %9171 : tensor<2097152xui32> loc(#loc873)
%9173 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9174 = "mhlo.broadcast_in_dim"(%9173) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9175 = mhlo.shift_right_logical %9168, %9174 : tensor<2097152xui32> loc(#loc874)
%9176 = mhlo.or %9172, %9175 : tensor<2097152xui32> loc(#loc875)
%9177 = mhlo.xor %9169, %9176 : tensor<2097152xui32> loc(#loc870)
%9178 = mhlo.add %9169, %9177 : tensor<2097152xui32> loc(#loc872)
%9179 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9180 = "mhlo.broadcast_in_dim"(%9179) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9181 = mhlo.shift_left %9177, %9180 : tensor<2097152xui32> loc(#loc873)
%9182 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9183 = "mhlo.broadcast_in_dim"(%9182) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9184 = mhlo.shift_right_logical %9177, %9183 : tensor<2097152xui32> loc(#loc874)
%9185 = mhlo.or %9181, %9184 : tensor<2097152xui32> loc(#loc875)
%9186 = mhlo.xor %9178, %9185 : tensor<2097152xui32> loc(#loc870)
%9187 = "mhlo.broadcast_in_dim"(%9053) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9188 = mhlo.add %9178, %9187 : tensor<2097152xui32> loc(#loc872)
%9189 = "mhlo.broadcast_in_dim"(%9055) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9190 = mhlo.add %9186, %9189 : tensor<2097152xui32> loc(#loc872)
%9191 = mhlo.constant dense<3> : tensor<ui32> loc(#loc871)
%9192 = "mhlo.broadcast_in_dim"(%9191) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9193 = mhlo.add %9190, %9192 : tensor<2097152xui32> loc(#loc872)
%9194 = mhlo.add %9188, %9193 : tensor<2097152xui32> loc(#loc872)
%9195 = mhlo.constant dense<17> : tensor<ui32> loc(#loc871)
%9196 = "mhlo.broadcast_in_dim"(%9195) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9197 = mhlo.shift_left %9193, %9196 : tensor<2097152xui32> loc(#loc873)
%9198 = mhlo.constant dense<15> : tensor<ui32> loc(#loc871)
%9199 = "mhlo.broadcast_in_dim"(%9198) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9200 = mhlo.shift_right_logical %9193, %9199 : tensor<2097152xui32> loc(#loc874)
%9201 = mhlo.or %9197, %9200 : tensor<2097152xui32> loc(#loc875)
%9202 = mhlo.xor %9194, %9201 : tensor<2097152xui32> loc(#loc870)
%9203 = mhlo.add %9194, %9202 : tensor<2097152xui32> loc(#loc872)
%9204 = mhlo.constant dense<29> : tensor<ui32> loc(#loc871)
%9205 = "mhlo.broadcast_in_dim"(%9204) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9206 = mhlo.shift_left %9202, %9205 : tensor<2097152xui32> loc(#loc873)
%9207 = mhlo.constant dense<3> : tensor<ui32> loc(#loc871)
%9208 = "mhlo.broadcast_in_dim"(%9207) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9209 = mhlo.shift_right_logical %9202, %9208 : tensor<2097152xui32> loc(#loc874)
%9210 = mhlo.or %9206, %9209 : tensor<2097152xui32> loc(#loc875)
%9211 = mhlo.xor %9203, %9210 : tensor<2097152xui32> loc(#loc870)
%9212 = mhlo.add %9203, %9211 : tensor<2097152xui32> loc(#loc872)
%9213 = mhlo.constant dense<16> : tensor<ui32> loc(#loc871)
%9214 = "mhlo.broadcast_in_dim"(%9213) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9215 = mhlo.shift_left %9211, %9214 : tensor<2097152xui32> loc(#loc873)
%9216 = mhlo.constant dense<16> : tensor<ui32> loc(#loc871)
%9217 = "mhlo.broadcast_in_dim"(%9216) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9218 = mhlo.shift_right_logical %9211, %9217 : tensor<2097152xui32> loc(#loc874)
%9219 = mhlo.or %9215, %9218 : tensor<2097152xui32> loc(#loc875)
%9220 = mhlo.xor %9212, %9219 : tensor<2097152xui32> loc(#loc870)
%9221 = mhlo.add %9212, %9220 : tensor<2097152xui32> loc(#loc872)
%9222 = mhlo.constant dense<24> : tensor<ui32> loc(#loc871)
%9223 = "mhlo.broadcast_in_dim"(%9222) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9224 = mhlo.shift_left %9220, %9223 : tensor<2097152xui32> loc(#loc873)
%9225 = mhlo.constant dense<8> : tensor<ui32> loc(#loc871)
%9226 = "mhlo.broadcast_in_dim"(%9225) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9227 = mhlo.shift_right_logical %9220, %9226 : tensor<2097152xui32> loc(#loc874)
%9228 = mhlo.or %9224, %9227 : tensor<2097152xui32> loc(#loc875)
%9229 = mhlo.xor %9221, %9228 : tensor<2097152xui32> loc(#loc870)
%9230 = "mhlo.broadcast_in_dim"(%9055) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9231 = mhlo.add %9221, %9230 : tensor<2097152xui32> loc(#loc872)
%9232 = "mhlo.broadcast_in_dim"(%9060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9233 = mhlo.add %9229, %9232 : tensor<2097152xui32> loc(#loc872)
%9234 = mhlo.constant dense<4> : tensor<ui32> loc(#loc871)
%9235 = "mhlo.broadcast_in_dim"(%9234) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9236 = mhlo.add %9233, %9235 : tensor<2097152xui32> loc(#loc872)
%9237 = mhlo.add %9231, %9236 : tensor<2097152xui32> loc(#loc872)
%9238 = mhlo.constant dense<13> : tensor<ui32> loc(#loc871)
%9239 = "mhlo.broadcast_in_dim"(%9238) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9240 = mhlo.shift_left %9236, %9239 : tensor<2097152xui32> loc(#loc873)
%9241 = mhlo.constant dense<19> : tensor<ui32> loc(#loc871)
%9242 = "mhlo.broadcast_in_dim"(%9241) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9243 = mhlo.shift_right_logical %9236, %9242 : tensor<2097152xui32> loc(#loc874)
%9244 = mhlo.or %9240, %9243 : tensor<2097152xui32> loc(#loc875)
%9245 = mhlo.xor %9237, %9244 : tensor<2097152xui32> loc(#loc870)
%9246 = mhlo.add %9237, %9245 : tensor<2097152xui32> loc(#loc872)
%9247 = mhlo.constant dense<15> : tensor<ui32> loc(#loc871)
%9248 = "mhlo.broadcast_in_dim"(%9247) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9249 = mhlo.shift_left %9245, %9248 : tensor<2097152xui32> loc(#loc873)
%9250 = mhlo.constant dense<17> : tensor<ui32> loc(#loc871)
%9251 = "mhlo.broadcast_in_dim"(%9250) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9252 = mhlo.shift_right_logical %9245, %9251 : tensor<2097152xui32> loc(#loc874)
%9253 = mhlo.or %9249, %9252 : tensor<2097152xui32> loc(#loc875)
%9254 = mhlo.xor %9246, %9253 : tensor<2097152xui32> loc(#loc870)
%9255 = mhlo.add %9246, %9254 : tensor<2097152xui32> loc(#loc872)
%9256 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9257 = "mhlo.broadcast_in_dim"(%9256) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9258 = mhlo.shift_left %9254, %9257 : tensor<2097152xui32> loc(#loc873)
%9259 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9260 = "mhlo.broadcast_in_dim"(%9259) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9261 = mhlo.shift_right_logical %9254, %9260 : tensor<2097152xui32> loc(#loc874)
%9262 = mhlo.or %9258, %9261 : tensor<2097152xui32> loc(#loc875)
%9263 = mhlo.xor %9255, %9262 : tensor<2097152xui32> loc(#loc870)
%9264 = mhlo.add %9255, %9263 : tensor<2097152xui32> loc(#loc872)
%9265 = mhlo.constant dense<6> : tensor<ui32> loc(#loc871)
%9266 = "mhlo.broadcast_in_dim"(%9265) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc873)
%9267 = mhlo.shift_left %9263, %9266 : tensor<2097152xui32> loc(#loc873)
%9268 = mhlo.constant dense<26> : tensor<ui32> loc(#loc871)
%9269 = "mhlo.broadcast_in_dim"(%9268) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc874)
%9270 = mhlo.shift_right_logical %9263, %9269 : tensor<2097152xui32> loc(#loc874)
%9271 = mhlo.or %9267, %9270 : tensor<2097152xui32> loc(#loc875)
%9272 = mhlo.xor %9264, %9271 : tensor<2097152xui32> loc(#loc870)
%9273 = "mhlo.broadcast_in_dim"(%9060) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9274 = mhlo.add %9264, %9273 : tensor<2097152xui32> loc(#loc872)
%9275 = "mhlo.broadcast_in_dim"(%9053) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9276 = mhlo.add %9272, %9275 : tensor<2097152xui32> loc(#loc872)
%9277 = mhlo.constant dense<5> : tensor<ui32> loc(#loc871)
%9278 = "mhlo.broadcast_in_dim"(%9277) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc872)
%9279 = mhlo.add %9276, %9278 : tensor<2097152xui32> loc(#loc872)
%9280 = "mhlo.concatenate"(%9274, %9279) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc876)
%9281 = "mhlo.reshape"(%9280) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc877)
%9282 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%9283 = "mhlo.broadcast_in_dim"(%9282) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc874)
%9284 = mhlo.shift_right_logical %9281, %9283 : tensor<2048x2048xui32> loc(#loc874)
%9285 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%9286 = "mhlo.broadcast_in_dim"(%9285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc875)
%9287 = mhlo.or %9284, %9286 : tensor<2048x2048xui32> loc(#loc875)
%9288 = "mhlo.bitcast_convert"(%9287) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc878)
%9289 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%9290 = "mhlo.broadcast_in_dim"(%9289) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc879)
%9291 = mhlo.subtract %9288, %9290 : tensor<2048x2048xf32> loc(#loc879)
%9292 = mhlo.subtract %9050, %9048 : tensor<1x1xf32> loc(#loc879)
%9293 = "mhlo.broadcast_in_dim"(%9292) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc880)
%9294 = mhlo.multiply %9291, %9293 : tensor<2048x2048xf32> loc(#loc880)
%9295 = "mhlo.broadcast_in_dim"(%9048) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc872)
%9296 = mhlo.add %9294, %9295 : tensor<2048x2048xf32> loc(#loc872)
%9297 = "mhlo.broadcast_in_dim"(%9048) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc881)
%9298 = mhlo.maximum %9297, %9296 : tensor<2048x2048xf32> loc(#loc881)
%9299 = func.call @erf_inv_22(%9298) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc882)
%9300 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%9301 = "mhlo.broadcast_in_dim"(%9300) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc880)
%9302 = mhlo.multiply %9299, %9301 : tensor<2048x2048xf32> loc(#loc880)
%9303 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%9304 = "mhlo.broadcast_in_dim"(%9303) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc880)
%9305 = mhlo.multiply %9302, %9304 : tensor<2048x2048xf32> loc(#loc880)
%9306 = mhlo.convert(%9305) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc883)
%9307 = "mhlo.dot_general"(%iterArg_1, %9306) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc884)
%9308 = mhlo.constant dense<673573497> : tensor<ui32> loc(#loc531)
%9309 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%9310 = mhlo.shift_right_logical %9308, %9309 : tensor<ui32> loc(#loc885)
%9311 = "mhlo.reshape"(%9310) : (tensor<ui32>) -> tensor<1xui32> loc(#loc886)
%9312 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%9313 = mhlo.and %9308, %9312 : tensor<ui32> loc(#loc887)
%9314 = "mhlo.reshape"(%9313) : (tensor<ui32>) -> tensor<1xui32> loc(#loc886)
%9315 = "mhlo.concatenate"(%9311, %9314) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc888)
%9316 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc889)
%9317 = "mhlo.reshape"(%9316) : (tensor<1xui32>) -> tensor<ui32> loc(#loc890)
%9318 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc891)
%9319 = "mhlo.reshape"(%9318) : (tensor<1xui32>) -> tensor<ui32> loc(#loc890)
%9320 = "mhlo.slice"(%9315) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc892)
%9321 = "mhlo.slice"(%9315) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc893)
%9322 = mhlo.xor %9317, %9319 : tensor<ui32> loc(#loc894)
%9323 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc895)
%9324 = mhlo.xor %9322, %9323 : tensor<ui32> loc(#loc894)
%9325 = "mhlo.broadcast_in_dim"(%9317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9326 = mhlo.add %9320, %9325 : tensor<1xui32> loc(#loc896)
%9327 = "mhlo.broadcast_in_dim"(%9319) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9328 = mhlo.add %9321, %9327 : tensor<1xui32> loc(#loc896)
%9329 = mhlo.add %9326, %9328 : tensor<1xui32> loc(#loc896)
%9330 = mhlo.constant dense<13> : tensor<ui32> loc(#loc895)
%9331 = "mhlo.broadcast_in_dim"(%9330) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9332 = mhlo.shift_left %9328, %9331 : tensor<1xui32> loc(#loc897)
%9333 = mhlo.constant dense<19> : tensor<ui32> loc(#loc895)
%9334 = "mhlo.broadcast_in_dim"(%9333) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9335 = mhlo.shift_right_logical %9328, %9334 : tensor<1xui32> loc(#loc885)
%9336 = mhlo.or %9332, %9335 : tensor<1xui32> loc(#loc898)
%9337 = mhlo.xor %9329, %9336 : tensor<1xui32> loc(#loc894)
%9338 = mhlo.add %9329, %9337 : tensor<1xui32> loc(#loc896)
%9339 = mhlo.constant dense<15> : tensor<ui32> loc(#loc895)
%9340 = "mhlo.broadcast_in_dim"(%9339) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9341 = mhlo.shift_left %9337, %9340 : tensor<1xui32> loc(#loc897)
%9342 = mhlo.constant dense<17> : tensor<ui32> loc(#loc895)
%9343 = "mhlo.broadcast_in_dim"(%9342) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9344 = mhlo.shift_right_logical %9337, %9343 : tensor<1xui32> loc(#loc885)
%9345 = mhlo.or %9341, %9344 : tensor<1xui32> loc(#loc898)
%9346 = mhlo.xor %9338, %9345 : tensor<1xui32> loc(#loc894)
%9347 = mhlo.add %9338, %9346 : tensor<1xui32> loc(#loc896)
%9348 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9349 = "mhlo.broadcast_in_dim"(%9348) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9350 = mhlo.shift_left %9346, %9349 : tensor<1xui32> loc(#loc897)
%9351 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9352 = "mhlo.broadcast_in_dim"(%9351) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9353 = mhlo.shift_right_logical %9346, %9352 : tensor<1xui32> loc(#loc885)
%9354 = mhlo.or %9350, %9353 : tensor<1xui32> loc(#loc898)
%9355 = mhlo.xor %9347, %9354 : tensor<1xui32> loc(#loc894)
%9356 = mhlo.add %9347, %9355 : tensor<1xui32> loc(#loc896)
%9357 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9358 = "mhlo.broadcast_in_dim"(%9357) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9359 = mhlo.shift_left %9355, %9358 : tensor<1xui32> loc(#loc897)
%9360 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9361 = "mhlo.broadcast_in_dim"(%9360) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9362 = mhlo.shift_right_logical %9355, %9361 : tensor<1xui32> loc(#loc885)
%9363 = mhlo.or %9359, %9362 : tensor<1xui32> loc(#loc898)
%9364 = mhlo.xor %9356, %9363 : tensor<1xui32> loc(#loc894)
%9365 = "mhlo.broadcast_in_dim"(%9319) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9366 = mhlo.add %9356, %9365 : tensor<1xui32> loc(#loc896)
%9367 = "mhlo.broadcast_in_dim"(%9324) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9368 = mhlo.add %9364, %9367 : tensor<1xui32> loc(#loc896)
%9369 = mhlo.constant dense<1> : tensor<ui32> loc(#loc895)
%9370 = "mhlo.broadcast_in_dim"(%9369) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9371 = mhlo.add %9368, %9370 : tensor<1xui32> loc(#loc896)
%9372 = mhlo.add %9366, %9371 : tensor<1xui32> loc(#loc896)
%9373 = mhlo.constant dense<17> : tensor<ui32> loc(#loc895)
%9374 = "mhlo.broadcast_in_dim"(%9373) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9375 = mhlo.shift_left %9371, %9374 : tensor<1xui32> loc(#loc897)
%9376 = mhlo.constant dense<15> : tensor<ui32> loc(#loc895)
%9377 = "mhlo.broadcast_in_dim"(%9376) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9378 = mhlo.shift_right_logical %9371, %9377 : tensor<1xui32> loc(#loc885)
%9379 = mhlo.or %9375, %9378 : tensor<1xui32> loc(#loc898)
%9380 = mhlo.xor %9372, %9379 : tensor<1xui32> loc(#loc894)
%9381 = mhlo.add %9372, %9380 : tensor<1xui32> loc(#loc896)
%9382 = mhlo.constant dense<29> : tensor<ui32> loc(#loc895)
%9383 = "mhlo.broadcast_in_dim"(%9382) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9384 = mhlo.shift_left %9380, %9383 : tensor<1xui32> loc(#loc897)
%9385 = mhlo.constant dense<3> : tensor<ui32> loc(#loc895)
%9386 = "mhlo.broadcast_in_dim"(%9385) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9387 = mhlo.shift_right_logical %9380, %9386 : tensor<1xui32> loc(#loc885)
%9388 = mhlo.or %9384, %9387 : tensor<1xui32> loc(#loc898)
%9389 = mhlo.xor %9381, %9388 : tensor<1xui32> loc(#loc894)
%9390 = mhlo.add %9381, %9389 : tensor<1xui32> loc(#loc896)
%9391 = mhlo.constant dense<16> : tensor<ui32> loc(#loc895)
%9392 = "mhlo.broadcast_in_dim"(%9391) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9393 = mhlo.shift_left %9389, %9392 : tensor<1xui32> loc(#loc897)
%9394 = mhlo.constant dense<16> : tensor<ui32> loc(#loc895)
%9395 = "mhlo.broadcast_in_dim"(%9394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9396 = mhlo.shift_right_logical %9389, %9395 : tensor<1xui32> loc(#loc885)
%9397 = mhlo.or %9393, %9396 : tensor<1xui32> loc(#loc898)
%9398 = mhlo.xor %9390, %9397 : tensor<1xui32> loc(#loc894)
%9399 = mhlo.add %9390, %9398 : tensor<1xui32> loc(#loc896)
%9400 = mhlo.constant dense<24> : tensor<ui32> loc(#loc895)
%9401 = "mhlo.broadcast_in_dim"(%9400) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9402 = mhlo.shift_left %9398, %9401 : tensor<1xui32> loc(#loc897)
%9403 = mhlo.constant dense<8> : tensor<ui32> loc(#loc895)
%9404 = "mhlo.broadcast_in_dim"(%9403) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9405 = mhlo.shift_right_logical %9398, %9404 : tensor<1xui32> loc(#loc885)
%9406 = mhlo.or %9402, %9405 : tensor<1xui32> loc(#loc898)
%9407 = mhlo.xor %9399, %9406 : tensor<1xui32> loc(#loc894)
%9408 = "mhlo.broadcast_in_dim"(%9324) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9409 = mhlo.add %9399, %9408 : tensor<1xui32> loc(#loc896)
%9410 = "mhlo.broadcast_in_dim"(%9317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9411 = mhlo.add %9407, %9410 : tensor<1xui32> loc(#loc896)
%9412 = mhlo.constant dense<2> : tensor<ui32> loc(#loc895)
%9413 = "mhlo.broadcast_in_dim"(%9412) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9414 = mhlo.add %9411, %9413 : tensor<1xui32> loc(#loc896)
%9415 = mhlo.add %9409, %9414 : tensor<1xui32> loc(#loc896)
%9416 = mhlo.constant dense<13> : tensor<ui32> loc(#loc895)
%9417 = "mhlo.broadcast_in_dim"(%9416) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9418 = mhlo.shift_left %9414, %9417 : tensor<1xui32> loc(#loc897)
%9419 = mhlo.constant dense<19> : tensor<ui32> loc(#loc895)
%9420 = "mhlo.broadcast_in_dim"(%9419) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9421 = mhlo.shift_right_logical %9414, %9420 : tensor<1xui32> loc(#loc885)
%9422 = mhlo.or %9418, %9421 : tensor<1xui32> loc(#loc898)
%9423 = mhlo.xor %9415, %9422 : tensor<1xui32> loc(#loc894)
%9424 = mhlo.add %9415, %9423 : tensor<1xui32> loc(#loc896)
%9425 = mhlo.constant dense<15> : tensor<ui32> loc(#loc895)
%9426 = "mhlo.broadcast_in_dim"(%9425) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9427 = mhlo.shift_left %9423, %9426 : tensor<1xui32> loc(#loc897)
%9428 = mhlo.constant dense<17> : tensor<ui32> loc(#loc895)
%9429 = "mhlo.broadcast_in_dim"(%9428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9430 = mhlo.shift_right_logical %9423, %9429 : tensor<1xui32> loc(#loc885)
%9431 = mhlo.or %9427, %9430 : tensor<1xui32> loc(#loc898)
%9432 = mhlo.xor %9424, %9431 : tensor<1xui32> loc(#loc894)
%9433 = mhlo.add %9424, %9432 : tensor<1xui32> loc(#loc896)
%9434 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9435 = "mhlo.broadcast_in_dim"(%9434) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9436 = mhlo.shift_left %9432, %9435 : tensor<1xui32> loc(#loc897)
%9437 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9438 = "mhlo.broadcast_in_dim"(%9437) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9439 = mhlo.shift_right_logical %9432, %9438 : tensor<1xui32> loc(#loc885)
%9440 = mhlo.or %9436, %9439 : tensor<1xui32> loc(#loc898)
%9441 = mhlo.xor %9433, %9440 : tensor<1xui32> loc(#loc894)
%9442 = mhlo.add %9433, %9441 : tensor<1xui32> loc(#loc896)
%9443 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9444 = "mhlo.broadcast_in_dim"(%9443) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9445 = mhlo.shift_left %9441, %9444 : tensor<1xui32> loc(#loc897)
%9446 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9447 = "mhlo.broadcast_in_dim"(%9446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9448 = mhlo.shift_right_logical %9441, %9447 : tensor<1xui32> loc(#loc885)
%9449 = mhlo.or %9445, %9448 : tensor<1xui32> loc(#loc898)
%9450 = mhlo.xor %9442, %9449 : tensor<1xui32> loc(#loc894)
%9451 = "mhlo.broadcast_in_dim"(%9317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9452 = mhlo.add %9442, %9451 : tensor<1xui32> loc(#loc896)
%9453 = "mhlo.broadcast_in_dim"(%9319) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9454 = mhlo.add %9450, %9453 : tensor<1xui32> loc(#loc896)
%9455 = mhlo.constant dense<3> : tensor<ui32> loc(#loc895)
%9456 = "mhlo.broadcast_in_dim"(%9455) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9457 = mhlo.add %9454, %9456 : tensor<1xui32> loc(#loc896)
%9458 = mhlo.add %9452, %9457 : tensor<1xui32> loc(#loc896)
%9459 = mhlo.constant dense<17> : tensor<ui32> loc(#loc895)
%9460 = "mhlo.broadcast_in_dim"(%9459) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9461 = mhlo.shift_left %9457, %9460 : tensor<1xui32> loc(#loc897)
%9462 = mhlo.constant dense<15> : tensor<ui32> loc(#loc895)
%9463 = "mhlo.broadcast_in_dim"(%9462) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9464 = mhlo.shift_right_logical %9457, %9463 : tensor<1xui32> loc(#loc885)
%9465 = mhlo.or %9461, %9464 : tensor<1xui32> loc(#loc898)
%9466 = mhlo.xor %9458, %9465 : tensor<1xui32> loc(#loc894)
%9467 = mhlo.add %9458, %9466 : tensor<1xui32> loc(#loc896)
%9468 = mhlo.constant dense<29> : tensor<ui32> loc(#loc895)
%9469 = "mhlo.broadcast_in_dim"(%9468) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9470 = mhlo.shift_left %9466, %9469 : tensor<1xui32> loc(#loc897)
%9471 = mhlo.constant dense<3> : tensor<ui32> loc(#loc895)
%9472 = "mhlo.broadcast_in_dim"(%9471) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9473 = mhlo.shift_right_logical %9466, %9472 : tensor<1xui32> loc(#loc885)
%9474 = mhlo.or %9470, %9473 : tensor<1xui32> loc(#loc898)
%9475 = mhlo.xor %9467, %9474 : tensor<1xui32> loc(#loc894)
%9476 = mhlo.add %9467, %9475 : tensor<1xui32> loc(#loc896)
%9477 = mhlo.constant dense<16> : tensor<ui32> loc(#loc895)
%9478 = "mhlo.broadcast_in_dim"(%9477) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9479 = mhlo.shift_left %9475, %9478 : tensor<1xui32> loc(#loc897)
%9480 = mhlo.constant dense<16> : tensor<ui32> loc(#loc895)
%9481 = "mhlo.broadcast_in_dim"(%9480) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9482 = mhlo.shift_right_logical %9475, %9481 : tensor<1xui32> loc(#loc885)
%9483 = mhlo.or %9479, %9482 : tensor<1xui32> loc(#loc898)
%9484 = mhlo.xor %9476, %9483 : tensor<1xui32> loc(#loc894)
%9485 = mhlo.add %9476, %9484 : tensor<1xui32> loc(#loc896)
%9486 = mhlo.constant dense<24> : tensor<ui32> loc(#loc895)
%9487 = "mhlo.broadcast_in_dim"(%9486) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9488 = mhlo.shift_left %9484, %9487 : tensor<1xui32> loc(#loc897)
%9489 = mhlo.constant dense<8> : tensor<ui32> loc(#loc895)
%9490 = "mhlo.broadcast_in_dim"(%9489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9491 = mhlo.shift_right_logical %9484, %9490 : tensor<1xui32> loc(#loc885)
%9492 = mhlo.or %9488, %9491 : tensor<1xui32> loc(#loc898)
%9493 = mhlo.xor %9485, %9492 : tensor<1xui32> loc(#loc894)
%9494 = "mhlo.broadcast_in_dim"(%9319) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9495 = mhlo.add %9485, %9494 : tensor<1xui32> loc(#loc896)
%9496 = "mhlo.broadcast_in_dim"(%9324) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9497 = mhlo.add %9493, %9496 : tensor<1xui32> loc(#loc896)
%9498 = mhlo.constant dense<4> : tensor<ui32> loc(#loc895)
%9499 = "mhlo.broadcast_in_dim"(%9498) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9500 = mhlo.add %9497, %9499 : tensor<1xui32> loc(#loc896)
%9501 = mhlo.add %9495, %9500 : tensor<1xui32> loc(#loc896)
%9502 = mhlo.constant dense<13> : tensor<ui32> loc(#loc895)
%9503 = "mhlo.broadcast_in_dim"(%9502) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9504 = mhlo.shift_left %9500, %9503 : tensor<1xui32> loc(#loc897)
%9505 = mhlo.constant dense<19> : tensor<ui32> loc(#loc895)
%9506 = "mhlo.broadcast_in_dim"(%9505) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9507 = mhlo.shift_right_logical %9500, %9506 : tensor<1xui32> loc(#loc885)
%9508 = mhlo.or %9504, %9507 : tensor<1xui32> loc(#loc898)
%9509 = mhlo.xor %9501, %9508 : tensor<1xui32> loc(#loc894)
%9510 = mhlo.add %9501, %9509 : tensor<1xui32> loc(#loc896)
%9511 = mhlo.constant dense<15> : tensor<ui32> loc(#loc895)
%9512 = "mhlo.broadcast_in_dim"(%9511) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9513 = mhlo.shift_left %9509, %9512 : tensor<1xui32> loc(#loc897)
%9514 = mhlo.constant dense<17> : tensor<ui32> loc(#loc895)
%9515 = "mhlo.broadcast_in_dim"(%9514) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9516 = mhlo.shift_right_logical %9509, %9515 : tensor<1xui32> loc(#loc885)
%9517 = mhlo.or %9513, %9516 : tensor<1xui32> loc(#loc898)
%9518 = mhlo.xor %9510, %9517 : tensor<1xui32> loc(#loc894)
%9519 = mhlo.add %9510, %9518 : tensor<1xui32> loc(#loc896)
%9520 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9521 = "mhlo.broadcast_in_dim"(%9520) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9522 = mhlo.shift_left %9518, %9521 : tensor<1xui32> loc(#loc897)
%9523 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9524 = "mhlo.broadcast_in_dim"(%9523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9525 = mhlo.shift_right_logical %9518, %9524 : tensor<1xui32> loc(#loc885)
%9526 = mhlo.or %9522, %9525 : tensor<1xui32> loc(#loc898)
%9527 = mhlo.xor %9519, %9526 : tensor<1xui32> loc(#loc894)
%9528 = mhlo.add %9519, %9527 : tensor<1xui32> loc(#loc896)
%9529 = mhlo.constant dense<6> : tensor<ui32> loc(#loc895)
%9530 = "mhlo.broadcast_in_dim"(%9529) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc897)
%9531 = mhlo.shift_left %9527, %9530 : tensor<1xui32> loc(#loc897)
%9532 = mhlo.constant dense<26> : tensor<ui32> loc(#loc895)
%9533 = "mhlo.broadcast_in_dim"(%9532) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc885)
%9534 = mhlo.shift_right_logical %9527, %9533 : tensor<1xui32> loc(#loc885)
%9535 = mhlo.or %9531, %9534 : tensor<1xui32> loc(#loc898)
%9536 = mhlo.xor %9528, %9535 : tensor<1xui32> loc(#loc894)
%9537 = "mhlo.broadcast_in_dim"(%9324) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9538 = mhlo.add %9528, %9537 : tensor<1xui32> loc(#loc896)
%9539 = "mhlo.broadcast_in_dim"(%9317) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9540 = mhlo.add %9536, %9539 : tensor<1xui32> loc(#loc896)
%9541 = mhlo.constant dense<5> : tensor<ui32> loc(#loc895)
%9542 = "mhlo.broadcast_in_dim"(%9541) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc896)
%9543 = mhlo.add %9540, %9542 : tensor<1xui32> loc(#loc896)
%9544 = "mhlo.concatenate"(%9538, %9543) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc888)
%9545 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%9546 = "mhlo.broadcast_in_dim"(%9545) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc899)
%9547 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%9548 = "mhlo.broadcast_in_dim"(%9547) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc899)
%9549 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc900)
%9550 = "mhlo.slice"(%9544) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc901)
%9551 = "mhlo.reshape"(%9550) : (tensor<1xui32>) -> tensor<ui32> loc(#loc902)
%9552 = "mhlo.slice"(%9544) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc903)
%9553 = "mhlo.reshape"(%9552) : (tensor<1xui32>) -> tensor<ui32> loc(#loc902)
%9554 = "mhlo.slice"(%9549) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc904)
%9555 = "mhlo.slice"(%9549) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc905)
%9556 = mhlo.xor %9551, %9553 : tensor<ui32> loc(#loc906)
%9557 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc907)
%9558 = mhlo.xor %9556, %9557 : tensor<ui32> loc(#loc906)
%9559 = "mhlo.broadcast_in_dim"(%9551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9560 = mhlo.add %9554, %9559 : tensor<2097152xui32> loc(#loc908)
%9561 = "mhlo.broadcast_in_dim"(%9553) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9562 = mhlo.add %9555, %9561 : tensor<2097152xui32> loc(#loc908)
%9563 = mhlo.add %9560, %9562 : tensor<2097152xui32> loc(#loc908)
%9564 = mhlo.constant dense<13> : tensor<ui32> loc(#loc907)
%9565 = "mhlo.broadcast_in_dim"(%9564) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9566 = mhlo.shift_left %9562, %9565 : tensor<2097152xui32> loc(#loc909)
%9567 = mhlo.constant dense<19> : tensor<ui32> loc(#loc907)
%9568 = "mhlo.broadcast_in_dim"(%9567) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9569 = mhlo.shift_right_logical %9562, %9568 : tensor<2097152xui32> loc(#loc910)
%9570 = mhlo.or %9566, %9569 : tensor<2097152xui32> loc(#loc911)
%9571 = mhlo.xor %9563, %9570 : tensor<2097152xui32> loc(#loc906)
%9572 = mhlo.add %9563, %9571 : tensor<2097152xui32> loc(#loc908)
%9573 = mhlo.constant dense<15> : tensor<ui32> loc(#loc907)
%9574 = "mhlo.broadcast_in_dim"(%9573) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9575 = mhlo.shift_left %9571, %9574 : tensor<2097152xui32> loc(#loc909)
%9576 = mhlo.constant dense<17> : tensor<ui32> loc(#loc907)
%9577 = "mhlo.broadcast_in_dim"(%9576) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9578 = mhlo.shift_right_logical %9571, %9577 : tensor<2097152xui32> loc(#loc910)
%9579 = mhlo.or %9575, %9578 : tensor<2097152xui32> loc(#loc911)
%9580 = mhlo.xor %9572, %9579 : tensor<2097152xui32> loc(#loc906)
%9581 = mhlo.add %9572, %9580 : tensor<2097152xui32> loc(#loc908)
%9582 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9583 = "mhlo.broadcast_in_dim"(%9582) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9584 = mhlo.shift_left %9580, %9583 : tensor<2097152xui32> loc(#loc909)
%9585 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9586 = "mhlo.broadcast_in_dim"(%9585) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9587 = mhlo.shift_right_logical %9580, %9586 : tensor<2097152xui32> loc(#loc910)
%9588 = mhlo.or %9584, %9587 : tensor<2097152xui32> loc(#loc911)
%9589 = mhlo.xor %9581, %9588 : tensor<2097152xui32> loc(#loc906)
%9590 = mhlo.add %9581, %9589 : tensor<2097152xui32> loc(#loc908)
%9591 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9592 = "mhlo.broadcast_in_dim"(%9591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9593 = mhlo.shift_left %9589, %9592 : tensor<2097152xui32> loc(#loc909)
%9594 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9595 = "mhlo.broadcast_in_dim"(%9594) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9596 = mhlo.shift_right_logical %9589, %9595 : tensor<2097152xui32> loc(#loc910)
%9597 = mhlo.or %9593, %9596 : tensor<2097152xui32> loc(#loc911)
%9598 = mhlo.xor %9590, %9597 : tensor<2097152xui32> loc(#loc906)
%9599 = "mhlo.broadcast_in_dim"(%9553) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9600 = mhlo.add %9590, %9599 : tensor<2097152xui32> loc(#loc908)
%9601 = "mhlo.broadcast_in_dim"(%9558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9602 = mhlo.add %9598, %9601 : tensor<2097152xui32> loc(#loc908)
%9603 = mhlo.constant dense<1> : tensor<ui32> loc(#loc907)
%9604 = "mhlo.broadcast_in_dim"(%9603) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9605 = mhlo.add %9602, %9604 : tensor<2097152xui32> loc(#loc908)
%9606 = mhlo.add %9600, %9605 : tensor<2097152xui32> loc(#loc908)
%9607 = mhlo.constant dense<17> : tensor<ui32> loc(#loc907)
%9608 = "mhlo.broadcast_in_dim"(%9607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9609 = mhlo.shift_left %9605, %9608 : tensor<2097152xui32> loc(#loc909)
%9610 = mhlo.constant dense<15> : tensor<ui32> loc(#loc907)
%9611 = "mhlo.broadcast_in_dim"(%9610) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9612 = mhlo.shift_right_logical %9605, %9611 : tensor<2097152xui32> loc(#loc910)
%9613 = mhlo.or %9609, %9612 : tensor<2097152xui32> loc(#loc911)
%9614 = mhlo.xor %9606, %9613 : tensor<2097152xui32> loc(#loc906)
%9615 = mhlo.add %9606, %9614 : tensor<2097152xui32> loc(#loc908)
%9616 = mhlo.constant dense<29> : tensor<ui32> loc(#loc907)
%9617 = "mhlo.broadcast_in_dim"(%9616) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9618 = mhlo.shift_left %9614, %9617 : tensor<2097152xui32> loc(#loc909)
%9619 = mhlo.constant dense<3> : tensor<ui32> loc(#loc907)
%9620 = "mhlo.broadcast_in_dim"(%9619) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9621 = mhlo.shift_right_logical %9614, %9620 : tensor<2097152xui32> loc(#loc910)
%9622 = mhlo.or %9618, %9621 : tensor<2097152xui32> loc(#loc911)
%9623 = mhlo.xor %9615, %9622 : tensor<2097152xui32> loc(#loc906)
%9624 = mhlo.add %9615, %9623 : tensor<2097152xui32> loc(#loc908)
%9625 = mhlo.constant dense<16> : tensor<ui32> loc(#loc907)
%9626 = "mhlo.broadcast_in_dim"(%9625) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9627 = mhlo.shift_left %9623, %9626 : tensor<2097152xui32> loc(#loc909)
%9628 = mhlo.constant dense<16> : tensor<ui32> loc(#loc907)
%9629 = "mhlo.broadcast_in_dim"(%9628) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9630 = mhlo.shift_right_logical %9623, %9629 : tensor<2097152xui32> loc(#loc910)
%9631 = mhlo.or %9627, %9630 : tensor<2097152xui32> loc(#loc911)
%9632 = mhlo.xor %9624, %9631 : tensor<2097152xui32> loc(#loc906)
%9633 = mhlo.add %9624, %9632 : tensor<2097152xui32> loc(#loc908)
%9634 = mhlo.constant dense<24> : tensor<ui32> loc(#loc907)
%9635 = "mhlo.broadcast_in_dim"(%9634) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9636 = mhlo.shift_left %9632, %9635 : tensor<2097152xui32> loc(#loc909)
%9637 = mhlo.constant dense<8> : tensor<ui32> loc(#loc907)
%9638 = "mhlo.broadcast_in_dim"(%9637) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9639 = mhlo.shift_right_logical %9632, %9638 : tensor<2097152xui32> loc(#loc910)
%9640 = mhlo.or %9636, %9639 : tensor<2097152xui32> loc(#loc911)
%9641 = mhlo.xor %9633, %9640 : tensor<2097152xui32> loc(#loc906)
%9642 = "mhlo.broadcast_in_dim"(%9558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9643 = mhlo.add %9633, %9642 : tensor<2097152xui32> loc(#loc908)
%9644 = "mhlo.broadcast_in_dim"(%9551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9645 = mhlo.add %9641, %9644 : tensor<2097152xui32> loc(#loc908)
%9646 = mhlo.constant dense<2> : tensor<ui32> loc(#loc907)
%9647 = "mhlo.broadcast_in_dim"(%9646) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9648 = mhlo.add %9645, %9647 : tensor<2097152xui32> loc(#loc908)
%9649 = mhlo.add %9643, %9648 : tensor<2097152xui32> loc(#loc908)
%9650 = mhlo.constant dense<13> : tensor<ui32> loc(#loc907)
%9651 = "mhlo.broadcast_in_dim"(%9650) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9652 = mhlo.shift_left %9648, %9651 : tensor<2097152xui32> loc(#loc909)
%9653 = mhlo.constant dense<19> : tensor<ui32> loc(#loc907)
%9654 = "mhlo.broadcast_in_dim"(%9653) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9655 = mhlo.shift_right_logical %9648, %9654 : tensor<2097152xui32> loc(#loc910)
%9656 = mhlo.or %9652, %9655 : tensor<2097152xui32> loc(#loc911)
%9657 = mhlo.xor %9649, %9656 : tensor<2097152xui32> loc(#loc906)
%9658 = mhlo.add %9649, %9657 : tensor<2097152xui32> loc(#loc908)
%9659 = mhlo.constant dense<15> : tensor<ui32> loc(#loc907)
%9660 = "mhlo.broadcast_in_dim"(%9659) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9661 = mhlo.shift_left %9657, %9660 : tensor<2097152xui32> loc(#loc909)
%9662 = mhlo.constant dense<17> : tensor<ui32> loc(#loc907)
%9663 = "mhlo.broadcast_in_dim"(%9662) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9664 = mhlo.shift_right_logical %9657, %9663 : tensor<2097152xui32> loc(#loc910)
%9665 = mhlo.or %9661, %9664 : tensor<2097152xui32> loc(#loc911)
%9666 = mhlo.xor %9658, %9665 : tensor<2097152xui32> loc(#loc906)
%9667 = mhlo.add %9658, %9666 : tensor<2097152xui32> loc(#loc908)
%9668 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9669 = "mhlo.broadcast_in_dim"(%9668) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9670 = mhlo.shift_left %9666, %9669 : tensor<2097152xui32> loc(#loc909)
%9671 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9672 = "mhlo.broadcast_in_dim"(%9671) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9673 = mhlo.shift_right_logical %9666, %9672 : tensor<2097152xui32> loc(#loc910)
%9674 = mhlo.or %9670, %9673 : tensor<2097152xui32> loc(#loc911)
%9675 = mhlo.xor %9667, %9674 : tensor<2097152xui32> loc(#loc906)
%9676 = mhlo.add %9667, %9675 : tensor<2097152xui32> loc(#loc908)
%9677 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9678 = "mhlo.broadcast_in_dim"(%9677) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9679 = mhlo.shift_left %9675, %9678 : tensor<2097152xui32> loc(#loc909)
%9680 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9681 = "mhlo.broadcast_in_dim"(%9680) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9682 = mhlo.shift_right_logical %9675, %9681 : tensor<2097152xui32> loc(#loc910)
%9683 = mhlo.or %9679, %9682 : tensor<2097152xui32> loc(#loc911)
%9684 = mhlo.xor %9676, %9683 : tensor<2097152xui32> loc(#loc906)
%9685 = "mhlo.broadcast_in_dim"(%9551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9686 = mhlo.add %9676, %9685 : tensor<2097152xui32> loc(#loc908)
%9687 = "mhlo.broadcast_in_dim"(%9553) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9688 = mhlo.add %9684, %9687 : tensor<2097152xui32> loc(#loc908)
%9689 = mhlo.constant dense<3> : tensor<ui32> loc(#loc907)
%9690 = "mhlo.broadcast_in_dim"(%9689) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9691 = mhlo.add %9688, %9690 : tensor<2097152xui32> loc(#loc908)
%9692 = mhlo.add %9686, %9691 : tensor<2097152xui32> loc(#loc908)
%9693 = mhlo.constant dense<17> : tensor<ui32> loc(#loc907)
%9694 = "mhlo.broadcast_in_dim"(%9693) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9695 = mhlo.shift_left %9691, %9694 : tensor<2097152xui32> loc(#loc909)
%9696 = mhlo.constant dense<15> : tensor<ui32> loc(#loc907)
%9697 = "mhlo.broadcast_in_dim"(%9696) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9698 = mhlo.shift_right_logical %9691, %9697 : tensor<2097152xui32> loc(#loc910)
%9699 = mhlo.or %9695, %9698 : tensor<2097152xui32> loc(#loc911)
%9700 = mhlo.xor %9692, %9699 : tensor<2097152xui32> loc(#loc906)
%9701 = mhlo.add %9692, %9700 : tensor<2097152xui32> loc(#loc908)
%9702 = mhlo.constant dense<29> : tensor<ui32> loc(#loc907)
%9703 = "mhlo.broadcast_in_dim"(%9702) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9704 = mhlo.shift_left %9700, %9703 : tensor<2097152xui32> loc(#loc909)
%9705 = mhlo.constant dense<3> : tensor<ui32> loc(#loc907)
%9706 = "mhlo.broadcast_in_dim"(%9705) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9707 = mhlo.shift_right_logical %9700, %9706 : tensor<2097152xui32> loc(#loc910)
%9708 = mhlo.or %9704, %9707 : tensor<2097152xui32> loc(#loc911)
%9709 = mhlo.xor %9701, %9708 : tensor<2097152xui32> loc(#loc906)
%9710 = mhlo.add %9701, %9709 : tensor<2097152xui32> loc(#loc908)
%9711 = mhlo.constant dense<16> : tensor<ui32> loc(#loc907)
%9712 = "mhlo.broadcast_in_dim"(%9711) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9713 = mhlo.shift_left %9709, %9712 : tensor<2097152xui32> loc(#loc909)
%9714 = mhlo.constant dense<16> : tensor<ui32> loc(#loc907)
%9715 = "mhlo.broadcast_in_dim"(%9714) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9716 = mhlo.shift_right_logical %9709, %9715 : tensor<2097152xui32> loc(#loc910)
%9717 = mhlo.or %9713, %9716 : tensor<2097152xui32> loc(#loc911)
%9718 = mhlo.xor %9710, %9717 : tensor<2097152xui32> loc(#loc906)
%9719 = mhlo.add %9710, %9718 : tensor<2097152xui32> loc(#loc908)
%9720 = mhlo.constant dense<24> : tensor<ui32> loc(#loc907)
%9721 = "mhlo.broadcast_in_dim"(%9720) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9722 = mhlo.shift_left %9718, %9721 : tensor<2097152xui32> loc(#loc909)
%9723 = mhlo.constant dense<8> : tensor<ui32> loc(#loc907)
%9724 = "mhlo.broadcast_in_dim"(%9723) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9725 = mhlo.shift_right_logical %9718, %9724 : tensor<2097152xui32> loc(#loc910)
%9726 = mhlo.or %9722, %9725 : tensor<2097152xui32> loc(#loc911)
%9727 = mhlo.xor %9719, %9726 : tensor<2097152xui32> loc(#loc906)
%9728 = "mhlo.broadcast_in_dim"(%9553) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9729 = mhlo.add %9719, %9728 : tensor<2097152xui32> loc(#loc908)
%9730 = "mhlo.broadcast_in_dim"(%9558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9731 = mhlo.add %9727, %9730 : tensor<2097152xui32> loc(#loc908)
%9732 = mhlo.constant dense<4> : tensor<ui32> loc(#loc907)
%9733 = "mhlo.broadcast_in_dim"(%9732) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9734 = mhlo.add %9731, %9733 : tensor<2097152xui32> loc(#loc908)
%9735 = mhlo.add %9729, %9734 : tensor<2097152xui32> loc(#loc908)
%9736 = mhlo.constant dense<13> : tensor<ui32> loc(#loc907)
%9737 = "mhlo.broadcast_in_dim"(%9736) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9738 = mhlo.shift_left %9734, %9737 : tensor<2097152xui32> loc(#loc909)
%9739 = mhlo.constant dense<19> : tensor<ui32> loc(#loc907)
%9740 = "mhlo.broadcast_in_dim"(%9739) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9741 = mhlo.shift_right_logical %9734, %9740 : tensor<2097152xui32> loc(#loc910)
%9742 = mhlo.or %9738, %9741 : tensor<2097152xui32> loc(#loc911)
%9743 = mhlo.xor %9735, %9742 : tensor<2097152xui32> loc(#loc906)
%9744 = mhlo.add %9735, %9743 : tensor<2097152xui32> loc(#loc908)
%9745 = mhlo.constant dense<15> : tensor<ui32> loc(#loc907)
%9746 = "mhlo.broadcast_in_dim"(%9745) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9747 = mhlo.shift_left %9743, %9746 : tensor<2097152xui32> loc(#loc909)
%9748 = mhlo.constant dense<17> : tensor<ui32> loc(#loc907)
%9749 = "mhlo.broadcast_in_dim"(%9748) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9750 = mhlo.shift_right_logical %9743, %9749 : tensor<2097152xui32> loc(#loc910)
%9751 = mhlo.or %9747, %9750 : tensor<2097152xui32> loc(#loc911)
%9752 = mhlo.xor %9744, %9751 : tensor<2097152xui32> loc(#loc906)
%9753 = mhlo.add %9744, %9752 : tensor<2097152xui32> loc(#loc908)
%9754 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9755 = "mhlo.broadcast_in_dim"(%9754) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9756 = mhlo.shift_left %9752, %9755 : tensor<2097152xui32> loc(#loc909)
%9757 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9758 = "mhlo.broadcast_in_dim"(%9757) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9759 = mhlo.shift_right_logical %9752, %9758 : tensor<2097152xui32> loc(#loc910)
%9760 = mhlo.or %9756, %9759 : tensor<2097152xui32> loc(#loc911)
%9761 = mhlo.xor %9753, %9760 : tensor<2097152xui32> loc(#loc906)
%9762 = mhlo.add %9753, %9761 : tensor<2097152xui32> loc(#loc908)
%9763 = mhlo.constant dense<6> : tensor<ui32> loc(#loc907)
%9764 = "mhlo.broadcast_in_dim"(%9763) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc909)
%9765 = mhlo.shift_left %9761, %9764 : tensor<2097152xui32> loc(#loc909)
%9766 = mhlo.constant dense<26> : tensor<ui32> loc(#loc907)
%9767 = "mhlo.broadcast_in_dim"(%9766) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc910)
%9768 = mhlo.shift_right_logical %9761, %9767 : tensor<2097152xui32> loc(#loc910)
%9769 = mhlo.or %9765, %9768 : tensor<2097152xui32> loc(#loc911)
%9770 = mhlo.xor %9762, %9769 : tensor<2097152xui32> loc(#loc906)
%9771 = "mhlo.broadcast_in_dim"(%9558) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9772 = mhlo.add %9762, %9771 : tensor<2097152xui32> loc(#loc908)
%9773 = "mhlo.broadcast_in_dim"(%9551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9774 = mhlo.add %9770, %9773 : tensor<2097152xui32> loc(#loc908)
%9775 = mhlo.constant dense<5> : tensor<ui32> loc(#loc907)
%9776 = "mhlo.broadcast_in_dim"(%9775) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc908)
%9777 = mhlo.add %9774, %9776 : tensor<2097152xui32> loc(#loc908)
%9778 = "mhlo.concatenate"(%9772, %9777) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc912)
%9779 = "mhlo.reshape"(%9778) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc913)
%9780 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%9781 = "mhlo.broadcast_in_dim"(%9780) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc910)
%9782 = mhlo.shift_right_logical %9779, %9781 : tensor<2048x2048xui32> loc(#loc910)
%9783 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%9784 = "mhlo.broadcast_in_dim"(%9783) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc911)
%9785 = mhlo.or %9782, %9784 : tensor<2048x2048xui32> loc(#loc911)
%9786 = "mhlo.bitcast_convert"(%9785) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc914)
%9787 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%9788 = "mhlo.broadcast_in_dim"(%9787) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc915)
%9789 = mhlo.subtract %9786, %9788 : tensor<2048x2048xf32> loc(#loc915)
%9790 = mhlo.subtract %9548, %9546 : tensor<1x1xf32> loc(#loc915)
%9791 = "mhlo.broadcast_in_dim"(%9790) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc916)
%9792 = mhlo.multiply %9789, %9791 : tensor<2048x2048xf32> loc(#loc916)
%9793 = "mhlo.broadcast_in_dim"(%9546) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc908)
%9794 = mhlo.add %9792, %9793 : tensor<2048x2048xf32> loc(#loc908)
%9795 = "mhlo.broadcast_in_dim"(%9546) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc917)
%9796 = mhlo.maximum %9795, %9794 : tensor<2048x2048xf32> loc(#loc917)
%9797 = func.call @erf_inv_22(%9796) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc918)
%9798 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%9799 = "mhlo.broadcast_in_dim"(%9798) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc916)
%9800 = mhlo.multiply %9797, %9799 : tensor<2048x2048xf32> loc(#loc916)
%9801 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%9802 = "mhlo.broadcast_in_dim"(%9801) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc916)
%9803 = mhlo.multiply %9800, %9802 : tensor<2048x2048xf32> loc(#loc916)
%9804 = mhlo.convert(%9803) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc919)
%9805 = "mhlo.dot_general"(%iterArg_1, %9804) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x64x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x64x2048xf16> loc(#loc920)
%9806 = "mhlo.reshape"(%8809) : (tensor<1x256x2048xf16>) -> tensor<1x256x32x64xf16> loc(#loc921)
%9807 = "mhlo.reshape"(%9307) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc922)
%9808 = "mhlo.reshape"(%9805) : (tensor<1x64x2048xf16>) -> tensor<1x64x32x64xf16> loc(#loc922)
%9809 = mhlo.constant dense<6.400000e+01> : tensor<f32> loc(#loc531)
%9810 = mhlo.sqrt %9809 : tensor<f32> loc(#loc923)
%9811 = mhlo.convert(%9810) : (tensor<f32>) -> tensor<f16> loc(#loc924)
%9812 = "mhlo.broadcast_in_dim"(%9811) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x32x64xf16> loc(#loc925)
%9813 = mhlo.divide %9806, %9812 : tensor<1x256x32x64xf16> loc(#loc925)
%9814 = func.call @_einsum_25(%9813, %9807) : (tensor<1x256x32x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x32x256x64xf16> loc(#loc926)
%9815 = mhlo.constant dense<0xFC00> : tensor<f16> loc(#loc927)
%9816 = mhlo.reduce(%9814 init: %9815) across dimensions = [3] : (tensor<1x32x256x64xf16>, tensor<f16>) -> tensor<1x32x256xf16>
reducer(%arg47: tensor<f16> loc(unknown), %arg48: tensor<f16> loc(unknown)) {
%13358 = mhlo.maximum %arg47, %arg48 : tensor<f16> loc(#loc927)
"mhlo.return"(%13358) : (tensor<f16>) -> () loc(#loc927)
} loc(#loc927)
%9817 = "mhlo.broadcast_in_dim"(%9816) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x256xf16>) -> tensor<1x32x256x1xf16> loc(#loc928)
%9818 = "mhlo.broadcast_in_dim"(%9817) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x256x1xf16>) -> tensor<1x32x256x64xf16> loc(#loc929)
%9819 = mhlo.subtract %9814, %9818 : tensor<1x32x256x64xf16> loc(#loc929)
%9820 = mhlo.exponential %9819 : tensor<1x32x256x64xf16> loc(#loc930)
%9821 = mhlo.convert(%9820) : (tensor<1x32x256x64xf16>) -> tensor<1x32x256x64xf32> loc(#loc931)
%9822 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc932)
%9823 = mhlo.reduce(%9821 init: %9822) across dimensions = [3] : (tensor<1x32x256x64xf32>, tensor<f32>) -> tensor<1x32x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc932)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc932)
} loc(#loc932)
%9824 = "mhlo.broadcast_in_dim"(%9823) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x32x256xf32>) -> tensor<1x32x256x1xf32> loc(#loc928)
%9825 = mhlo.convert(%9824) : (tensor<1x32x256x1xf32>) -> tensor<1x32x256x1xf16> loc(#loc933)
%9826 = "mhlo.broadcast_in_dim"(%9825) {broadcast_dimensions = dense<[0, 1, 2, 3]> : tensor<4xi64>} : (tensor<1x32x256x1xf16>) -> tensor<1x32x256x64xf16> loc(#loc934)
%9827 = mhlo.divide %9820, %9826 : tensor<1x32x256x64xf16> loc(#loc934)
%9828 = func.call @_einsum_26(%9827, %9808) : (tensor<1x32x256x64xf16>, tensor<1x64x32x64xf16>) -> tensor<1x256x32x64xf16> loc(#loc935)
%9829 = "mhlo.reshape"(%9828) : (tensor<1x256x32x64xf16>) -> tensor<1x256x2048xf16> loc(#loc936)
%9830 = mhlo.constant dense<1063172292> : tensor<ui32> loc(#loc531)
%9831 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%9832 = mhlo.shift_right_logical %9830, %9831 : tensor<ui32> loc(#loc937)
%9833 = "mhlo.reshape"(%9832) : (tensor<ui32>) -> tensor<1xui32> loc(#loc938)
%9834 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%9835 = mhlo.and %9830, %9834 : tensor<ui32> loc(#loc939)
%9836 = "mhlo.reshape"(%9835) : (tensor<ui32>) -> tensor<1xui32> loc(#loc938)
%9837 = "mhlo.concatenate"(%9833, %9836) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc940)
%9838 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc941)
%9839 = "mhlo.reshape"(%9838) : (tensor<1xui32>) -> tensor<ui32> loc(#loc942)
%9840 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc943)
%9841 = "mhlo.reshape"(%9840) : (tensor<1xui32>) -> tensor<ui32> loc(#loc942)
%9842 = "mhlo.slice"(%9837) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc944)
%9843 = "mhlo.slice"(%9837) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc945)
%9844 = mhlo.xor %9839, %9841 : tensor<ui32> loc(#loc946)
%9845 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc947)
%9846 = mhlo.xor %9844, %9845 : tensor<ui32> loc(#loc946)
%9847 = "mhlo.broadcast_in_dim"(%9839) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9848 = mhlo.add %9842, %9847 : tensor<1xui32> loc(#loc948)
%9849 = "mhlo.broadcast_in_dim"(%9841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9850 = mhlo.add %9843, %9849 : tensor<1xui32> loc(#loc948)
%9851 = mhlo.add %9848, %9850 : tensor<1xui32> loc(#loc948)
%9852 = mhlo.constant dense<13> : tensor<ui32> loc(#loc947)
%9853 = "mhlo.broadcast_in_dim"(%9852) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9854 = mhlo.shift_left %9850, %9853 : tensor<1xui32> loc(#loc949)
%9855 = mhlo.constant dense<19> : tensor<ui32> loc(#loc947)
%9856 = "mhlo.broadcast_in_dim"(%9855) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9857 = mhlo.shift_right_logical %9850, %9856 : tensor<1xui32> loc(#loc937)
%9858 = mhlo.or %9854, %9857 : tensor<1xui32> loc(#loc950)
%9859 = mhlo.xor %9851, %9858 : tensor<1xui32> loc(#loc946)
%9860 = mhlo.add %9851, %9859 : tensor<1xui32> loc(#loc948)
%9861 = mhlo.constant dense<15> : tensor<ui32> loc(#loc947)
%9862 = "mhlo.broadcast_in_dim"(%9861) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9863 = mhlo.shift_left %9859, %9862 : tensor<1xui32> loc(#loc949)
%9864 = mhlo.constant dense<17> : tensor<ui32> loc(#loc947)
%9865 = "mhlo.broadcast_in_dim"(%9864) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9866 = mhlo.shift_right_logical %9859, %9865 : tensor<1xui32> loc(#loc937)
%9867 = mhlo.or %9863, %9866 : tensor<1xui32> loc(#loc950)
%9868 = mhlo.xor %9860, %9867 : tensor<1xui32> loc(#loc946)
%9869 = mhlo.add %9860, %9868 : tensor<1xui32> loc(#loc948)
%9870 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%9871 = "mhlo.broadcast_in_dim"(%9870) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9872 = mhlo.shift_left %9868, %9871 : tensor<1xui32> loc(#loc949)
%9873 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%9874 = "mhlo.broadcast_in_dim"(%9873) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9875 = mhlo.shift_right_logical %9868, %9874 : tensor<1xui32> loc(#loc937)
%9876 = mhlo.or %9872, %9875 : tensor<1xui32> loc(#loc950)
%9877 = mhlo.xor %9869, %9876 : tensor<1xui32> loc(#loc946)
%9878 = mhlo.add %9869, %9877 : tensor<1xui32> loc(#loc948)
%9879 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%9880 = "mhlo.broadcast_in_dim"(%9879) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9881 = mhlo.shift_left %9877, %9880 : tensor<1xui32> loc(#loc949)
%9882 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%9883 = "mhlo.broadcast_in_dim"(%9882) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9884 = mhlo.shift_right_logical %9877, %9883 : tensor<1xui32> loc(#loc937)
%9885 = mhlo.or %9881, %9884 : tensor<1xui32> loc(#loc950)
%9886 = mhlo.xor %9878, %9885 : tensor<1xui32> loc(#loc946)
%9887 = "mhlo.broadcast_in_dim"(%9841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9888 = mhlo.add %9878, %9887 : tensor<1xui32> loc(#loc948)
%9889 = "mhlo.broadcast_in_dim"(%9846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9890 = mhlo.add %9886, %9889 : tensor<1xui32> loc(#loc948)
%9891 = mhlo.constant dense<1> : tensor<ui32> loc(#loc947)
%9892 = "mhlo.broadcast_in_dim"(%9891) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9893 = mhlo.add %9890, %9892 : tensor<1xui32> loc(#loc948)
%9894 = mhlo.add %9888, %9893 : tensor<1xui32> loc(#loc948)
%9895 = mhlo.constant dense<17> : tensor<ui32> loc(#loc947)
%9896 = "mhlo.broadcast_in_dim"(%9895) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9897 = mhlo.shift_left %9893, %9896 : tensor<1xui32> loc(#loc949)
%9898 = mhlo.constant dense<15> : tensor<ui32> loc(#loc947)
%9899 = "mhlo.broadcast_in_dim"(%9898) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9900 = mhlo.shift_right_logical %9893, %9899 : tensor<1xui32> loc(#loc937)
%9901 = mhlo.or %9897, %9900 : tensor<1xui32> loc(#loc950)
%9902 = mhlo.xor %9894, %9901 : tensor<1xui32> loc(#loc946)
%9903 = mhlo.add %9894, %9902 : tensor<1xui32> loc(#loc948)
%9904 = mhlo.constant dense<29> : tensor<ui32> loc(#loc947)
%9905 = "mhlo.broadcast_in_dim"(%9904) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9906 = mhlo.shift_left %9902, %9905 : tensor<1xui32> loc(#loc949)
%9907 = mhlo.constant dense<3> : tensor<ui32> loc(#loc947)
%9908 = "mhlo.broadcast_in_dim"(%9907) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9909 = mhlo.shift_right_logical %9902, %9908 : tensor<1xui32> loc(#loc937)
%9910 = mhlo.or %9906, %9909 : tensor<1xui32> loc(#loc950)
%9911 = mhlo.xor %9903, %9910 : tensor<1xui32> loc(#loc946)
%9912 = mhlo.add %9903, %9911 : tensor<1xui32> loc(#loc948)
%9913 = mhlo.constant dense<16> : tensor<ui32> loc(#loc947)
%9914 = "mhlo.broadcast_in_dim"(%9913) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9915 = mhlo.shift_left %9911, %9914 : tensor<1xui32> loc(#loc949)
%9916 = mhlo.constant dense<16> : tensor<ui32> loc(#loc947)
%9917 = "mhlo.broadcast_in_dim"(%9916) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9918 = mhlo.shift_right_logical %9911, %9917 : tensor<1xui32> loc(#loc937)
%9919 = mhlo.or %9915, %9918 : tensor<1xui32> loc(#loc950)
%9920 = mhlo.xor %9912, %9919 : tensor<1xui32> loc(#loc946)
%9921 = mhlo.add %9912, %9920 : tensor<1xui32> loc(#loc948)
%9922 = mhlo.constant dense<24> : tensor<ui32> loc(#loc947)
%9923 = "mhlo.broadcast_in_dim"(%9922) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9924 = mhlo.shift_left %9920, %9923 : tensor<1xui32> loc(#loc949)
%9925 = mhlo.constant dense<8> : tensor<ui32> loc(#loc947)
%9926 = "mhlo.broadcast_in_dim"(%9925) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9927 = mhlo.shift_right_logical %9920, %9926 : tensor<1xui32> loc(#loc937)
%9928 = mhlo.or %9924, %9927 : tensor<1xui32> loc(#loc950)
%9929 = mhlo.xor %9921, %9928 : tensor<1xui32> loc(#loc946)
%9930 = "mhlo.broadcast_in_dim"(%9846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9931 = mhlo.add %9921, %9930 : tensor<1xui32> loc(#loc948)
%9932 = "mhlo.broadcast_in_dim"(%9839) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9933 = mhlo.add %9929, %9932 : tensor<1xui32> loc(#loc948)
%9934 = mhlo.constant dense<2> : tensor<ui32> loc(#loc947)
%9935 = "mhlo.broadcast_in_dim"(%9934) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9936 = mhlo.add %9933, %9935 : tensor<1xui32> loc(#loc948)
%9937 = mhlo.add %9931, %9936 : tensor<1xui32> loc(#loc948)
%9938 = mhlo.constant dense<13> : tensor<ui32> loc(#loc947)
%9939 = "mhlo.broadcast_in_dim"(%9938) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9940 = mhlo.shift_left %9936, %9939 : tensor<1xui32> loc(#loc949)
%9941 = mhlo.constant dense<19> : tensor<ui32> loc(#loc947)
%9942 = "mhlo.broadcast_in_dim"(%9941) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9943 = mhlo.shift_right_logical %9936, %9942 : tensor<1xui32> loc(#loc937)
%9944 = mhlo.or %9940, %9943 : tensor<1xui32> loc(#loc950)
%9945 = mhlo.xor %9937, %9944 : tensor<1xui32> loc(#loc946)
%9946 = mhlo.add %9937, %9945 : tensor<1xui32> loc(#loc948)
%9947 = mhlo.constant dense<15> : tensor<ui32> loc(#loc947)
%9948 = "mhlo.broadcast_in_dim"(%9947) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9949 = mhlo.shift_left %9945, %9948 : tensor<1xui32> loc(#loc949)
%9950 = mhlo.constant dense<17> : tensor<ui32> loc(#loc947)
%9951 = "mhlo.broadcast_in_dim"(%9950) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9952 = mhlo.shift_right_logical %9945, %9951 : tensor<1xui32> loc(#loc937)
%9953 = mhlo.or %9949, %9952 : tensor<1xui32> loc(#loc950)
%9954 = mhlo.xor %9946, %9953 : tensor<1xui32> loc(#loc946)
%9955 = mhlo.add %9946, %9954 : tensor<1xui32> loc(#loc948)
%9956 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%9957 = "mhlo.broadcast_in_dim"(%9956) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9958 = mhlo.shift_left %9954, %9957 : tensor<1xui32> loc(#loc949)
%9959 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%9960 = "mhlo.broadcast_in_dim"(%9959) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9961 = mhlo.shift_right_logical %9954, %9960 : tensor<1xui32> loc(#loc937)
%9962 = mhlo.or %9958, %9961 : tensor<1xui32> loc(#loc950)
%9963 = mhlo.xor %9955, %9962 : tensor<1xui32> loc(#loc946)
%9964 = mhlo.add %9955, %9963 : tensor<1xui32> loc(#loc948)
%9965 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%9966 = "mhlo.broadcast_in_dim"(%9965) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9967 = mhlo.shift_left %9963, %9966 : tensor<1xui32> loc(#loc949)
%9968 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%9969 = "mhlo.broadcast_in_dim"(%9968) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9970 = mhlo.shift_right_logical %9963, %9969 : tensor<1xui32> loc(#loc937)
%9971 = mhlo.or %9967, %9970 : tensor<1xui32> loc(#loc950)
%9972 = mhlo.xor %9964, %9971 : tensor<1xui32> loc(#loc946)
%9973 = "mhlo.broadcast_in_dim"(%9839) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9974 = mhlo.add %9964, %9973 : tensor<1xui32> loc(#loc948)
%9975 = "mhlo.broadcast_in_dim"(%9841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9976 = mhlo.add %9972, %9975 : tensor<1xui32> loc(#loc948)
%9977 = mhlo.constant dense<3> : tensor<ui32> loc(#loc947)
%9978 = "mhlo.broadcast_in_dim"(%9977) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%9979 = mhlo.add %9976, %9978 : tensor<1xui32> loc(#loc948)
%9980 = mhlo.add %9974, %9979 : tensor<1xui32> loc(#loc948)
%9981 = mhlo.constant dense<17> : tensor<ui32> loc(#loc947)
%9982 = "mhlo.broadcast_in_dim"(%9981) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9983 = mhlo.shift_left %9979, %9982 : tensor<1xui32> loc(#loc949)
%9984 = mhlo.constant dense<15> : tensor<ui32> loc(#loc947)
%9985 = "mhlo.broadcast_in_dim"(%9984) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9986 = mhlo.shift_right_logical %9979, %9985 : tensor<1xui32> loc(#loc937)
%9987 = mhlo.or %9983, %9986 : tensor<1xui32> loc(#loc950)
%9988 = mhlo.xor %9980, %9987 : tensor<1xui32> loc(#loc946)
%9989 = mhlo.add %9980, %9988 : tensor<1xui32> loc(#loc948)
%9990 = mhlo.constant dense<29> : tensor<ui32> loc(#loc947)
%9991 = "mhlo.broadcast_in_dim"(%9990) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%9992 = mhlo.shift_left %9988, %9991 : tensor<1xui32> loc(#loc949)
%9993 = mhlo.constant dense<3> : tensor<ui32> loc(#loc947)
%9994 = "mhlo.broadcast_in_dim"(%9993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%9995 = mhlo.shift_right_logical %9988, %9994 : tensor<1xui32> loc(#loc937)
%9996 = mhlo.or %9992, %9995 : tensor<1xui32> loc(#loc950)
%9997 = mhlo.xor %9989, %9996 : tensor<1xui32> loc(#loc946)
%9998 = mhlo.add %9989, %9997 : tensor<1xui32> loc(#loc948)
%9999 = mhlo.constant dense<16> : tensor<ui32> loc(#loc947)
%10000 = "mhlo.broadcast_in_dim"(%9999) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10001 = mhlo.shift_left %9997, %10000 : tensor<1xui32> loc(#loc949)
%10002 = mhlo.constant dense<16> : tensor<ui32> loc(#loc947)
%10003 = "mhlo.broadcast_in_dim"(%10002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10004 = mhlo.shift_right_logical %9997, %10003 : tensor<1xui32> loc(#loc937)
%10005 = mhlo.or %10001, %10004 : tensor<1xui32> loc(#loc950)
%10006 = mhlo.xor %9998, %10005 : tensor<1xui32> loc(#loc946)
%10007 = mhlo.add %9998, %10006 : tensor<1xui32> loc(#loc948)
%10008 = mhlo.constant dense<24> : tensor<ui32> loc(#loc947)
%10009 = "mhlo.broadcast_in_dim"(%10008) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10010 = mhlo.shift_left %10006, %10009 : tensor<1xui32> loc(#loc949)
%10011 = mhlo.constant dense<8> : tensor<ui32> loc(#loc947)
%10012 = "mhlo.broadcast_in_dim"(%10011) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10013 = mhlo.shift_right_logical %10006, %10012 : tensor<1xui32> loc(#loc937)
%10014 = mhlo.or %10010, %10013 : tensor<1xui32> loc(#loc950)
%10015 = mhlo.xor %10007, %10014 : tensor<1xui32> loc(#loc946)
%10016 = "mhlo.broadcast_in_dim"(%9841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10017 = mhlo.add %10007, %10016 : tensor<1xui32> loc(#loc948)
%10018 = "mhlo.broadcast_in_dim"(%9846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10019 = mhlo.add %10015, %10018 : tensor<1xui32> loc(#loc948)
%10020 = mhlo.constant dense<4> : tensor<ui32> loc(#loc947)
%10021 = "mhlo.broadcast_in_dim"(%10020) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10022 = mhlo.add %10019, %10021 : tensor<1xui32> loc(#loc948)
%10023 = mhlo.add %10017, %10022 : tensor<1xui32> loc(#loc948)
%10024 = mhlo.constant dense<13> : tensor<ui32> loc(#loc947)
%10025 = "mhlo.broadcast_in_dim"(%10024) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10026 = mhlo.shift_left %10022, %10025 : tensor<1xui32> loc(#loc949)
%10027 = mhlo.constant dense<19> : tensor<ui32> loc(#loc947)
%10028 = "mhlo.broadcast_in_dim"(%10027) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10029 = mhlo.shift_right_logical %10022, %10028 : tensor<1xui32> loc(#loc937)
%10030 = mhlo.or %10026, %10029 : tensor<1xui32> loc(#loc950)
%10031 = mhlo.xor %10023, %10030 : tensor<1xui32> loc(#loc946)
%10032 = mhlo.add %10023, %10031 : tensor<1xui32> loc(#loc948)
%10033 = mhlo.constant dense<15> : tensor<ui32> loc(#loc947)
%10034 = "mhlo.broadcast_in_dim"(%10033) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10035 = mhlo.shift_left %10031, %10034 : tensor<1xui32> loc(#loc949)
%10036 = mhlo.constant dense<17> : tensor<ui32> loc(#loc947)
%10037 = "mhlo.broadcast_in_dim"(%10036) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10038 = mhlo.shift_right_logical %10031, %10037 : tensor<1xui32> loc(#loc937)
%10039 = mhlo.or %10035, %10038 : tensor<1xui32> loc(#loc950)
%10040 = mhlo.xor %10032, %10039 : tensor<1xui32> loc(#loc946)
%10041 = mhlo.add %10032, %10040 : tensor<1xui32> loc(#loc948)
%10042 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%10043 = "mhlo.broadcast_in_dim"(%10042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10044 = mhlo.shift_left %10040, %10043 : tensor<1xui32> loc(#loc949)
%10045 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%10046 = "mhlo.broadcast_in_dim"(%10045) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10047 = mhlo.shift_right_logical %10040, %10046 : tensor<1xui32> loc(#loc937)
%10048 = mhlo.or %10044, %10047 : tensor<1xui32> loc(#loc950)
%10049 = mhlo.xor %10041, %10048 : tensor<1xui32> loc(#loc946)
%10050 = mhlo.add %10041, %10049 : tensor<1xui32> loc(#loc948)
%10051 = mhlo.constant dense<6> : tensor<ui32> loc(#loc947)
%10052 = "mhlo.broadcast_in_dim"(%10051) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc949)
%10053 = mhlo.shift_left %10049, %10052 : tensor<1xui32> loc(#loc949)
%10054 = mhlo.constant dense<26> : tensor<ui32> loc(#loc947)
%10055 = "mhlo.broadcast_in_dim"(%10054) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc937)
%10056 = mhlo.shift_right_logical %10049, %10055 : tensor<1xui32> loc(#loc937)
%10057 = mhlo.or %10053, %10056 : tensor<1xui32> loc(#loc950)
%10058 = mhlo.xor %10050, %10057 : tensor<1xui32> loc(#loc946)
%10059 = "mhlo.broadcast_in_dim"(%9846) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10060 = mhlo.add %10050, %10059 : tensor<1xui32> loc(#loc948)
%10061 = "mhlo.broadcast_in_dim"(%9839) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10062 = mhlo.add %10058, %10061 : tensor<1xui32> loc(#loc948)
%10063 = mhlo.constant dense<5> : tensor<ui32> loc(#loc947)
%10064 = "mhlo.broadcast_in_dim"(%10063) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc948)
%10065 = mhlo.add %10062, %10064 : tensor<1xui32> loc(#loc948)
%10066 = "mhlo.concatenate"(%10060, %10065) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc940)
%10067 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%10068 = "mhlo.broadcast_in_dim"(%10067) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc951)
%10069 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%10070 = "mhlo.broadcast_in_dim"(%10069) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc951)
%10071 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<4194304xui32> loc(#loc952)
%10072 = "mhlo.slice"(%10066) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc953)
%10073 = "mhlo.reshape"(%10072) : (tensor<1xui32>) -> tensor<ui32> loc(#loc954)
%10074 = "mhlo.slice"(%10066) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc955)
%10075 = "mhlo.reshape"(%10074) : (tensor<1xui32>) -> tensor<ui32> loc(#loc954)
%10076 = "mhlo.slice"(%10071) {limit_indices = dense<2097152> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc956)
%10077 = "mhlo.slice"(%10071) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<2097152> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<4194304xui32>) -> tensor<2097152xui32> loc(#loc957)
%10078 = mhlo.xor %10073, %10075 : tensor<ui32> loc(#loc958)
%10079 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc959)
%10080 = mhlo.xor %10078, %10079 : tensor<ui32> loc(#loc958)
%10081 = "mhlo.broadcast_in_dim"(%10073) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10082 = mhlo.add %10076, %10081 : tensor<2097152xui32> loc(#loc960)
%10083 = "mhlo.broadcast_in_dim"(%10075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10084 = mhlo.add %10077, %10083 : tensor<2097152xui32> loc(#loc960)
%10085 = mhlo.add %10082, %10084 : tensor<2097152xui32> loc(#loc960)
%10086 = mhlo.constant dense<13> : tensor<ui32> loc(#loc959)
%10087 = "mhlo.broadcast_in_dim"(%10086) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10088 = mhlo.shift_left %10084, %10087 : tensor<2097152xui32> loc(#loc961)
%10089 = mhlo.constant dense<19> : tensor<ui32> loc(#loc959)
%10090 = "mhlo.broadcast_in_dim"(%10089) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10091 = mhlo.shift_right_logical %10084, %10090 : tensor<2097152xui32> loc(#loc962)
%10092 = mhlo.or %10088, %10091 : tensor<2097152xui32> loc(#loc963)
%10093 = mhlo.xor %10085, %10092 : tensor<2097152xui32> loc(#loc958)
%10094 = mhlo.add %10085, %10093 : tensor<2097152xui32> loc(#loc960)
%10095 = mhlo.constant dense<15> : tensor<ui32> loc(#loc959)
%10096 = "mhlo.broadcast_in_dim"(%10095) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10097 = mhlo.shift_left %10093, %10096 : tensor<2097152xui32> loc(#loc961)
%10098 = mhlo.constant dense<17> : tensor<ui32> loc(#loc959)
%10099 = "mhlo.broadcast_in_dim"(%10098) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10100 = mhlo.shift_right_logical %10093, %10099 : tensor<2097152xui32> loc(#loc962)
%10101 = mhlo.or %10097, %10100 : tensor<2097152xui32> loc(#loc963)
%10102 = mhlo.xor %10094, %10101 : tensor<2097152xui32> loc(#loc958)
%10103 = mhlo.add %10094, %10102 : tensor<2097152xui32> loc(#loc960)
%10104 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10105 = "mhlo.broadcast_in_dim"(%10104) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10106 = mhlo.shift_left %10102, %10105 : tensor<2097152xui32> loc(#loc961)
%10107 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10108 = "mhlo.broadcast_in_dim"(%10107) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10109 = mhlo.shift_right_logical %10102, %10108 : tensor<2097152xui32> loc(#loc962)
%10110 = mhlo.or %10106, %10109 : tensor<2097152xui32> loc(#loc963)
%10111 = mhlo.xor %10103, %10110 : tensor<2097152xui32> loc(#loc958)
%10112 = mhlo.add %10103, %10111 : tensor<2097152xui32> loc(#loc960)
%10113 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10114 = "mhlo.broadcast_in_dim"(%10113) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10115 = mhlo.shift_left %10111, %10114 : tensor<2097152xui32> loc(#loc961)
%10116 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10117 = "mhlo.broadcast_in_dim"(%10116) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10118 = mhlo.shift_right_logical %10111, %10117 : tensor<2097152xui32> loc(#loc962)
%10119 = mhlo.or %10115, %10118 : tensor<2097152xui32> loc(#loc963)
%10120 = mhlo.xor %10112, %10119 : tensor<2097152xui32> loc(#loc958)
%10121 = "mhlo.broadcast_in_dim"(%10075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10122 = mhlo.add %10112, %10121 : tensor<2097152xui32> loc(#loc960)
%10123 = "mhlo.broadcast_in_dim"(%10080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10124 = mhlo.add %10120, %10123 : tensor<2097152xui32> loc(#loc960)
%10125 = mhlo.constant dense<1> : tensor<ui32> loc(#loc959)
%10126 = "mhlo.broadcast_in_dim"(%10125) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10127 = mhlo.add %10124, %10126 : tensor<2097152xui32> loc(#loc960)
%10128 = mhlo.add %10122, %10127 : tensor<2097152xui32> loc(#loc960)
%10129 = mhlo.constant dense<17> : tensor<ui32> loc(#loc959)
%10130 = "mhlo.broadcast_in_dim"(%10129) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10131 = mhlo.shift_left %10127, %10130 : tensor<2097152xui32> loc(#loc961)
%10132 = mhlo.constant dense<15> : tensor<ui32> loc(#loc959)
%10133 = "mhlo.broadcast_in_dim"(%10132) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10134 = mhlo.shift_right_logical %10127, %10133 : tensor<2097152xui32> loc(#loc962)
%10135 = mhlo.or %10131, %10134 : tensor<2097152xui32> loc(#loc963)
%10136 = mhlo.xor %10128, %10135 : tensor<2097152xui32> loc(#loc958)
%10137 = mhlo.add %10128, %10136 : tensor<2097152xui32> loc(#loc960)
%10138 = mhlo.constant dense<29> : tensor<ui32> loc(#loc959)
%10139 = "mhlo.broadcast_in_dim"(%10138) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10140 = mhlo.shift_left %10136, %10139 : tensor<2097152xui32> loc(#loc961)
%10141 = mhlo.constant dense<3> : tensor<ui32> loc(#loc959)
%10142 = "mhlo.broadcast_in_dim"(%10141) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10143 = mhlo.shift_right_logical %10136, %10142 : tensor<2097152xui32> loc(#loc962)
%10144 = mhlo.or %10140, %10143 : tensor<2097152xui32> loc(#loc963)
%10145 = mhlo.xor %10137, %10144 : tensor<2097152xui32> loc(#loc958)
%10146 = mhlo.add %10137, %10145 : tensor<2097152xui32> loc(#loc960)
%10147 = mhlo.constant dense<16> : tensor<ui32> loc(#loc959)
%10148 = "mhlo.broadcast_in_dim"(%10147) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10149 = mhlo.shift_left %10145, %10148 : tensor<2097152xui32> loc(#loc961)
%10150 = mhlo.constant dense<16> : tensor<ui32> loc(#loc959)
%10151 = "mhlo.broadcast_in_dim"(%10150) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10152 = mhlo.shift_right_logical %10145, %10151 : tensor<2097152xui32> loc(#loc962)
%10153 = mhlo.or %10149, %10152 : tensor<2097152xui32> loc(#loc963)
%10154 = mhlo.xor %10146, %10153 : tensor<2097152xui32> loc(#loc958)
%10155 = mhlo.add %10146, %10154 : tensor<2097152xui32> loc(#loc960)
%10156 = mhlo.constant dense<24> : tensor<ui32> loc(#loc959)
%10157 = "mhlo.broadcast_in_dim"(%10156) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10158 = mhlo.shift_left %10154, %10157 : tensor<2097152xui32> loc(#loc961)
%10159 = mhlo.constant dense<8> : tensor<ui32> loc(#loc959)
%10160 = "mhlo.broadcast_in_dim"(%10159) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10161 = mhlo.shift_right_logical %10154, %10160 : tensor<2097152xui32> loc(#loc962)
%10162 = mhlo.or %10158, %10161 : tensor<2097152xui32> loc(#loc963)
%10163 = mhlo.xor %10155, %10162 : tensor<2097152xui32> loc(#loc958)
%10164 = "mhlo.broadcast_in_dim"(%10080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10165 = mhlo.add %10155, %10164 : tensor<2097152xui32> loc(#loc960)
%10166 = "mhlo.broadcast_in_dim"(%10073) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10167 = mhlo.add %10163, %10166 : tensor<2097152xui32> loc(#loc960)
%10168 = mhlo.constant dense<2> : tensor<ui32> loc(#loc959)
%10169 = "mhlo.broadcast_in_dim"(%10168) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10170 = mhlo.add %10167, %10169 : tensor<2097152xui32> loc(#loc960)
%10171 = mhlo.add %10165, %10170 : tensor<2097152xui32> loc(#loc960)
%10172 = mhlo.constant dense<13> : tensor<ui32> loc(#loc959)
%10173 = "mhlo.broadcast_in_dim"(%10172) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10174 = mhlo.shift_left %10170, %10173 : tensor<2097152xui32> loc(#loc961)
%10175 = mhlo.constant dense<19> : tensor<ui32> loc(#loc959)
%10176 = "mhlo.broadcast_in_dim"(%10175) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10177 = mhlo.shift_right_logical %10170, %10176 : tensor<2097152xui32> loc(#loc962)
%10178 = mhlo.or %10174, %10177 : tensor<2097152xui32> loc(#loc963)
%10179 = mhlo.xor %10171, %10178 : tensor<2097152xui32> loc(#loc958)
%10180 = mhlo.add %10171, %10179 : tensor<2097152xui32> loc(#loc960)
%10181 = mhlo.constant dense<15> : tensor<ui32> loc(#loc959)
%10182 = "mhlo.broadcast_in_dim"(%10181) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10183 = mhlo.shift_left %10179, %10182 : tensor<2097152xui32> loc(#loc961)
%10184 = mhlo.constant dense<17> : tensor<ui32> loc(#loc959)
%10185 = "mhlo.broadcast_in_dim"(%10184) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10186 = mhlo.shift_right_logical %10179, %10185 : tensor<2097152xui32> loc(#loc962)
%10187 = mhlo.or %10183, %10186 : tensor<2097152xui32> loc(#loc963)
%10188 = mhlo.xor %10180, %10187 : tensor<2097152xui32> loc(#loc958)
%10189 = mhlo.add %10180, %10188 : tensor<2097152xui32> loc(#loc960)
%10190 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10191 = "mhlo.broadcast_in_dim"(%10190) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10192 = mhlo.shift_left %10188, %10191 : tensor<2097152xui32> loc(#loc961)
%10193 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10194 = "mhlo.broadcast_in_dim"(%10193) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10195 = mhlo.shift_right_logical %10188, %10194 : tensor<2097152xui32> loc(#loc962)
%10196 = mhlo.or %10192, %10195 : tensor<2097152xui32> loc(#loc963)
%10197 = mhlo.xor %10189, %10196 : tensor<2097152xui32> loc(#loc958)
%10198 = mhlo.add %10189, %10197 : tensor<2097152xui32> loc(#loc960)
%10199 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10200 = "mhlo.broadcast_in_dim"(%10199) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10201 = mhlo.shift_left %10197, %10200 : tensor<2097152xui32> loc(#loc961)
%10202 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10203 = "mhlo.broadcast_in_dim"(%10202) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10204 = mhlo.shift_right_logical %10197, %10203 : tensor<2097152xui32> loc(#loc962)
%10205 = mhlo.or %10201, %10204 : tensor<2097152xui32> loc(#loc963)
%10206 = mhlo.xor %10198, %10205 : tensor<2097152xui32> loc(#loc958)
%10207 = "mhlo.broadcast_in_dim"(%10073) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10208 = mhlo.add %10198, %10207 : tensor<2097152xui32> loc(#loc960)
%10209 = "mhlo.broadcast_in_dim"(%10075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10210 = mhlo.add %10206, %10209 : tensor<2097152xui32> loc(#loc960)
%10211 = mhlo.constant dense<3> : tensor<ui32> loc(#loc959)
%10212 = "mhlo.broadcast_in_dim"(%10211) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10213 = mhlo.add %10210, %10212 : tensor<2097152xui32> loc(#loc960)
%10214 = mhlo.add %10208, %10213 : tensor<2097152xui32> loc(#loc960)
%10215 = mhlo.constant dense<17> : tensor<ui32> loc(#loc959)
%10216 = "mhlo.broadcast_in_dim"(%10215) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10217 = mhlo.shift_left %10213, %10216 : tensor<2097152xui32> loc(#loc961)
%10218 = mhlo.constant dense<15> : tensor<ui32> loc(#loc959)
%10219 = "mhlo.broadcast_in_dim"(%10218) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10220 = mhlo.shift_right_logical %10213, %10219 : tensor<2097152xui32> loc(#loc962)
%10221 = mhlo.or %10217, %10220 : tensor<2097152xui32> loc(#loc963)
%10222 = mhlo.xor %10214, %10221 : tensor<2097152xui32> loc(#loc958)
%10223 = mhlo.add %10214, %10222 : tensor<2097152xui32> loc(#loc960)
%10224 = mhlo.constant dense<29> : tensor<ui32> loc(#loc959)
%10225 = "mhlo.broadcast_in_dim"(%10224) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10226 = mhlo.shift_left %10222, %10225 : tensor<2097152xui32> loc(#loc961)
%10227 = mhlo.constant dense<3> : tensor<ui32> loc(#loc959)
%10228 = "mhlo.broadcast_in_dim"(%10227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10229 = mhlo.shift_right_logical %10222, %10228 : tensor<2097152xui32> loc(#loc962)
%10230 = mhlo.or %10226, %10229 : tensor<2097152xui32> loc(#loc963)
%10231 = mhlo.xor %10223, %10230 : tensor<2097152xui32> loc(#loc958)
%10232 = mhlo.add %10223, %10231 : tensor<2097152xui32> loc(#loc960)
%10233 = mhlo.constant dense<16> : tensor<ui32> loc(#loc959)
%10234 = "mhlo.broadcast_in_dim"(%10233) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10235 = mhlo.shift_left %10231, %10234 : tensor<2097152xui32> loc(#loc961)
%10236 = mhlo.constant dense<16> : tensor<ui32> loc(#loc959)
%10237 = "mhlo.broadcast_in_dim"(%10236) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10238 = mhlo.shift_right_logical %10231, %10237 : tensor<2097152xui32> loc(#loc962)
%10239 = mhlo.or %10235, %10238 : tensor<2097152xui32> loc(#loc963)
%10240 = mhlo.xor %10232, %10239 : tensor<2097152xui32> loc(#loc958)
%10241 = mhlo.add %10232, %10240 : tensor<2097152xui32> loc(#loc960)
%10242 = mhlo.constant dense<24> : tensor<ui32> loc(#loc959)
%10243 = "mhlo.broadcast_in_dim"(%10242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10244 = mhlo.shift_left %10240, %10243 : tensor<2097152xui32> loc(#loc961)
%10245 = mhlo.constant dense<8> : tensor<ui32> loc(#loc959)
%10246 = "mhlo.broadcast_in_dim"(%10245) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10247 = mhlo.shift_right_logical %10240, %10246 : tensor<2097152xui32> loc(#loc962)
%10248 = mhlo.or %10244, %10247 : tensor<2097152xui32> loc(#loc963)
%10249 = mhlo.xor %10241, %10248 : tensor<2097152xui32> loc(#loc958)
%10250 = "mhlo.broadcast_in_dim"(%10075) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10251 = mhlo.add %10241, %10250 : tensor<2097152xui32> loc(#loc960)
%10252 = "mhlo.broadcast_in_dim"(%10080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10253 = mhlo.add %10249, %10252 : tensor<2097152xui32> loc(#loc960)
%10254 = mhlo.constant dense<4> : tensor<ui32> loc(#loc959)
%10255 = "mhlo.broadcast_in_dim"(%10254) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10256 = mhlo.add %10253, %10255 : tensor<2097152xui32> loc(#loc960)
%10257 = mhlo.add %10251, %10256 : tensor<2097152xui32> loc(#loc960)
%10258 = mhlo.constant dense<13> : tensor<ui32> loc(#loc959)
%10259 = "mhlo.broadcast_in_dim"(%10258) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10260 = mhlo.shift_left %10256, %10259 : tensor<2097152xui32> loc(#loc961)
%10261 = mhlo.constant dense<19> : tensor<ui32> loc(#loc959)
%10262 = "mhlo.broadcast_in_dim"(%10261) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10263 = mhlo.shift_right_logical %10256, %10262 : tensor<2097152xui32> loc(#loc962)
%10264 = mhlo.or %10260, %10263 : tensor<2097152xui32> loc(#loc963)
%10265 = mhlo.xor %10257, %10264 : tensor<2097152xui32> loc(#loc958)
%10266 = mhlo.add %10257, %10265 : tensor<2097152xui32> loc(#loc960)
%10267 = mhlo.constant dense<15> : tensor<ui32> loc(#loc959)
%10268 = "mhlo.broadcast_in_dim"(%10267) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10269 = mhlo.shift_left %10265, %10268 : tensor<2097152xui32> loc(#loc961)
%10270 = mhlo.constant dense<17> : tensor<ui32> loc(#loc959)
%10271 = "mhlo.broadcast_in_dim"(%10270) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10272 = mhlo.shift_right_logical %10265, %10271 : tensor<2097152xui32> loc(#loc962)
%10273 = mhlo.or %10269, %10272 : tensor<2097152xui32> loc(#loc963)
%10274 = mhlo.xor %10266, %10273 : tensor<2097152xui32> loc(#loc958)
%10275 = mhlo.add %10266, %10274 : tensor<2097152xui32> loc(#loc960)
%10276 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10277 = "mhlo.broadcast_in_dim"(%10276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10278 = mhlo.shift_left %10274, %10277 : tensor<2097152xui32> loc(#loc961)
%10279 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10280 = "mhlo.broadcast_in_dim"(%10279) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10281 = mhlo.shift_right_logical %10274, %10280 : tensor<2097152xui32> loc(#loc962)
%10282 = mhlo.or %10278, %10281 : tensor<2097152xui32> loc(#loc963)
%10283 = mhlo.xor %10275, %10282 : tensor<2097152xui32> loc(#loc958)
%10284 = mhlo.add %10275, %10283 : tensor<2097152xui32> loc(#loc960)
%10285 = mhlo.constant dense<6> : tensor<ui32> loc(#loc959)
%10286 = "mhlo.broadcast_in_dim"(%10285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc961)
%10287 = mhlo.shift_left %10283, %10286 : tensor<2097152xui32> loc(#loc961)
%10288 = mhlo.constant dense<26> : tensor<ui32> loc(#loc959)
%10289 = "mhlo.broadcast_in_dim"(%10288) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc962)
%10290 = mhlo.shift_right_logical %10283, %10289 : tensor<2097152xui32> loc(#loc962)
%10291 = mhlo.or %10287, %10290 : tensor<2097152xui32> loc(#loc963)
%10292 = mhlo.xor %10284, %10291 : tensor<2097152xui32> loc(#loc958)
%10293 = "mhlo.broadcast_in_dim"(%10080) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10294 = mhlo.add %10284, %10293 : tensor<2097152xui32> loc(#loc960)
%10295 = "mhlo.broadcast_in_dim"(%10073) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10296 = mhlo.add %10292, %10295 : tensor<2097152xui32> loc(#loc960)
%10297 = mhlo.constant dense<5> : tensor<ui32> loc(#loc959)
%10298 = "mhlo.broadcast_in_dim"(%10297) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2097152xui32> loc(#loc960)
%10299 = mhlo.add %10296, %10298 : tensor<2097152xui32> loc(#loc960)
%10300 = "mhlo.concatenate"(%10294, %10299) {dimension = 0 : i64} : (tensor<2097152xui32>, tensor<2097152xui32>) -> tensor<4194304xui32> loc(#loc964)
%10301 = "mhlo.reshape"(%10300) : (tensor<4194304xui32>) -> tensor<2048x2048xui32> loc(#loc965)
%10302 = mhlo.constant dense<9> : tensor<ui32> loc(#loc531)
%10303 = "mhlo.broadcast_in_dim"(%10302) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc962)
%10304 = mhlo.shift_right_logical %10301, %10303 : tensor<2048x2048xui32> loc(#loc962)
%10305 = mhlo.constant dense<1065353216> : tensor<ui32> loc(#loc531)
%10306 = "mhlo.broadcast_in_dim"(%10305) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<2048x2048xui32> loc(#loc963)
%10307 = mhlo.or %10304, %10306 : tensor<2048x2048xui32> loc(#loc963)
%10308 = "mhlo.bitcast_convert"(%10307) : (tensor<2048x2048xui32>) -> tensor<2048x2048xf32> loc(#loc966)
%10309 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%10310 = "mhlo.broadcast_in_dim"(%10309) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc967)
%10311 = mhlo.subtract %10308, %10310 : tensor<2048x2048xf32> loc(#loc967)
%10312 = mhlo.subtract %10070, %10068 : tensor<1x1xf32> loc(#loc967)
%10313 = "mhlo.broadcast_in_dim"(%10312) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc968)
%10314 = mhlo.multiply %10311, %10313 : tensor<2048x2048xf32> loc(#loc968)
%10315 = "mhlo.broadcast_in_dim"(%10068) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc960)
%10316 = mhlo.add %10314, %10315 : tensor<2048x2048xf32> loc(#loc960)
%10317 = "mhlo.broadcast_in_dim"(%10068) {broadcast_dimensions = dense<[0, 1]> : tensor<2xi64>} : (tensor<1x1xf32>) -> tensor<2048x2048xf32> loc(#loc969)
%10318 = mhlo.maximum %10317, %10316 : tensor<2048x2048xf32> loc(#loc969)
%10319 = func.call @erf_inv_22(%10318) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf32> loc(#loc970)
%10320 = mhlo.constant dense<1.41421354> : tensor<f32> loc(#loc531)
%10321 = "mhlo.broadcast_in_dim"(%10320) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc968)
%10322 = mhlo.multiply %10319, %10321 : tensor<2048x2048xf32> loc(#loc968)
%10323 = mhlo.constant dense<0.00999999977> : tensor<f32> loc(#loc531)
%10324 = "mhlo.broadcast_in_dim"(%10323) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048x2048xf32> loc(#loc968)
%10325 = mhlo.multiply %10322, %10324 : tensor<2048x2048xf32> loc(#loc968)
%10326 = mhlo.convert(%10325) : (tensor<2048x2048xf32>) -> tensor<2048x2048xf16> loc(#loc971)
%10327 = "mhlo.dot_general"(%9829, %10326) {dot_dimension_numbers = #mhlo.dot<lhs_contracting_dimensions = [2], rhs_contracting_dimensions = [0]>, precision_config = [#mhlo<"precision DEFAULT">, #mhlo<"precision DEFAULT">]} : (tensor<1x256x2048xf16>, tensor<2048x2048xf16>) -> tensor<1x256x2048xf16> loc(#loc972)
%10328 = mhlo.convert(%10327) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc973)
%10329 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc974)
%10330 = mhlo.reduce(%10328 init: %10329) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc974)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc974)
} loc(#loc974)
%10331 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%10332 = "mhlo.broadcast_in_dim"(%10331) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc975)
%10333 = mhlo.divide %10330, %10332 : tensor<1x256xf32> loc(#loc975)
%10334 = mhlo.multiply %10328, %10328 : tensor<1x256x2048xf32> loc(#loc976)
%10335 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc977)
%10336 = mhlo.reduce(%10334 init: %10335) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc977)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc977)
} loc(#loc977)
%10337 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%10338 = "mhlo.broadcast_in_dim"(%10337) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc978)
%10339 = mhlo.divide %10336, %10338 : tensor<1x256xf32> loc(#loc978)
%10340 = mhlo.multiply %10333, %10333 : tensor<1x256xf32> loc(#loc976)
%10341 = mhlo.subtract %10339, %10340 : tensor<1x256xf32> loc(#loc979)
%10342 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%10343 = "mhlo.broadcast_in_dim"(%10342) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc980)
%10344 = mhlo.maximum %10343, %10341 : tensor<1x256xf32> loc(#loc980)
%10345 = "mhlo.reshape"(%10333) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc981)
%10346 = "mhlo.reshape"(%10344) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc982)
%10347 = mhlo.convert(%10327) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc983)
%10348 = "mhlo.broadcast_in_dim"(%10345) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc984)
%10349 = mhlo.subtract %10347, %10348 : tensor<1x256x2048xf32> loc(#loc984)
%10350 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc531)
%10351 = "mhlo.broadcast_in_dim"(%10350) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc985)
%10352 = mhlo.add %10346, %10351 : tensor<1x256x1xf32> loc(#loc985)
%10353 = mhlo.rsqrt %10352 : tensor<1x256x1xf32> loc(#loc986)
%10354 = mhlo.constant dense<764051246> : tensor<ui32> loc(#loc531)
%10355 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%10356 = mhlo.shift_right_logical %10354, %10355 : tensor<ui32> loc(#loc987)
%10357 = "mhlo.reshape"(%10356) : (tensor<ui32>) -> tensor<1xui32> loc(#loc988)
%10358 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%10359 = mhlo.and %10354, %10358 : tensor<ui32> loc(#loc989)
%10360 = "mhlo.reshape"(%10359) : (tensor<ui32>) -> tensor<1xui32> loc(#loc988)
%10361 = "mhlo.concatenate"(%10357, %10360) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc990)
%10362 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc991)
%10363 = "mhlo.reshape"(%10362) : (tensor<1xui32>) -> tensor<ui32> loc(#loc992)
%10364 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc993)
%10365 = "mhlo.reshape"(%10364) : (tensor<1xui32>) -> tensor<ui32> loc(#loc992)
%10366 = "mhlo.slice"(%10361) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc994)
%10367 = "mhlo.slice"(%10361) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc995)
%10368 = mhlo.xor %10363, %10365 : tensor<ui32> loc(#loc996)
%10369 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc997)
%10370 = mhlo.xor %10368, %10369 : tensor<ui32> loc(#loc996)
%10371 = "mhlo.broadcast_in_dim"(%10363) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10372 = mhlo.add %10366, %10371 : tensor<1xui32> loc(#loc998)
%10373 = "mhlo.broadcast_in_dim"(%10365) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10374 = mhlo.add %10367, %10373 : tensor<1xui32> loc(#loc998)
%10375 = mhlo.add %10372, %10374 : tensor<1xui32> loc(#loc998)
%10376 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10377 = "mhlo.broadcast_in_dim"(%10376) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10378 = mhlo.shift_left %10374, %10377 : tensor<1xui32> loc(#loc999)
%10379 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10380 = "mhlo.broadcast_in_dim"(%10379) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10381 = mhlo.shift_right_logical %10374, %10380 : tensor<1xui32> loc(#loc987)
%10382 = mhlo.or %10378, %10381 : tensor<1xui32> loc(#loc1000)
%10383 = mhlo.xor %10375, %10382 : tensor<1xui32> loc(#loc996)
%10384 = mhlo.add %10375, %10383 : tensor<1xui32> loc(#loc998)
%10385 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10386 = "mhlo.broadcast_in_dim"(%10385) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10387 = mhlo.shift_left %10383, %10386 : tensor<1xui32> loc(#loc999)
%10388 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10389 = "mhlo.broadcast_in_dim"(%10388) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10390 = mhlo.shift_right_logical %10383, %10389 : tensor<1xui32> loc(#loc987)
%10391 = mhlo.or %10387, %10390 : tensor<1xui32> loc(#loc1000)
%10392 = mhlo.xor %10384, %10391 : tensor<1xui32> loc(#loc996)
%10393 = mhlo.add %10384, %10392 : tensor<1xui32> loc(#loc998)
%10394 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10395 = "mhlo.broadcast_in_dim"(%10394) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10396 = mhlo.shift_left %10392, %10395 : tensor<1xui32> loc(#loc999)
%10397 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10398 = "mhlo.broadcast_in_dim"(%10397) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10399 = mhlo.shift_right_logical %10392, %10398 : tensor<1xui32> loc(#loc987)
%10400 = mhlo.or %10396, %10399 : tensor<1xui32> loc(#loc1000)
%10401 = mhlo.xor %10393, %10400 : tensor<1xui32> loc(#loc996)
%10402 = mhlo.add %10393, %10401 : tensor<1xui32> loc(#loc998)
%10403 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10404 = "mhlo.broadcast_in_dim"(%10403) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10405 = mhlo.shift_left %10401, %10404 : tensor<1xui32> loc(#loc999)
%10406 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10407 = "mhlo.broadcast_in_dim"(%10406) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10408 = mhlo.shift_right_logical %10401, %10407 : tensor<1xui32> loc(#loc987)
%10409 = mhlo.or %10405, %10408 : tensor<1xui32> loc(#loc1000)
%10410 = mhlo.xor %10402, %10409 : tensor<1xui32> loc(#loc996)
%10411 = "mhlo.broadcast_in_dim"(%10365) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10412 = mhlo.add %10402, %10411 : tensor<1xui32> loc(#loc998)
%10413 = "mhlo.broadcast_in_dim"(%10370) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10414 = mhlo.add %10410, %10413 : tensor<1xui32> loc(#loc998)
%10415 = mhlo.constant dense<1> : tensor<ui32> loc(#loc997)
%10416 = "mhlo.broadcast_in_dim"(%10415) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10417 = mhlo.add %10414, %10416 : tensor<1xui32> loc(#loc998)
%10418 = mhlo.add %10412, %10417 : tensor<1xui32> loc(#loc998)
%10419 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10420 = "mhlo.broadcast_in_dim"(%10419) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10421 = mhlo.shift_left %10417, %10420 : tensor<1xui32> loc(#loc999)
%10422 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10423 = "mhlo.broadcast_in_dim"(%10422) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10424 = mhlo.shift_right_logical %10417, %10423 : tensor<1xui32> loc(#loc987)
%10425 = mhlo.or %10421, %10424 : tensor<1xui32> loc(#loc1000)
%10426 = mhlo.xor %10418, %10425 : tensor<1xui32> loc(#loc996)
%10427 = mhlo.add %10418, %10426 : tensor<1xui32> loc(#loc998)
%10428 = mhlo.constant dense<29> : tensor<ui32> loc(#loc997)
%10429 = "mhlo.broadcast_in_dim"(%10428) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10430 = mhlo.shift_left %10426, %10429 : tensor<1xui32> loc(#loc999)
%10431 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10432 = "mhlo.broadcast_in_dim"(%10431) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10433 = mhlo.shift_right_logical %10426, %10432 : tensor<1xui32> loc(#loc987)
%10434 = mhlo.or %10430, %10433 : tensor<1xui32> loc(#loc1000)
%10435 = mhlo.xor %10427, %10434 : tensor<1xui32> loc(#loc996)
%10436 = mhlo.add %10427, %10435 : tensor<1xui32> loc(#loc998)
%10437 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10438 = "mhlo.broadcast_in_dim"(%10437) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10439 = mhlo.shift_left %10435, %10438 : tensor<1xui32> loc(#loc999)
%10440 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10441 = "mhlo.broadcast_in_dim"(%10440) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10442 = mhlo.shift_right_logical %10435, %10441 : tensor<1xui32> loc(#loc987)
%10443 = mhlo.or %10439, %10442 : tensor<1xui32> loc(#loc1000)
%10444 = mhlo.xor %10436, %10443 : tensor<1xui32> loc(#loc996)
%10445 = mhlo.add %10436, %10444 : tensor<1xui32> loc(#loc998)
%10446 = mhlo.constant dense<24> : tensor<ui32> loc(#loc997)
%10447 = "mhlo.broadcast_in_dim"(%10446) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10448 = mhlo.shift_left %10444, %10447 : tensor<1xui32> loc(#loc999)
%10449 = mhlo.constant dense<8> : tensor<ui32> loc(#loc997)
%10450 = "mhlo.broadcast_in_dim"(%10449) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10451 = mhlo.shift_right_logical %10444, %10450 : tensor<1xui32> loc(#loc987)
%10452 = mhlo.or %10448, %10451 : tensor<1xui32> loc(#loc1000)
%10453 = mhlo.xor %10445, %10452 : tensor<1xui32> loc(#loc996)
%10454 = "mhlo.broadcast_in_dim"(%10370) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10455 = mhlo.add %10445, %10454 : tensor<1xui32> loc(#loc998)
%10456 = "mhlo.broadcast_in_dim"(%10363) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10457 = mhlo.add %10453, %10456 : tensor<1xui32> loc(#loc998)
%10458 = mhlo.constant dense<2> : tensor<ui32> loc(#loc997)
%10459 = "mhlo.broadcast_in_dim"(%10458) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10460 = mhlo.add %10457, %10459 : tensor<1xui32> loc(#loc998)
%10461 = mhlo.add %10455, %10460 : tensor<1xui32> loc(#loc998)
%10462 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10463 = "mhlo.broadcast_in_dim"(%10462) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10464 = mhlo.shift_left %10460, %10463 : tensor<1xui32> loc(#loc999)
%10465 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10466 = "mhlo.broadcast_in_dim"(%10465) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10467 = mhlo.shift_right_logical %10460, %10466 : tensor<1xui32> loc(#loc987)
%10468 = mhlo.or %10464, %10467 : tensor<1xui32> loc(#loc1000)
%10469 = mhlo.xor %10461, %10468 : tensor<1xui32> loc(#loc996)
%10470 = mhlo.add %10461, %10469 : tensor<1xui32> loc(#loc998)
%10471 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10472 = "mhlo.broadcast_in_dim"(%10471) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10473 = mhlo.shift_left %10469, %10472 : tensor<1xui32> loc(#loc999)
%10474 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10475 = "mhlo.broadcast_in_dim"(%10474) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10476 = mhlo.shift_right_logical %10469, %10475 : tensor<1xui32> loc(#loc987)
%10477 = mhlo.or %10473, %10476 : tensor<1xui32> loc(#loc1000)
%10478 = mhlo.xor %10470, %10477 : tensor<1xui32> loc(#loc996)
%10479 = mhlo.add %10470, %10478 : tensor<1xui32> loc(#loc998)
%10480 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10481 = "mhlo.broadcast_in_dim"(%10480) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10482 = mhlo.shift_left %10478, %10481 : tensor<1xui32> loc(#loc999)
%10483 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10484 = "mhlo.broadcast_in_dim"(%10483) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10485 = mhlo.shift_right_logical %10478, %10484 : tensor<1xui32> loc(#loc987)
%10486 = mhlo.or %10482, %10485 : tensor<1xui32> loc(#loc1000)
%10487 = mhlo.xor %10479, %10486 : tensor<1xui32> loc(#loc996)
%10488 = mhlo.add %10479, %10487 : tensor<1xui32> loc(#loc998)
%10489 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10490 = "mhlo.broadcast_in_dim"(%10489) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10491 = mhlo.shift_left %10487, %10490 : tensor<1xui32> loc(#loc999)
%10492 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10493 = "mhlo.broadcast_in_dim"(%10492) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10494 = mhlo.shift_right_logical %10487, %10493 : tensor<1xui32> loc(#loc987)
%10495 = mhlo.or %10491, %10494 : tensor<1xui32> loc(#loc1000)
%10496 = mhlo.xor %10488, %10495 : tensor<1xui32> loc(#loc996)
%10497 = "mhlo.broadcast_in_dim"(%10363) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10498 = mhlo.add %10488, %10497 : tensor<1xui32> loc(#loc998)
%10499 = "mhlo.broadcast_in_dim"(%10365) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10500 = mhlo.add %10496, %10499 : tensor<1xui32> loc(#loc998)
%10501 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10502 = "mhlo.broadcast_in_dim"(%10501) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10503 = mhlo.add %10500, %10502 : tensor<1xui32> loc(#loc998)
%10504 = mhlo.add %10498, %10503 : tensor<1xui32> loc(#loc998)
%10505 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10506 = "mhlo.broadcast_in_dim"(%10505) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10507 = mhlo.shift_left %10503, %10506 : tensor<1xui32> loc(#loc999)
%10508 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10509 = "mhlo.broadcast_in_dim"(%10508) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10510 = mhlo.shift_right_logical %10503, %10509 : tensor<1xui32> loc(#loc987)
%10511 = mhlo.or %10507, %10510 : tensor<1xui32> loc(#loc1000)
%10512 = mhlo.xor %10504, %10511 : tensor<1xui32> loc(#loc996)
%10513 = mhlo.add %10504, %10512 : tensor<1xui32> loc(#loc998)
%10514 = mhlo.constant dense<29> : tensor<ui32> loc(#loc997)
%10515 = "mhlo.broadcast_in_dim"(%10514) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10516 = mhlo.shift_left %10512, %10515 : tensor<1xui32> loc(#loc999)
%10517 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10518 = "mhlo.broadcast_in_dim"(%10517) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10519 = mhlo.shift_right_logical %10512, %10518 : tensor<1xui32> loc(#loc987)
%10520 = mhlo.or %10516, %10519 : tensor<1xui32> loc(#loc1000)
%10521 = mhlo.xor %10513, %10520 : tensor<1xui32> loc(#loc996)
%10522 = mhlo.add %10513, %10521 : tensor<1xui32> loc(#loc998)
%10523 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10524 = "mhlo.broadcast_in_dim"(%10523) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10525 = mhlo.shift_left %10521, %10524 : tensor<1xui32> loc(#loc999)
%10526 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10527 = "mhlo.broadcast_in_dim"(%10526) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10528 = mhlo.shift_right_logical %10521, %10527 : tensor<1xui32> loc(#loc987)
%10529 = mhlo.or %10525, %10528 : tensor<1xui32> loc(#loc1000)
%10530 = mhlo.xor %10522, %10529 : tensor<1xui32> loc(#loc996)
%10531 = mhlo.add %10522, %10530 : tensor<1xui32> loc(#loc998)
%10532 = mhlo.constant dense<24> : tensor<ui32> loc(#loc997)
%10533 = "mhlo.broadcast_in_dim"(%10532) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10534 = mhlo.shift_left %10530, %10533 : tensor<1xui32> loc(#loc999)
%10535 = mhlo.constant dense<8> : tensor<ui32> loc(#loc997)
%10536 = "mhlo.broadcast_in_dim"(%10535) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10537 = mhlo.shift_right_logical %10530, %10536 : tensor<1xui32> loc(#loc987)
%10538 = mhlo.or %10534, %10537 : tensor<1xui32> loc(#loc1000)
%10539 = mhlo.xor %10531, %10538 : tensor<1xui32> loc(#loc996)
%10540 = "mhlo.broadcast_in_dim"(%10365) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10541 = mhlo.add %10531, %10540 : tensor<1xui32> loc(#loc998)
%10542 = "mhlo.broadcast_in_dim"(%10370) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10543 = mhlo.add %10539, %10542 : tensor<1xui32> loc(#loc998)
%10544 = mhlo.constant dense<4> : tensor<ui32> loc(#loc997)
%10545 = "mhlo.broadcast_in_dim"(%10544) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10546 = mhlo.add %10543, %10545 : tensor<1xui32> loc(#loc998)
%10547 = mhlo.add %10541, %10546 : tensor<1xui32> loc(#loc998)
%10548 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10549 = "mhlo.broadcast_in_dim"(%10548) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10550 = mhlo.shift_left %10546, %10549 : tensor<1xui32> loc(#loc999)
%10551 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10552 = "mhlo.broadcast_in_dim"(%10551) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10553 = mhlo.shift_right_logical %10546, %10552 : tensor<1xui32> loc(#loc987)
%10554 = mhlo.or %10550, %10553 : tensor<1xui32> loc(#loc1000)
%10555 = mhlo.xor %10547, %10554 : tensor<1xui32> loc(#loc996)
%10556 = mhlo.add %10547, %10555 : tensor<1xui32> loc(#loc998)
%10557 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10558 = "mhlo.broadcast_in_dim"(%10557) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10559 = mhlo.shift_left %10555, %10558 : tensor<1xui32> loc(#loc999)
%10560 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10561 = "mhlo.broadcast_in_dim"(%10560) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10562 = mhlo.shift_right_logical %10555, %10561 : tensor<1xui32> loc(#loc987)
%10563 = mhlo.or %10559, %10562 : tensor<1xui32> loc(#loc1000)
%10564 = mhlo.xor %10556, %10563 : tensor<1xui32> loc(#loc996)
%10565 = mhlo.add %10556, %10564 : tensor<1xui32> loc(#loc998)
%10566 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10567 = "mhlo.broadcast_in_dim"(%10566) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10568 = mhlo.shift_left %10564, %10567 : tensor<1xui32> loc(#loc999)
%10569 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10570 = "mhlo.broadcast_in_dim"(%10569) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10571 = mhlo.shift_right_logical %10564, %10570 : tensor<1xui32> loc(#loc987)
%10572 = mhlo.or %10568, %10571 : tensor<1xui32> loc(#loc1000)
%10573 = mhlo.xor %10565, %10572 : tensor<1xui32> loc(#loc996)
%10574 = mhlo.add %10565, %10573 : tensor<1xui32> loc(#loc998)
%10575 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10576 = "mhlo.broadcast_in_dim"(%10575) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10577 = mhlo.shift_left %10573, %10576 : tensor<1xui32> loc(#loc999)
%10578 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10579 = "mhlo.broadcast_in_dim"(%10578) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10580 = mhlo.shift_right_logical %10573, %10579 : tensor<1xui32> loc(#loc987)
%10581 = mhlo.or %10577, %10580 : tensor<1xui32> loc(#loc1000)
%10582 = mhlo.xor %10574, %10581 : tensor<1xui32> loc(#loc996)
%10583 = "mhlo.broadcast_in_dim"(%10370) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10584 = mhlo.add %10574, %10583 : tensor<1xui32> loc(#loc998)
%10585 = "mhlo.broadcast_in_dim"(%10363) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10586 = mhlo.add %10582, %10585 : tensor<1xui32> loc(#loc998)
%10587 = mhlo.constant dense<5> : tensor<ui32> loc(#loc997)
%10588 = "mhlo.broadcast_in_dim"(%10587) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10589 = mhlo.add %10586, %10588 : tensor<1xui32> loc(#loc998)
%10590 = "mhlo.concatenate"(%10584, %10589) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc990)
%10591 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%10592 = "mhlo.broadcast_in_dim"(%10591) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc1001)
%10593 = "mhlo.reshape"(%10592) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc1002)
%10594 = "mhlo.broadcast_in_dim"(%10353) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc1003)
%10595 = "mhlo.broadcast_in_dim"(%10593) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc1003)
%10596 = mhlo.multiply %10594, %10595 : tensor<1x256x2048xf32> loc(#loc1003)
%10597 = mhlo.multiply %10349, %10596 : tensor<1x256x2048xf32> loc(#loc1004)
%10598 = mhlo.constant dense<2730799930> : tensor<ui32> loc(#loc531)
%10599 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%10600 = mhlo.shift_right_logical %10598, %10599 : tensor<ui32> loc(#loc987)
%10601 = "mhlo.reshape"(%10600) : (tensor<ui32>) -> tensor<1xui32> loc(#loc988)
%10602 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%10603 = mhlo.and %10598, %10602 : tensor<ui32> loc(#loc989)
%10604 = "mhlo.reshape"(%10603) : (tensor<ui32>) -> tensor<1xui32> loc(#loc988)
%10605 = "mhlo.concatenate"(%10601, %10604) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc990)
%10606 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc991)
%10607 = "mhlo.reshape"(%10606) : (tensor<1xui32>) -> tensor<ui32> loc(#loc992)
%10608 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc993)
%10609 = "mhlo.reshape"(%10608) : (tensor<1xui32>) -> tensor<ui32> loc(#loc992)
%10610 = "mhlo.slice"(%10605) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc994)
%10611 = "mhlo.slice"(%10605) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc995)
%10612 = mhlo.xor %10607, %10609 : tensor<ui32> loc(#loc996)
%10613 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc997)
%10614 = mhlo.xor %10612, %10613 : tensor<ui32> loc(#loc996)
%10615 = "mhlo.broadcast_in_dim"(%10607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10616 = mhlo.add %10610, %10615 : tensor<1xui32> loc(#loc998)
%10617 = "mhlo.broadcast_in_dim"(%10609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10618 = mhlo.add %10611, %10617 : tensor<1xui32> loc(#loc998)
%10619 = mhlo.add %10616, %10618 : tensor<1xui32> loc(#loc998)
%10620 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10621 = "mhlo.broadcast_in_dim"(%10620) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10622 = mhlo.shift_left %10618, %10621 : tensor<1xui32> loc(#loc999)
%10623 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10624 = "mhlo.broadcast_in_dim"(%10623) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10625 = mhlo.shift_right_logical %10618, %10624 : tensor<1xui32> loc(#loc987)
%10626 = mhlo.or %10622, %10625 : tensor<1xui32> loc(#loc1000)
%10627 = mhlo.xor %10619, %10626 : tensor<1xui32> loc(#loc996)
%10628 = mhlo.add %10619, %10627 : tensor<1xui32> loc(#loc998)
%10629 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10630 = "mhlo.broadcast_in_dim"(%10629) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10631 = mhlo.shift_left %10627, %10630 : tensor<1xui32> loc(#loc999)
%10632 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10633 = "mhlo.broadcast_in_dim"(%10632) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10634 = mhlo.shift_right_logical %10627, %10633 : tensor<1xui32> loc(#loc987)
%10635 = mhlo.or %10631, %10634 : tensor<1xui32> loc(#loc1000)
%10636 = mhlo.xor %10628, %10635 : tensor<1xui32> loc(#loc996)
%10637 = mhlo.add %10628, %10636 : tensor<1xui32> loc(#loc998)
%10638 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10639 = "mhlo.broadcast_in_dim"(%10638) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10640 = mhlo.shift_left %10636, %10639 : tensor<1xui32> loc(#loc999)
%10641 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10642 = "mhlo.broadcast_in_dim"(%10641) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10643 = mhlo.shift_right_logical %10636, %10642 : tensor<1xui32> loc(#loc987)
%10644 = mhlo.or %10640, %10643 : tensor<1xui32> loc(#loc1000)
%10645 = mhlo.xor %10637, %10644 : tensor<1xui32> loc(#loc996)
%10646 = mhlo.add %10637, %10645 : tensor<1xui32> loc(#loc998)
%10647 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10648 = "mhlo.broadcast_in_dim"(%10647) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10649 = mhlo.shift_left %10645, %10648 : tensor<1xui32> loc(#loc999)
%10650 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10651 = "mhlo.broadcast_in_dim"(%10650) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10652 = mhlo.shift_right_logical %10645, %10651 : tensor<1xui32> loc(#loc987)
%10653 = mhlo.or %10649, %10652 : tensor<1xui32> loc(#loc1000)
%10654 = mhlo.xor %10646, %10653 : tensor<1xui32> loc(#loc996)
%10655 = "mhlo.broadcast_in_dim"(%10609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10656 = mhlo.add %10646, %10655 : tensor<1xui32> loc(#loc998)
%10657 = "mhlo.broadcast_in_dim"(%10614) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10658 = mhlo.add %10654, %10657 : tensor<1xui32> loc(#loc998)
%10659 = mhlo.constant dense<1> : tensor<ui32> loc(#loc997)
%10660 = "mhlo.broadcast_in_dim"(%10659) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10661 = mhlo.add %10658, %10660 : tensor<1xui32> loc(#loc998)
%10662 = mhlo.add %10656, %10661 : tensor<1xui32> loc(#loc998)
%10663 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10664 = "mhlo.broadcast_in_dim"(%10663) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10665 = mhlo.shift_left %10661, %10664 : tensor<1xui32> loc(#loc999)
%10666 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10667 = "mhlo.broadcast_in_dim"(%10666) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10668 = mhlo.shift_right_logical %10661, %10667 : tensor<1xui32> loc(#loc987)
%10669 = mhlo.or %10665, %10668 : tensor<1xui32> loc(#loc1000)
%10670 = mhlo.xor %10662, %10669 : tensor<1xui32> loc(#loc996)
%10671 = mhlo.add %10662, %10670 : tensor<1xui32> loc(#loc998)
%10672 = mhlo.constant dense<29> : tensor<ui32> loc(#loc997)
%10673 = "mhlo.broadcast_in_dim"(%10672) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10674 = mhlo.shift_left %10670, %10673 : tensor<1xui32> loc(#loc999)
%10675 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10676 = "mhlo.broadcast_in_dim"(%10675) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10677 = mhlo.shift_right_logical %10670, %10676 : tensor<1xui32> loc(#loc987)
%10678 = mhlo.or %10674, %10677 : tensor<1xui32> loc(#loc1000)
%10679 = mhlo.xor %10671, %10678 : tensor<1xui32> loc(#loc996)
%10680 = mhlo.add %10671, %10679 : tensor<1xui32> loc(#loc998)
%10681 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10682 = "mhlo.broadcast_in_dim"(%10681) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10683 = mhlo.shift_left %10679, %10682 : tensor<1xui32> loc(#loc999)
%10684 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10685 = "mhlo.broadcast_in_dim"(%10684) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10686 = mhlo.shift_right_logical %10679, %10685 : tensor<1xui32> loc(#loc987)
%10687 = mhlo.or %10683, %10686 : tensor<1xui32> loc(#loc1000)
%10688 = mhlo.xor %10680, %10687 : tensor<1xui32> loc(#loc996)
%10689 = mhlo.add %10680, %10688 : tensor<1xui32> loc(#loc998)
%10690 = mhlo.constant dense<24> : tensor<ui32> loc(#loc997)
%10691 = "mhlo.broadcast_in_dim"(%10690) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10692 = mhlo.shift_left %10688, %10691 : tensor<1xui32> loc(#loc999)
%10693 = mhlo.constant dense<8> : tensor<ui32> loc(#loc997)
%10694 = "mhlo.broadcast_in_dim"(%10693) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10695 = mhlo.shift_right_logical %10688, %10694 : tensor<1xui32> loc(#loc987)
%10696 = mhlo.or %10692, %10695 : tensor<1xui32> loc(#loc1000)
%10697 = mhlo.xor %10689, %10696 : tensor<1xui32> loc(#loc996)
%10698 = "mhlo.broadcast_in_dim"(%10614) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10699 = mhlo.add %10689, %10698 : tensor<1xui32> loc(#loc998)
%10700 = "mhlo.broadcast_in_dim"(%10607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10701 = mhlo.add %10697, %10700 : tensor<1xui32> loc(#loc998)
%10702 = mhlo.constant dense<2> : tensor<ui32> loc(#loc997)
%10703 = "mhlo.broadcast_in_dim"(%10702) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10704 = mhlo.add %10701, %10703 : tensor<1xui32> loc(#loc998)
%10705 = mhlo.add %10699, %10704 : tensor<1xui32> loc(#loc998)
%10706 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10707 = "mhlo.broadcast_in_dim"(%10706) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10708 = mhlo.shift_left %10704, %10707 : tensor<1xui32> loc(#loc999)
%10709 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10710 = "mhlo.broadcast_in_dim"(%10709) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10711 = mhlo.shift_right_logical %10704, %10710 : tensor<1xui32> loc(#loc987)
%10712 = mhlo.or %10708, %10711 : tensor<1xui32> loc(#loc1000)
%10713 = mhlo.xor %10705, %10712 : tensor<1xui32> loc(#loc996)
%10714 = mhlo.add %10705, %10713 : tensor<1xui32> loc(#loc998)
%10715 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10716 = "mhlo.broadcast_in_dim"(%10715) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10717 = mhlo.shift_left %10713, %10716 : tensor<1xui32> loc(#loc999)
%10718 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10719 = "mhlo.broadcast_in_dim"(%10718) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10720 = mhlo.shift_right_logical %10713, %10719 : tensor<1xui32> loc(#loc987)
%10721 = mhlo.or %10717, %10720 : tensor<1xui32> loc(#loc1000)
%10722 = mhlo.xor %10714, %10721 : tensor<1xui32> loc(#loc996)
%10723 = mhlo.add %10714, %10722 : tensor<1xui32> loc(#loc998)
%10724 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10725 = "mhlo.broadcast_in_dim"(%10724) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10726 = mhlo.shift_left %10722, %10725 : tensor<1xui32> loc(#loc999)
%10727 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10728 = "mhlo.broadcast_in_dim"(%10727) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10729 = mhlo.shift_right_logical %10722, %10728 : tensor<1xui32> loc(#loc987)
%10730 = mhlo.or %10726, %10729 : tensor<1xui32> loc(#loc1000)
%10731 = mhlo.xor %10723, %10730 : tensor<1xui32> loc(#loc996)
%10732 = mhlo.add %10723, %10731 : tensor<1xui32> loc(#loc998)
%10733 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10734 = "mhlo.broadcast_in_dim"(%10733) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10735 = mhlo.shift_left %10731, %10734 : tensor<1xui32> loc(#loc999)
%10736 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10737 = "mhlo.broadcast_in_dim"(%10736) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10738 = mhlo.shift_right_logical %10731, %10737 : tensor<1xui32> loc(#loc987)
%10739 = mhlo.or %10735, %10738 : tensor<1xui32> loc(#loc1000)
%10740 = mhlo.xor %10732, %10739 : tensor<1xui32> loc(#loc996)
%10741 = "mhlo.broadcast_in_dim"(%10607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10742 = mhlo.add %10732, %10741 : tensor<1xui32> loc(#loc998)
%10743 = "mhlo.broadcast_in_dim"(%10609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10744 = mhlo.add %10740, %10743 : tensor<1xui32> loc(#loc998)
%10745 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10746 = "mhlo.broadcast_in_dim"(%10745) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10747 = mhlo.add %10744, %10746 : tensor<1xui32> loc(#loc998)
%10748 = mhlo.add %10742, %10747 : tensor<1xui32> loc(#loc998)
%10749 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10750 = "mhlo.broadcast_in_dim"(%10749) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10751 = mhlo.shift_left %10747, %10750 : tensor<1xui32> loc(#loc999)
%10752 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10753 = "mhlo.broadcast_in_dim"(%10752) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10754 = mhlo.shift_right_logical %10747, %10753 : tensor<1xui32> loc(#loc987)
%10755 = mhlo.or %10751, %10754 : tensor<1xui32> loc(#loc1000)
%10756 = mhlo.xor %10748, %10755 : tensor<1xui32> loc(#loc996)
%10757 = mhlo.add %10748, %10756 : tensor<1xui32> loc(#loc998)
%10758 = mhlo.constant dense<29> : tensor<ui32> loc(#loc997)
%10759 = "mhlo.broadcast_in_dim"(%10758) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10760 = mhlo.shift_left %10756, %10759 : tensor<1xui32> loc(#loc999)
%10761 = mhlo.constant dense<3> : tensor<ui32> loc(#loc997)
%10762 = "mhlo.broadcast_in_dim"(%10761) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10763 = mhlo.shift_right_logical %10756, %10762 : tensor<1xui32> loc(#loc987)
%10764 = mhlo.or %10760, %10763 : tensor<1xui32> loc(#loc1000)
%10765 = mhlo.xor %10757, %10764 : tensor<1xui32> loc(#loc996)
%10766 = mhlo.add %10757, %10765 : tensor<1xui32> loc(#loc998)
%10767 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10768 = "mhlo.broadcast_in_dim"(%10767) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10769 = mhlo.shift_left %10765, %10768 : tensor<1xui32> loc(#loc999)
%10770 = mhlo.constant dense<16> : tensor<ui32> loc(#loc997)
%10771 = "mhlo.broadcast_in_dim"(%10770) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10772 = mhlo.shift_right_logical %10765, %10771 : tensor<1xui32> loc(#loc987)
%10773 = mhlo.or %10769, %10772 : tensor<1xui32> loc(#loc1000)
%10774 = mhlo.xor %10766, %10773 : tensor<1xui32> loc(#loc996)
%10775 = mhlo.add %10766, %10774 : tensor<1xui32> loc(#loc998)
%10776 = mhlo.constant dense<24> : tensor<ui32> loc(#loc997)
%10777 = "mhlo.broadcast_in_dim"(%10776) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10778 = mhlo.shift_left %10774, %10777 : tensor<1xui32> loc(#loc999)
%10779 = mhlo.constant dense<8> : tensor<ui32> loc(#loc997)
%10780 = "mhlo.broadcast_in_dim"(%10779) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10781 = mhlo.shift_right_logical %10774, %10780 : tensor<1xui32> loc(#loc987)
%10782 = mhlo.or %10778, %10781 : tensor<1xui32> loc(#loc1000)
%10783 = mhlo.xor %10775, %10782 : tensor<1xui32> loc(#loc996)
%10784 = "mhlo.broadcast_in_dim"(%10609) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10785 = mhlo.add %10775, %10784 : tensor<1xui32> loc(#loc998)
%10786 = "mhlo.broadcast_in_dim"(%10614) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10787 = mhlo.add %10783, %10786 : tensor<1xui32> loc(#loc998)
%10788 = mhlo.constant dense<4> : tensor<ui32> loc(#loc997)
%10789 = "mhlo.broadcast_in_dim"(%10788) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10790 = mhlo.add %10787, %10789 : tensor<1xui32> loc(#loc998)
%10791 = mhlo.add %10785, %10790 : tensor<1xui32> loc(#loc998)
%10792 = mhlo.constant dense<13> : tensor<ui32> loc(#loc997)
%10793 = "mhlo.broadcast_in_dim"(%10792) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10794 = mhlo.shift_left %10790, %10793 : tensor<1xui32> loc(#loc999)
%10795 = mhlo.constant dense<19> : tensor<ui32> loc(#loc997)
%10796 = "mhlo.broadcast_in_dim"(%10795) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10797 = mhlo.shift_right_logical %10790, %10796 : tensor<1xui32> loc(#loc987)
%10798 = mhlo.or %10794, %10797 : tensor<1xui32> loc(#loc1000)
%10799 = mhlo.xor %10791, %10798 : tensor<1xui32> loc(#loc996)
%10800 = mhlo.add %10791, %10799 : tensor<1xui32> loc(#loc998)
%10801 = mhlo.constant dense<15> : tensor<ui32> loc(#loc997)
%10802 = "mhlo.broadcast_in_dim"(%10801) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10803 = mhlo.shift_left %10799, %10802 : tensor<1xui32> loc(#loc999)
%10804 = mhlo.constant dense<17> : tensor<ui32> loc(#loc997)
%10805 = "mhlo.broadcast_in_dim"(%10804) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10806 = mhlo.shift_right_logical %10799, %10805 : tensor<1xui32> loc(#loc987)
%10807 = mhlo.or %10803, %10806 : tensor<1xui32> loc(#loc1000)
%10808 = mhlo.xor %10800, %10807 : tensor<1xui32> loc(#loc996)
%10809 = mhlo.add %10800, %10808 : tensor<1xui32> loc(#loc998)
%10810 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10811 = "mhlo.broadcast_in_dim"(%10810) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10812 = mhlo.shift_left %10808, %10811 : tensor<1xui32> loc(#loc999)
%10813 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10814 = "mhlo.broadcast_in_dim"(%10813) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10815 = mhlo.shift_right_logical %10808, %10814 : tensor<1xui32> loc(#loc987)
%10816 = mhlo.or %10812, %10815 : tensor<1xui32> loc(#loc1000)
%10817 = mhlo.xor %10809, %10816 : tensor<1xui32> loc(#loc996)
%10818 = mhlo.add %10809, %10817 : tensor<1xui32> loc(#loc998)
%10819 = mhlo.constant dense<6> : tensor<ui32> loc(#loc997)
%10820 = "mhlo.broadcast_in_dim"(%10819) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc999)
%10821 = mhlo.shift_left %10817, %10820 : tensor<1xui32> loc(#loc999)
%10822 = mhlo.constant dense<26> : tensor<ui32> loc(#loc997)
%10823 = "mhlo.broadcast_in_dim"(%10822) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc987)
%10824 = mhlo.shift_right_logical %10817, %10823 : tensor<1xui32> loc(#loc987)
%10825 = mhlo.or %10821, %10824 : tensor<1xui32> loc(#loc1000)
%10826 = mhlo.xor %10818, %10825 : tensor<1xui32> loc(#loc996)
%10827 = "mhlo.broadcast_in_dim"(%10614) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10828 = mhlo.add %10818, %10827 : tensor<1xui32> loc(#loc998)
%10829 = "mhlo.broadcast_in_dim"(%10607) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10830 = mhlo.add %10826, %10829 : tensor<1xui32> loc(#loc998)
%10831 = mhlo.constant dense<5> : tensor<ui32> loc(#loc997)
%10832 = "mhlo.broadcast_in_dim"(%10831) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc998)
%10833 = mhlo.add %10830, %10832 : tensor<1xui32> loc(#loc998)
%10834 = "mhlo.concatenate"(%10828, %10833) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc990)
%10835 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%10836 = "mhlo.broadcast_in_dim"(%10835) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc1001)
%10837 = "mhlo.reshape"(%10836) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc1005)
%10838 = "mhlo.broadcast_in_dim"(%10837) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc1006)
%10839 = mhlo.add %10597, %10838 : tensor<1x256x2048xf32> loc(#loc1006)
%10840 = mhlo.convert(%10839) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc1007)
%10841 = mhlo.constant dense<1.000000e+00> : tensor<f16> loc(#loc531)
%10842 = "mhlo.broadcast_in_dim"(%10841) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f16>) -> tensor<1x256x2048xf16> loc(#loc1008)
%10843 = mhlo.multiply %8040, %10842 : tensor<1x256x2048xf16> loc(#loc1008)
%10844 = mhlo.add %10843, %10840 : tensor<1x256x2048xf16> loc(#loc1009)
%10845 = mhlo.convert(%10844) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc1010)
%10846 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc1011)
%10847 = mhlo.reduce(%10845 init: %10846) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc1011)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc1011)
} loc(#loc1011)
%10848 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%10849 = "mhlo.broadcast_in_dim"(%10848) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc1012)
%10850 = mhlo.divide %10847, %10849 : tensor<1x256xf32> loc(#loc1012)
%10851 = mhlo.multiply %10845, %10845 : tensor<1x256x2048xf32> loc(#loc1013)
%10852 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc1014)
%10853 = mhlo.reduce(%10851 init: %10852) across dimensions = [2] : (tensor<1x256x2048xf32>, tensor<f32>) -> tensor<1x256xf32>
reducer(%arg47: tensor<f32> loc(unknown), %arg48: tensor<f32> loc(unknown)) {
%13358 = mhlo.add %arg47, %arg48 : tensor<f32> loc(#loc1014)
"mhlo.return"(%13358) : (tensor<f32>) -> () loc(#loc1014)
} loc(#loc1014)
%10854 = mhlo.constant dense<2.048000e+03> : tensor<f32> loc(#loc531)
%10855 = "mhlo.broadcast_in_dim"(%10854) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc1015)
%10856 = mhlo.divide %10853, %10855 : tensor<1x256xf32> loc(#loc1015)
%10857 = mhlo.multiply %10850, %10850 : tensor<1x256xf32> loc(#loc1013)
%10858 = mhlo.subtract %10856, %10857 : tensor<1x256xf32> loc(#loc1016)
%10859 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%10860 = "mhlo.broadcast_in_dim"(%10859) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256xf32> loc(#loc1017)
%10861 = mhlo.maximum %10860, %10858 : tensor<1x256xf32> loc(#loc1017)
%10862 = "mhlo.reshape"(%10850) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc1018)
%10863 = "mhlo.reshape"(%10861) : (tensor<1x256xf32>) -> tensor<1x256x1xf32> loc(#loc1019)
%10864 = mhlo.convert(%10844) : (tensor<1x256x2048xf16>) -> tensor<1x256x2048xf32> loc(#loc1020)
%10865 = "mhlo.broadcast_in_dim"(%10862) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc1021)
%10866 = mhlo.subtract %10864, %10865 : tensor<1x256x2048xf32> loc(#loc1021)
%10867 = mhlo.constant dense<9.99999974E-6> : tensor<f32> loc(#loc531)
%10868 = "mhlo.broadcast_in_dim"(%10867) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x256x1xf32> loc(#loc1022)
%10869 = mhlo.add %10863, %10868 : tensor<1x256x1xf32> loc(#loc1022)
%10870 = mhlo.rsqrt %10869 : tensor<1x256x1xf32> loc(#loc1023)
%10871 = "mhlo.broadcast_in_dim"(%10870) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x256x1xf32>) -> tensor<1x256x2048xf32> loc(#loc1024)
%10872 = mhlo.multiply %10866, %10871 : tensor<1x256x2048xf32> loc(#loc1024)
%10873 = mhlo.constant dense<949201226> : tensor<ui32> loc(#loc531)
%10874 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%10875 = mhlo.shift_right_logical %10873, %10874 : tensor<ui32> loc(#loc1025)
%10876 = "mhlo.reshape"(%10875) : (tensor<ui32>) -> tensor<1xui32> loc(#loc1026)
%10877 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%10878 = mhlo.and %10873, %10877 : tensor<ui32> loc(#loc1027)
%10879 = "mhlo.reshape"(%10878) : (tensor<ui32>) -> tensor<1xui32> loc(#loc1026)
%10880 = "mhlo.concatenate"(%10876, %10879) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc1028)
%10881 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1029)
%10882 = "mhlo.reshape"(%10881) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1030)
%10883 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1031)
%10884 = "mhlo.reshape"(%10883) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1030)
%10885 = "mhlo.slice"(%10880) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1032)
%10886 = "mhlo.slice"(%10880) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1033)
%10887 = mhlo.xor %10882, %10884 : tensor<ui32> loc(#loc1034)
%10888 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc1035)
%10889 = mhlo.xor %10887, %10888 : tensor<ui32> loc(#loc1034)
%10890 = "mhlo.broadcast_in_dim"(%10882) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10891 = mhlo.add %10885, %10890 : tensor<1xui32> loc(#loc1036)
%10892 = "mhlo.broadcast_in_dim"(%10884) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10893 = mhlo.add %10886, %10892 : tensor<1xui32> loc(#loc1036)
%10894 = mhlo.add %10891, %10893 : tensor<1xui32> loc(#loc1036)
%10895 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1035)
%10896 = "mhlo.broadcast_in_dim"(%10895) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10897 = mhlo.shift_left %10893, %10896 : tensor<1xui32> loc(#loc1037)
%10898 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1035)
%10899 = "mhlo.broadcast_in_dim"(%10898) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10900 = mhlo.shift_right_logical %10893, %10899 : tensor<1xui32> loc(#loc1025)
%10901 = mhlo.or %10897, %10900 : tensor<1xui32> loc(#loc1038)
%10902 = mhlo.xor %10894, %10901 : tensor<1xui32> loc(#loc1034)
%10903 = mhlo.add %10894, %10902 : tensor<1xui32> loc(#loc1036)
%10904 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1035)
%10905 = "mhlo.broadcast_in_dim"(%10904) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10906 = mhlo.shift_left %10902, %10905 : tensor<1xui32> loc(#loc1037)
%10907 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1035)
%10908 = "mhlo.broadcast_in_dim"(%10907) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10909 = mhlo.shift_right_logical %10902, %10908 : tensor<1xui32> loc(#loc1025)
%10910 = mhlo.or %10906, %10909 : tensor<1xui32> loc(#loc1038)
%10911 = mhlo.xor %10903, %10910 : tensor<1xui32> loc(#loc1034)
%10912 = mhlo.add %10903, %10911 : tensor<1xui32> loc(#loc1036)
%10913 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%10914 = "mhlo.broadcast_in_dim"(%10913) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10915 = mhlo.shift_left %10911, %10914 : tensor<1xui32> loc(#loc1037)
%10916 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%10917 = "mhlo.broadcast_in_dim"(%10916) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10918 = mhlo.shift_right_logical %10911, %10917 : tensor<1xui32> loc(#loc1025)
%10919 = mhlo.or %10915, %10918 : tensor<1xui32> loc(#loc1038)
%10920 = mhlo.xor %10912, %10919 : tensor<1xui32> loc(#loc1034)
%10921 = mhlo.add %10912, %10920 : tensor<1xui32> loc(#loc1036)
%10922 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%10923 = "mhlo.broadcast_in_dim"(%10922) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10924 = mhlo.shift_left %10920, %10923 : tensor<1xui32> loc(#loc1037)
%10925 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%10926 = "mhlo.broadcast_in_dim"(%10925) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10927 = mhlo.shift_right_logical %10920, %10926 : tensor<1xui32> loc(#loc1025)
%10928 = mhlo.or %10924, %10927 : tensor<1xui32> loc(#loc1038)
%10929 = mhlo.xor %10921, %10928 : tensor<1xui32> loc(#loc1034)
%10930 = "mhlo.broadcast_in_dim"(%10884) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10931 = mhlo.add %10921, %10930 : tensor<1xui32> loc(#loc1036)
%10932 = "mhlo.broadcast_in_dim"(%10889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10933 = mhlo.add %10929, %10932 : tensor<1xui32> loc(#loc1036)
%10934 = mhlo.constant dense<1> : tensor<ui32> loc(#loc1035)
%10935 = "mhlo.broadcast_in_dim"(%10934) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10936 = mhlo.add %10933, %10935 : tensor<1xui32> loc(#loc1036)
%10937 = mhlo.add %10931, %10936 : tensor<1xui32> loc(#loc1036)
%10938 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1035)
%10939 = "mhlo.broadcast_in_dim"(%10938) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10940 = mhlo.shift_left %10936, %10939 : tensor<1xui32> loc(#loc1037)
%10941 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1035)
%10942 = "mhlo.broadcast_in_dim"(%10941) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10943 = mhlo.shift_right_logical %10936, %10942 : tensor<1xui32> loc(#loc1025)
%10944 = mhlo.or %10940, %10943 : tensor<1xui32> loc(#loc1038)
%10945 = mhlo.xor %10937, %10944 : tensor<1xui32> loc(#loc1034)
%10946 = mhlo.add %10937, %10945 : tensor<1xui32> loc(#loc1036)
%10947 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1035)
%10948 = "mhlo.broadcast_in_dim"(%10947) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10949 = mhlo.shift_left %10945, %10948 : tensor<1xui32> loc(#loc1037)
%10950 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1035)
%10951 = "mhlo.broadcast_in_dim"(%10950) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10952 = mhlo.shift_right_logical %10945, %10951 : tensor<1xui32> loc(#loc1025)
%10953 = mhlo.or %10949, %10952 : tensor<1xui32> loc(#loc1038)
%10954 = mhlo.xor %10946, %10953 : tensor<1xui32> loc(#loc1034)
%10955 = mhlo.add %10946, %10954 : tensor<1xui32> loc(#loc1036)
%10956 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1035)
%10957 = "mhlo.broadcast_in_dim"(%10956) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10958 = mhlo.shift_left %10954, %10957 : tensor<1xui32> loc(#loc1037)
%10959 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1035)
%10960 = "mhlo.broadcast_in_dim"(%10959) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10961 = mhlo.shift_right_logical %10954, %10960 : tensor<1xui32> loc(#loc1025)
%10962 = mhlo.or %10958, %10961 : tensor<1xui32> loc(#loc1038)
%10963 = mhlo.xor %10955, %10962 : tensor<1xui32> loc(#loc1034)
%10964 = mhlo.add %10955, %10963 : tensor<1xui32> loc(#loc1036)
%10965 = mhlo.constant dense<24> : tensor<ui32> loc(#loc1035)
%10966 = "mhlo.broadcast_in_dim"(%10965) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10967 = mhlo.shift_left %10963, %10966 : tensor<1xui32> loc(#loc1037)
%10968 = mhlo.constant dense<8> : tensor<ui32> loc(#loc1035)
%10969 = "mhlo.broadcast_in_dim"(%10968) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10970 = mhlo.shift_right_logical %10963, %10969 : tensor<1xui32> loc(#loc1025)
%10971 = mhlo.or %10967, %10970 : tensor<1xui32> loc(#loc1038)
%10972 = mhlo.xor %10964, %10971 : tensor<1xui32> loc(#loc1034)
%10973 = "mhlo.broadcast_in_dim"(%10889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10974 = mhlo.add %10964, %10973 : tensor<1xui32> loc(#loc1036)
%10975 = "mhlo.broadcast_in_dim"(%10882) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10976 = mhlo.add %10972, %10975 : tensor<1xui32> loc(#loc1036)
%10977 = mhlo.constant dense<2> : tensor<ui32> loc(#loc1035)
%10978 = "mhlo.broadcast_in_dim"(%10977) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%10979 = mhlo.add %10976, %10978 : tensor<1xui32> loc(#loc1036)
%10980 = mhlo.add %10974, %10979 : tensor<1xui32> loc(#loc1036)
%10981 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1035)
%10982 = "mhlo.broadcast_in_dim"(%10981) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10983 = mhlo.shift_left %10979, %10982 : tensor<1xui32> loc(#loc1037)
%10984 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1035)
%10985 = "mhlo.broadcast_in_dim"(%10984) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10986 = mhlo.shift_right_logical %10979, %10985 : tensor<1xui32> loc(#loc1025)
%10987 = mhlo.or %10983, %10986 : tensor<1xui32> loc(#loc1038)
%10988 = mhlo.xor %10980, %10987 : tensor<1xui32> loc(#loc1034)
%10989 = mhlo.add %10980, %10988 : tensor<1xui32> loc(#loc1036)
%10990 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1035)
%10991 = "mhlo.broadcast_in_dim"(%10990) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%10992 = mhlo.shift_left %10988, %10991 : tensor<1xui32> loc(#loc1037)
%10993 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1035)
%10994 = "mhlo.broadcast_in_dim"(%10993) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%10995 = mhlo.shift_right_logical %10988, %10994 : tensor<1xui32> loc(#loc1025)
%10996 = mhlo.or %10992, %10995 : tensor<1xui32> loc(#loc1038)
%10997 = mhlo.xor %10989, %10996 : tensor<1xui32> loc(#loc1034)
%10998 = mhlo.add %10989, %10997 : tensor<1xui32> loc(#loc1036)
%10999 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%11000 = "mhlo.broadcast_in_dim"(%10999) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11001 = mhlo.shift_left %10997, %11000 : tensor<1xui32> loc(#loc1037)
%11002 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%11003 = "mhlo.broadcast_in_dim"(%11002) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11004 = mhlo.shift_right_logical %10997, %11003 : tensor<1xui32> loc(#loc1025)
%11005 = mhlo.or %11001, %11004 : tensor<1xui32> loc(#loc1038)
%11006 = mhlo.xor %10998, %11005 : tensor<1xui32> loc(#loc1034)
%11007 = mhlo.add %10998, %11006 : tensor<1xui32> loc(#loc1036)
%11008 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%11009 = "mhlo.broadcast_in_dim"(%11008) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11010 = mhlo.shift_left %11006, %11009 : tensor<1xui32> loc(#loc1037)
%11011 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%11012 = "mhlo.broadcast_in_dim"(%11011) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11013 = mhlo.shift_right_logical %11006, %11012 : tensor<1xui32> loc(#loc1025)
%11014 = mhlo.or %11010, %11013 : tensor<1xui32> loc(#loc1038)
%11015 = mhlo.xor %11007, %11014 : tensor<1xui32> loc(#loc1034)
%11016 = "mhlo.broadcast_in_dim"(%10882) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11017 = mhlo.add %11007, %11016 : tensor<1xui32> loc(#loc1036)
%11018 = "mhlo.broadcast_in_dim"(%10884) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11019 = mhlo.add %11015, %11018 : tensor<1xui32> loc(#loc1036)
%11020 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1035)
%11021 = "mhlo.broadcast_in_dim"(%11020) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11022 = mhlo.add %11019, %11021 : tensor<1xui32> loc(#loc1036)
%11023 = mhlo.add %11017, %11022 : tensor<1xui32> loc(#loc1036)
%11024 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1035)
%11025 = "mhlo.broadcast_in_dim"(%11024) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11026 = mhlo.shift_left %11022, %11025 : tensor<1xui32> loc(#loc1037)
%11027 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1035)
%11028 = "mhlo.broadcast_in_dim"(%11027) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11029 = mhlo.shift_right_logical %11022, %11028 : tensor<1xui32> loc(#loc1025)
%11030 = mhlo.or %11026, %11029 : tensor<1xui32> loc(#loc1038)
%11031 = mhlo.xor %11023, %11030 : tensor<1xui32> loc(#loc1034)
%11032 = mhlo.add %11023, %11031 : tensor<1xui32> loc(#loc1036)
%11033 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1035)
%11034 = "mhlo.broadcast_in_dim"(%11033) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11035 = mhlo.shift_left %11031, %11034 : tensor<1xui32> loc(#loc1037)
%11036 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1035)
%11037 = "mhlo.broadcast_in_dim"(%11036) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11038 = mhlo.shift_right_logical %11031, %11037 : tensor<1xui32> loc(#loc1025)
%11039 = mhlo.or %11035, %11038 : tensor<1xui32> loc(#loc1038)
%11040 = mhlo.xor %11032, %11039 : tensor<1xui32> loc(#loc1034)
%11041 = mhlo.add %11032, %11040 : tensor<1xui32> loc(#loc1036)
%11042 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1035)
%11043 = "mhlo.broadcast_in_dim"(%11042) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11044 = mhlo.shift_left %11040, %11043 : tensor<1xui32> loc(#loc1037)
%11045 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1035)
%11046 = "mhlo.broadcast_in_dim"(%11045) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11047 = mhlo.shift_right_logical %11040, %11046 : tensor<1xui32> loc(#loc1025)
%11048 = mhlo.or %11044, %11047 : tensor<1xui32> loc(#loc1038)
%11049 = mhlo.xor %11041, %11048 : tensor<1xui32> loc(#loc1034)
%11050 = mhlo.add %11041, %11049 : tensor<1xui32> loc(#loc1036)
%11051 = mhlo.constant dense<24> : tensor<ui32> loc(#loc1035)
%11052 = "mhlo.broadcast_in_dim"(%11051) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11053 = mhlo.shift_left %11049, %11052 : tensor<1xui32> loc(#loc1037)
%11054 = mhlo.constant dense<8> : tensor<ui32> loc(#loc1035)
%11055 = "mhlo.broadcast_in_dim"(%11054) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11056 = mhlo.shift_right_logical %11049, %11055 : tensor<1xui32> loc(#loc1025)
%11057 = mhlo.or %11053, %11056 : tensor<1xui32> loc(#loc1038)
%11058 = mhlo.xor %11050, %11057 : tensor<1xui32> loc(#loc1034)
%11059 = "mhlo.broadcast_in_dim"(%10884) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11060 = mhlo.add %11050, %11059 : tensor<1xui32> loc(#loc1036)
%11061 = "mhlo.broadcast_in_dim"(%10889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11062 = mhlo.add %11058, %11061 : tensor<1xui32> loc(#loc1036)
%11063 = mhlo.constant dense<4> : tensor<ui32> loc(#loc1035)
%11064 = "mhlo.broadcast_in_dim"(%11063) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11065 = mhlo.add %11062, %11064 : tensor<1xui32> loc(#loc1036)
%11066 = mhlo.add %11060, %11065 : tensor<1xui32> loc(#loc1036)
%11067 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1035)
%11068 = "mhlo.broadcast_in_dim"(%11067) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11069 = mhlo.shift_left %11065, %11068 : tensor<1xui32> loc(#loc1037)
%11070 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1035)
%11071 = "mhlo.broadcast_in_dim"(%11070) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11072 = mhlo.shift_right_logical %11065, %11071 : tensor<1xui32> loc(#loc1025)
%11073 = mhlo.or %11069, %11072 : tensor<1xui32> loc(#loc1038)
%11074 = mhlo.xor %11066, %11073 : tensor<1xui32> loc(#loc1034)
%11075 = mhlo.add %11066, %11074 : tensor<1xui32> loc(#loc1036)
%11076 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1035)
%11077 = "mhlo.broadcast_in_dim"(%11076) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11078 = mhlo.shift_left %11074, %11077 : tensor<1xui32> loc(#loc1037)
%11079 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1035)
%11080 = "mhlo.broadcast_in_dim"(%11079) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11081 = mhlo.shift_right_logical %11074, %11080 : tensor<1xui32> loc(#loc1025)
%11082 = mhlo.or %11078, %11081 : tensor<1xui32> loc(#loc1038)
%11083 = mhlo.xor %11075, %11082 : tensor<1xui32> loc(#loc1034)
%11084 = mhlo.add %11075, %11083 : tensor<1xui32> loc(#loc1036)
%11085 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%11086 = "mhlo.broadcast_in_dim"(%11085) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11087 = mhlo.shift_left %11083, %11086 : tensor<1xui32> loc(#loc1037)
%11088 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%11089 = "mhlo.broadcast_in_dim"(%11088) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11090 = mhlo.shift_right_logical %11083, %11089 : tensor<1xui32> loc(#loc1025)
%11091 = mhlo.or %11087, %11090 : tensor<1xui32> loc(#loc1038)
%11092 = mhlo.xor %11084, %11091 : tensor<1xui32> loc(#loc1034)
%11093 = mhlo.add %11084, %11092 : tensor<1xui32> loc(#loc1036)
%11094 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1035)
%11095 = "mhlo.broadcast_in_dim"(%11094) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1037)
%11096 = mhlo.shift_left %11092, %11095 : tensor<1xui32> loc(#loc1037)
%11097 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1035)
%11098 = "mhlo.broadcast_in_dim"(%11097) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1025)
%11099 = mhlo.shift_right_logical %11092, %11098 : tensor<1xui32> loc(#loc1025)
%11100 = mhlo.or %11096, %11099 : tensor<1xui32> loc(#loc1038)
%11101 = mhlo.xor %11093, %11100 : tensor<1xui32> loc(#loc1034)
%11102 = "mhlo.broadcast_in_dim"(%10889) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11103 = mhlo.add %11093, %11102 : tensor<1xui32> loc(#loc1036)
%11104 = "mhlo.broadcast_in_dim"(%10882) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11105 = mhlo.add %11101, %11104 : tensor<1xui32> loc(#loc1036)
%11106 = mhlo.constant dense<5> : tensor<ui32> loc(#loc1035)
%11107 = "mhlo.broadcast_in_dim"(%11106) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1036)
%11108 = mhlo.add %11105, %11107 : tensor<1xui32> loc(#loc1036)
%11109 = "mhlo.concatenate"(%11103, %11108) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc1028)
%11110 = mhlo.constant dense<0.000000e+00> : tensor<f32> loc(#loc531)
%11111 = "mhlo.broadcast_in_dim"(%11110) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<2048xf32> loc(#loc1039)
%11112 = "mhlo.reshape"(%11111) : (tensor<2048xf32>) -> tensor<1x1x2048xf32> loc(#loc1040)
%11113 = "mhlo.broadcast_in_dim"(%11112) {broadcast_dimensions = dense<[0, 1, 2]> : tensor<3xi64>} : (tensor<1x1x2048xf32>) -> tensor<1x256x2048xf32> loc(#loc1041)
%11114 = mhlo.add %10872, %11113 : tensor<1x256x2048xf32> loc(#loc1041)
%11115 = mhlo.convert(%11114) : (tensor<1x256x2048xf32>) -> tensor<1x256x2048xf16> loc(#loc1042)
%11116 = mhlo.constant dense<876918311> : tensor<ui32> loc(#loc531)
%11117 = mhlo.constant dense<32> : tensor<ui32> loc(#loc531)
%11118 = mhlo.shift_right_logical %11116, %11117 : tensor<ui32> loc(#loc1043)
%11119 = "mhlo.reshape"(%11118) : (tensor<ui32>) -> tensor<1xui32> loc(#loc1044)
%11120 = mhlo.constant dense<4294967295> : tensor<ui32> loc(#loc531)
%11121 = mhlo.and %11116, %11120 : tensor<ui32> loc(#loc1045)
%11122 = "mhlo.reshape"(%11121) : (tensor<ui32>) -> tensor<1xui32> loc(#loc1044)
%11123 = "mhlo.concatenate"(%11119, %11122) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc1046)
%11124 = "mhlo.slice"(%5202) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1047)
%11125 = "mhlo.reshape"(%11124) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1048)
%11126 = "mhlo.slice"(%5202) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1049)
%11127 = "mhlo.reshape"(%11126) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1048)
%11128 = "mhlo.slice"(%11123) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1050)
%11129 = "mhlo.slice"(%11123) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1051)
%11130 = mhlo.xor %11125, %11127 : tensor<ui32> loc(#loc1052)
%11131 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc1053)
%11132 = mhlo.xor %11130, %11131 : tensor<ui32> loc(#loc1052)
%11133 = "mhlo.broadcast_in_dim"(%11125) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11134 = mhlo.add %11128, %11133 : tensor<1xui32> loc(#loc1054)
%11135 = "mhlo.broadcast_in_dim"(%11127) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11136 = mhlo.add %11129, %11135 : tensor<1xui32> loc(#loc1054)
%11137 = mhlo.add %11134, %11136 : tensor<1xui32> loc(#loc1054)
%11138 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1053)
%11139 = "mhlo.broadcast_in_dim"(%11138) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11140 = mhlo.shift_left %11136, %11139 : tensor<1xui32> loc(#loc1055)
%11141 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1053)
%11142 = "mhlo.broadcast_in_dim"(%11141) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11143 = mhlo.shift_right_logical %11136, %11142 : tensor<1xui32> loc(#loc1043)
%11144 = mhlo.or %11140, %11143 : tensor<1xui32> loc(#loc1056)
%11145 = mhlo.xor %11137, %11144 : tensor<1xui32> loc(#loc1052)
%11146 = mhlo.add %11137, %11145 : tensor<1xui32> loc(#loc1054)
%11147 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1053)
%11148 = "mhlo.broadcast_in_dim"(%11147) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11149 = mhlo.shift_left %11145, %11148 : tensor<1xui32> loc(#loc1055)
%11150 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1053)
%11151 = "mhlo.broadcast_in_dim"(%11150) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11152 = mhlo.shift_right_logical %11145, %11151 : tensor<1xui32> loc(#loc1043)
%11153 = mhlo.or %11149, %11152 : tensor<1xui32> loc(#loc1056)
%11154 = mhlo.xor %11146, %11153 : tensor<1xui32> loc(#loc1052)
%11155 = mhlo.add %11146, %11154 : tensor<1xui32> loc(#loc1054)
%11156 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11157 = "mhlo.broadcast_in_dim"(%11156) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11158 = mhlo.shift_left %11154, %11157 : tensor<1xui32> loc(#loc1055)
%11159 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11160 = "mhlo.broadcast_in_dim"(%11159) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11161 = mhlo.shift_right_logical %11154, %11160 : tensor<1xui32> loc(#loc1043)
%11162 = mhlo.or %11158, %11161 : tensor<1xui32> loc(#loc1056)
%11163 = mhlo.xor %11155, %11162 : tensor<1xui32> loc(#loc1052)
%11164 = mhlo.add %11155, %11163 : tensor<1xui32> loc(#loc1054)
%11165 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11166 = "mhlo.broadcast_in_dim"(%11165) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11167 = mhlo.shift_left %11163, %11166 : tensor<1xui32> loc(#loc1055)
%11168 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11169 = "mhlo.broadcast_in_dim"(%11168) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11170 = mhlo.shift_right_logical %11163, %11169 : tensor<1xui32> loc(#loc1043)
%11171 = mhlo.or %11167, %11170 : tensor<1xui32> loc(#loc1056)
%11172 = mhlo.xor %11164, %11171 : tensor<1xui32> loc(#loc1052)
%11173 = "mhlo.broadcast_in_dim"(%11127) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11174 = mhlo.add %11164, %11173 : tensor<1xui32> loc(#loc1054)
%11175 = "mhlo.broadcast_in_dim"(%11132) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11176 = mhlo.add %11172, %11175 : tensor<1xui32> loc(#loc1054)
%11177 = mhlo.constant dense<1> : tensor<ui32> loc(#loc1053)
%11178 = "mhlo.broadcast_in_dim"(%11177) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11179 = mhlo.add %11176, %11178 : tensor<1xui32> loc(#loc1054)
%11180 = mhlo.add %11174, %11179 : tensor<1xui32> loc(#loc1054)
%11181 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1053)
%11182 = "mhlo.broadcast_in_dim"(%11181) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11183 = mhlo.shift_left %11179, %11182 : tensor<1xui32> loc(#loc1055)
%11184 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1053)
%11185 = "mhlo.broadcast_in_dim"(%11184) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11186 = mhlo.shift_right_logical %11179, %11185 : tensor<1xui32> loc(#loc1043)
%11187 = mhlo.or %11183, %11186 : tensor<1xui32> loc(#loc1056)
%11188 = mhlo.xor %11180, %11187 : tensor<1xui32> loc(#loc1052)
%11189 = mhlo.add %11180, %11188 : tensor<1xui32> loc(#loc1054)
%11190 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1053)
%11191 = "mhlo.broadcast_in_dim"(%11190) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11192 = mhlo.shift_left %11188, %11191 : tensor<1xui32> loc(#loc1055)
%11193 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1053)
%11194 = "mhlo.broadcast_in_dim"(%11193) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11195 = mhlo.shift_right_logical %11188, %11194 : tensor<1xui32> loc(#loc1043)
%11196 = mhlo.or %11192, %11195 : tensor<1xui32> loc(#loc1056)
%11197 = mhlo.xor %11189, %11196 : tensor<1xui32> loc(#loc1052)
%11198 = mhlo.add %11189, %11197 : tensor<1xui32> loc(#loc1054)
%11199 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1053)
%11200 = "mhlo.broadcast_in_dim"(%11199) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11201 = mhlo.shift_left %11197, %11200 : tensor<1xui32> loc(#loc1055)
%11202 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1053)
%11203 = "mhlo.broadcast_in_dim"(%11202) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11204 = mhlo.shift_right_logical %11197, %11203 : tensor<1xui32> loc(#loc1043)
%11205 = mhlo.or %11201, %11204 : tensor<1xui32> loc(#loc1056)
%11206 = mhlo.xor %11198, %11205 : tensor<1xui32> loc(#loc1052)
%11207 = mhlo.add %11198, %11206 : tensor<1xui32> loc(#loc1054)
%11208 = mhlo.constant dense<24> : tensor<ui32> loc(#loc1053)
%11209 = "mhlo.broadcast_in_dim"(%11208) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11210 = mhlo.shift_left %11206, %11209 : tensor<1xui32> loc(#loc1055)
%11211 = mhlo.constant dense<8> : tensor<ui32> loc(#loc1053)
%11212 = "mhlo.broadcast_in_dim"(%11211) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11213 = mhlo.shift_right_logical %11206, %11212 : tensor<1xui32> loc(#loc1043)
%11214 = mhlo.or %11210, %11213 : tensor<1xui32> loc(#loc1056)
%11215 = mhlo.xor %11207, %11214 : tensor<1xui32> loc(#loc1052)
%11216 = "mhlo.broadcast_in_dim"(%11132) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11217 = mhlo.add %11207, %11216 : tensor<1xui32> loc(#loc1054)
%11218 = "mhlo.broadcast_in_dim"(%11125) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11219 = mhlo.add %11215, %11218 : tensor<1xui32> loc(#loc1054)
%11220 = mhlo.constant dense<2> : tensor<ui32> loc(#loc1053)
%11221 = "mhlo.broadcast_in_dim"(%11220) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11222 = mhlo.add %11219, %11221 : tensor<1xui32> loc(#loc1054)
%11223 = mhlo.add %11217, %11222 : tensor<1xui32> loc(#loc1054)
%11224 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1053)
%11225 = "mhlo.broadcast_in_dim"(%11224) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11226 = mhlo.shift_left %11222, %11225 : tensor<1xui32> loc(#loc1055)
%11227 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1053)
%11228 = "mhlo.broadcast_in_dim"(%11227) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11229 = mhlo.shift_right_logical %11222, %11228 : tensor<1xui32> loc(#loc1043)
%11230 = mhlo.or %11226, %11229 : tensor<1xui32> loc(#loc1056)
%11231 = mhlo.xor %11223, %11230 : tensor<1xui32> loc(#loc1052)
%11232 = mhlo.add %11223, %11231 : tensor<1xui32> loc(#loc1054)
%11233 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1053)
%11234 = "mhlo.broadcast_in_dim"(%11233) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11235 = mhlo.shift_left %11231, %11234 : tensor<1xui32> loc(#loc1055)
%11236 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1053)
%11237 = "mhlo.broadcast_in_dim"(%11236) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11238 = mhlo.shift_right_logical %11231, %11237 : tensor<1xui32> loc(#loc1043)
%11239 = mhlo.or %11235, %11238 : tensor<1xui32> loc(#loc1056)
%11240 = mhlo.xor %11232, %11239 : tensor<1xui32> loc(#loc1052)
%11241 = mhlo.add %11232, %11240 : tensor<1xui32> loc(#loc1054)
%11242 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11243 = "mhlo.broadcast_in_dim"(%11242) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11244 = mhlo.shift_left %11240, %11243 : tensor<1xui32> loc(#loc1055)
%11245 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11246 = "mhlo.broadcast_in_dim"(%11245) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11247 = mhlo.shift_right_logical %11240, %11246 : tensor<1xui32> loc(#loc1043)
%11248 = mhlo.or %11244, %11247 : tensor<1xui32> loc(#loc1056)
%11249 = mhlo.xor %11241, %11248 : tensor<1xui32> loc(#loc1052)
%11250 = mhlo.add %11241, %11249 : tensor<1xui32> loc(#loc1054)
%11251 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11252 = "mhlo.broadcast_in_dim"(%11251) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11253 = mhlo.shift_left %11249, %11252 : tensor<1xui32> loc(#loc1055)
%11254 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11255 = "mhlo.broadcast_in_dim"(%11254) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11256 = mhlo.shift_right_logical %11249, %11255 : tensor<1xui32> loc(#loc1043)
%11257 = mhlo.or %11253, %11256 : tensor<1xui32> loc(#loc1056)
%11258 = mhlo.xor %11250, %11257 : tensor<1xui32> loc(#loc1052)
%11259 = "mhlo.broadcast_in_dim"(%11125) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11260 = mhlo.add %11250, %11259 : tensor<1xui32> loc(#loc1054)
%11261 = "mhlo.broadcast_in_dim"(%11127) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11262 = mhlo.add %11258, %11261 : tensor<1xui32> loc(#loc1054)
%11263 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1053)
%11264 = "mhlo.broadcast_in_dim"(%11263) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11265 = mhlo.add %11262, %11264 : tensor<1xui32> loc(#loc1054)
%11266 = mhlo.add %11260, %11265 : tensor<1xui32> loc(#loc1054)
%11267 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1053)
%11268 = "mhlo.broadcast_in_dim"(%11267) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11269 = mhlo.shift_left %11265, %11268 : tensor<1xui32> loc(#loc1055)
%11270 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1053)
%11271 = "mhlo.broadcast_in_dim"(%11270) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11272 = mhlo.shift_right_logical %11265, %11271 : tensor<1xui32> loc(#loc1043)
%11273 = mhlo.or %11269, %11272 : tensor<1xui32> loc(#loc1056)
%11274 = mhlo.xor %11266, %11273 : tensor<1xui32> loc(#loc1052)
%11275 = mhlo.add %11266, %11274 : tensor<1xui32> loc(#loc1054)
%11276 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1053)
%11277 = "mhlo.broadcast_in_dim"(%11276) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11278 = mhlo.shift_left %11274, %11277 : tensor<1xui32> loc(#loc1055)
%11279 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1053)
%11280 = "mhlo.broadcast_in_dim"(%11279) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11281 = mhlo.shift_right_logical %11274, %11280 : tensor<1xui32> loc(#loc1043)
%11282 = mhlo.or %11278, %11281 : tensor<1xui32> loc(#loc1056)
%11283 = mhlo.xor %11275, %11282 : tensor<1xui32> loc(#loc1052)
%11284 = mhlo.add %11275, %11283 : tensor<1xui32> loc(#loc1054)
%11285 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1053)
%11286 = "mhlo.broadcast_in_dim"(%11285) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11287 = mhlo.shift_left %11283, %11286 : tensor<1xui32> loc(#loc1055)
%11288 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1053)
%11289 = "mhlo.broadcast_in_dim"(%11288) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11290 = mhlo.shift_right_logical %11283, %11289 : tensor<1xui32> loc(#loc1043)
%11291 = mhlo.or %11287, %11290 : tensor<1xui32> loc(#loc1056)
%11292 = mhlo.xor %11284, %11291 : tensor<1xui32> loc(#loc1052)
%11293 = mhlo.add %11284, %11292 : tensor<1xui32> loc(#loc1054)
%11294 = mhlo.constant dense<24> : tensor<ui32> loc(#loc1053)
%11295 = "mhlo.broadcast_in_dim"(%11294) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11296 = mhlo.shift_left %11292, %11295 : tensor<1xui32> loc(#loc1055)
%11297 = mhlo.constant dense<8> : tensor<ui32> loc(#loc1053)
%11298 = "mhlo.broadcast_in_dim"(%11297) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11299 = mhlo.shift_right_logical %11292, %11298 : tensor<1xui32> loc(#loc1043)
%11300 = mhlo.or %11296, %11299 : tensor<1xui32> loc(#loc1056)
%11301 = mhlo.xor %11293, %11300 : tensor<1xui32> loc(#loc1052)
%11302 = "mhlo.broadcast_in_dim"(%11127) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11303 = mhlo.add %11293, %11302 : tensor<1xui32> loc(#loc1054)
%11304 = "mhlo.broadcast_in_dim"(%11132) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11305 = mhlo.add %11301, %11304 : tensor<1xui32> loc(#loc1054)
%11306 = mhlo.constant dense<4> : tensor<ui32> loc(#loc1053)
%11307 = "mhlo.broadcast_in_dim"(%11306) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11308 = mhlo.add %11305, %11307 : tensor<1xui32> loc(#loc1054)
%11309 = mhlo.add %11303, %11308 : tensor<1xui32> loc(#loc1054)
%11310 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1053)
%11311 = "mhlo.broadcast_in_dim"(%11310) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11312 = mhlo.shift_left %11308, %11311 : tensor<1xui32> loc(#loc1055)
%11313 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1053)
%11314 = "mhlo.broadcast_in_dim"(%11313) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11315 = mhlo.shift_right_logical %11308, %11314 : tensor<1xui32> loc(#loc1043)
%11316 = mhlo.or %11312, %11315 : tensor<1xui32> loc(#loc1056)
%11317 = mhlo.xor %11309, %11316 : tensor<1xui32> loc(#loc1052)
%11318 = mhlo.add %11309, %11317 : tensor<1xui32> loc(#loc1054)
%11319 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1053)
%11320 = "mhlo.broadcast_in_dim"(%11319) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11321 = mhlo.shift_left %11317, %11320 : tensor<1xui32> loc(#loc1055)
%11322 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1053)
%11323 = "mhlo.broadcast_in_dim"(%11322) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11324 = mhlo.shift_right_logical %11317, %11323 : tensor<1xui32> loc(#loc1043)
%11325 = mhlo.or %11321, %11324 : tensor<1xui32> loc(#loc1056)
%11326 = mhlo.xor %11318, %11325 : tensor<1xui32> loc(#loc1052)
%11327 = mhlo.add %11318, %11326 : tensor<1xui32> loc(#loc1054)
%11328 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11329 = "mhlo.broadcast_in_dim"(%11328) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11330 = mhlo.shift_left %11326, %11329 : tensor<1xui32> loc(#loc1055)
%11331 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11332 = "mhlo.broadcast_in_dim"(%11331) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11333 = mhlo.shift_right_logical %11326, %11332 : tensor<1xui32> loc(#loc1043)
%11334 = mhlo.or %11330, %11333 : tensor<1xui32> loc(#loc1056)
%11335 = mhlo.xor %11327, %11334 : tensor<1xui32> loc(#loc1052)
%11336 = mhlo.add %11327, %11335 : tensor<1xui32> loc(#loc1054)
%11337 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1053)
%11338 = "mhlo.broadcast_in_dim"(%11337) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1055)
%11339 = mhlo.shift_left %11335, %11338 : tensor<1xui32> loc(#loc1055)
%11340 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1053)
%11341 = "mhlo.broadcast_in_dim"(%11340) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1043)
%11342 = mhlo.shift_right_logical %11335, %11341 : tensor<1xui32> loc(#loc1043)
%11343 = mhlo.or %11339, %11342 : tensor<1xui32> loc(#loc1056)
%11344 = mhlo.xor %11336, %11343 : tensor<1xui32> loc(#loc1052)
%11345 = "mhlo.broadcast_in_dim"(%11132) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11346 = mhlo.add %11336, %11345 : tensor<1xui32> loc(#loc1054)
%11347 = "mhlo.broadcast_in_dim"(%11125) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11348 = mhlo.add %11344, %11347 : tensor<1xui32> loc(#loc1054)
%11349 = mhlo.constant dense<5> : tensor<ui32> loc(#loc1053)
%11350 = "mhlo.broadcast_in_dim"(%11349) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<1xui32> loc(#loc1054)
%11351 = mhlo.add %11348, %11350 : tensor<1xui32> loc(#loc1054)
%11352 = "mhlo.concatenate"(%11346, %11351) {dimension = 0 : i64} : (tensor<1xui32>, tensor<1xui32>) -> tensor<2xui32> loc(#loc1046)
%11353 = mhlo.constant dense<-0.99999994> : tensor<f32> loc(#loc531)
%11354 = "mhlo.broadcast_in_dim"(%11353) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc1057)
%11355 = mhlo.constant dense<1.000000e+00> : tensor<f32> loc(#loc531)
%11356 = "mhlo.broadcast_in_dim"(%11355) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<f32>) -> tensor<1x1xf32> loc(#loc1057)
%11357 = "mhlo.iota"() {iota_dimension = 0 : i64} : () -> tensor<8388608xui32> loc(#loc1058)
%11358 = "mhlo.slice"(%11352) {limit_indices = dense<1> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1059)
%11359 = "mhlo.reshape"(%11358) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1060)
%11360 = "mhlo.slice"(%11352) {limit_indices = dense<2> : tensor<1xi64>, start_indices = dense<1> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<2xui32>) -> tensor<1xui32> loc(#loc1061)
%11361 = "mhlo.reshape"(%11360) : (tensor<1xui32>) -> tensor<ui32> loc(#loc1060)
%11362 = "mhlo.slice"(%11357) {limit_indices = dense<4194304> : tensor<1xi64>, start_indices = dense<0> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc1062)
%11363 = "mhlo.slice"(%11357) {limit_indices = dense<8388608> : tensor<1xi64>, start_indices = dense<4194304> : tensor<1xi64>, strides = dense<1> : tensor<1xi64>} : (tensor<8388608xui32>) -> tensor<4194304xui32> loc(#loc1063)
%11364 = mhlo.xor %11359, %11361 : tensor<ui32> loc(#loc1064)
%11365 = mhlo.constant dense<466688986> : tensor<ui32> loc(#loc1065)
%11366 = mhlo.xor %11364, %11365 : tensor<ui32> loc(#loc1064)
%11367 = "mhlo.broadcast_in_dim"(%11359) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11368 = mhlo.add %11362, %11367 : tensor<4194304xui32> loc(#loc1066)
%11369 = "mhlo.broadcast_in_dim"(%11361) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11370 = mhlo.add %11363, %11369 : tensor<4194304xui32> loc(#loc1066)
%11371 = mhlo.add %11368, %11370 : tensor<4194304xui32> loc(#loc1066)
%11372 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1065)
%11373 = "mhlo.broadcast_in_dim"(%11372) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11374 = mhlo.shift_left %11370, %11373 : tensor<4194304xui32> loc(#loc1067)
%11375 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1065)
%11376 = "mhlo.broadcast_in_dim"(%11375) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11377 = mhlo.shift_right_logical %11370, %11376 : tensor<4194304xui32> loc(#loc1068)
%11378 = mhlo.or %11374, %11377 : tensor<4194304xui32> loc(#loc1069)
%11379 = mhlo.xor %11371, %11378 : tensor<4194304xui32> loc(#loc1064)
%11380 = mhlo.add %11371, %11379 : tensor<4194304xui32> loc(#loc1066)
%11381 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1065)
%11382 = "mhlo.broadcast_in_dim"(%11381) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11383 = mhlo.shift_left %11379, %11382 : tensor<4194304xui32> loc(#loc1067)
%11384 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1065)
%11385 = "mhlo.broadcast_in_dim"(%11384) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11386 = mhlo.shift_right_logical %11379, %11385 : tensor<4194304xui32> loc(#loc1068)
%11387 = mhlo.or %11383, %11386 : tensor<4194304xui32> loc(#loc1069)
%11388 = mhlo.xor %11380, %11387 : tensor<4194304xui32> loc(#loc1064)
%11389 = mhlo.add %11380, %11388 : tensor<4194304xui32> loc(#loc1066)
%11390 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1065)
%11391 = "mhlo.broadcast_in_dim"(%11390) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11392 = mhlo.shift_left %11388, %11391 : tensor<4194304xui32> loc(#loc1067)
%11393 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1065)
%11394 = "mhlo.broadcast_in_dim"(%11393) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11395 = mhlo.shift_right_logical %11388, %11394 : tensor<4194304xui32> loc(#loc1068)
%11396 = mhlo.or %11392, %11395 : tensor<4194304xui32> loc(#loc1069)
%11397 = mhlo.xor %11389, %11396 : tensor<4194304xui32> loc(#loc1064)
%11398 = mhlo.add %11389, %11397 : tensor<4194304xui32> loc(#loc1066)
%11399 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1065)
%11400 = "mhlo.broadcast_in_dim"(%11399) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11401 = mhlo.shift_left %11397, %11400 : tensor<4194304xui32> loc(#loc1067)
%11402 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1065)
%11403 = "mhlo.broadcast_in_dim"(%11402) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11404 = mhlo.shift_right_logical %11397, %11403 : tensor<4194304xui32> loc(#loc1068)
%11405 = mhlo.or %11401, %11404 : tensor<4194304xui32> loc(#loc1069)
%11406 = mhlo.xor %11398, %11405 : tensor<4194304xui32> loc(#loc1064)
%11407 = "mhlo.broadcast_in_dim"(%11361) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11408 = mhlo.add %11398, %11407 : tensor<4194304xui32> loc(#loc1066)
%11409 = "mhlo.broadcast_in_dim"(%11366) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11410 = mhlo.add %11406, %11409 : tensor<4194304xui32> loc(#loc1066)
%11411 = mhlo.constant dense<1> : tensor<ui32> loc(#loc1065)
%11412 = "mhlo.broadcast_in_dim"(%11411) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11413 = mhlo.add %11410, %11412 : tensor<4194304xui32> loc(#loc1066)
%11414 = mhlo.add %11408, %11413 : tensor<4194304xui32> loc(#loc1066)
%11415 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1065)
%11416 = "mhlo.broadcast_in_dim"(%11415) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11417 = mhlo.shift_left %11413, %11416 : tensor<4194304xui32> loc(#loc1067)
%11418 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1065)
%11419 = "mhlo.broadcast_in_dim"(%11418) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11420 = mhlo.shift_right_logical %11413, %11419 : tensor<4194304xui32> loc(#loc1068)
%11421 = mhlo.or %11417, %11420 : tensor<4194304xui32> loc(#loc1069)
%11422 = mhlo.xor %11414, %11421 : tensor<4194304xui32> loc(#loc1064)
%11423 = mhlo.add %11414, %11422 : tensor<4194304xui32> loc(#loc1066)
%11424 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1065)
%11425 = "mhlo.broadcast_in_dim"(%11424) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11426 = mhlo.shift_left %11422, %11425 : tensor<4194304xui32> loc(#loc1067)
%11427 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1065)
%11428 = "mhlo.broadcast_in_dim"(%11427) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11429 = mhlo.shift_right_logical %11422, %11428 : tensor<4194304xui32> loc(#loc1068)
%11430 = mhlo.or %11426, %11429 : tensor<4194304xui32> loc(#loc1069)
%11431 = mhlo.xor %11423, %11430 : tensor<4194304xui32> loc(#loc1064)
%11432 = mhlo.add %11423, %11431 : tensor<4194304xui32> loc(#loc1066)
%11433 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1065)
%11434 = "mhlo.broadcast_in_dim"(%11433) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11435 = mhlo.shift_left %11431, %11434 : tensor<4194304xui32> loc(#loc1067)
%11436 = mhlo.constant dense<16> : tensor<ui32> loc(#loc1065)
%11437 = "mhlo.broadcast_in_dim"(%11436) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11438 = mhlo.shift_right_logical %11431, %11437 : tensor<4194304xui32> loc(#loc1068)
%11439 = mhlo.or %11435, %11438 : tensor<4194304xui32> loc(#loc1069)
%11440 = mhlo.xor %11432, %11439 : tensor<4194304xui32> loc(#loc1064)
%11441 = mhlo.add %11432, %11440 : tensor<4194304xui32> loc(#loc1066)
%11442 = mhlo.constant dense<24> : tensor<ui32> loc(#loc1065)
%11443 = "mhlo.broadcast_in_dim"(%11442) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11444 = mhlo.shift_left %11440, %11443 : tensor<4194304xui32> loc(#loc1067)
%11445 = mhlo.constant dense<8> : tensor<ui32> loc(#loc1065)
%11446 = "mhlo.broadcast_in_dim"(%11445) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11447 = mhlo.shift_right_logical %11440, %11446 : tensor<4194304xui32> loc(#loc1068)
%11448 = mhlo.or %11444, %11447 : tensor<4194304xui32> loc(#loc1069)
%11449 = mhlo.xor %11441, %11448 : tensor<4194304xui32> loc(#loc1064)
%11450 = "mhlo.broadcast_in_dim"(%11366) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11451 = mhlo.add %11441, %11450 : tensor<4194304xui32> loc(#loc1066)
%11452 = "mhlo.broadcast_in_dim"(%11359) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11453 = mhlo.add %11449, %11452 : tensor<4194304xui32> loc(#loc1066)
%11454 = mhlo.constant dense<2> : tensor<ui32> loc(#loc1065)
%11455 = "mhlo.broadcast_in_dim"(%11454) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11456 = mhlo.add %11453, %11455 : tensor<4194304xui32> loc(#loc1066)
%11457 = mhlo.add %11451, %11456 : tensor<4194304xui32> loc(#loc1066)
%11458 = mhlo.constant dense<13> : tensor<ui32> loc(#loc1065)
%11459 = "mhlo.broadcast_in_dim"(%11458) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11460 = mhlo.shift_left %11456, %11459 : tensor<4194304xui32> loc(#loc1067)
%11461 = mhlo.constant dense<19> : tensor<ui32> loc(#loc1065)
%11462 = "mhlo.broadcast_in_dim"(%11461) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11463 = mhlo.shift_right_logical %11456, %11462 : tensor<4194304xui32> loc(#loc1068)
%11464 = mhlo.or %11460, %11463 : tensor<4194304xui32> loc(#loc1069)
%11465 = mhlo.xor %11457, %11464 : tensor<4194304xui32> loc(#loc1064)
%11466 = mhlo.add %11457, %11465 : tensor<4194304xui32> loc(#loc1066)
%11467 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1065)
%11468 = "mhlo.broadcast_in_dim"(%11467) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11469 = mhlo.shift_left %11465, %11468 : tensor<4194304xui32> loc(#loc1067)
%11470 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1065)
%11471 = "mhlo.broadcast_in_dim"(%11470) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11472 = mhlo.shift_right_logical %11465, %11471 : tensor<4194304xui32> loc(#loc1068)
%11473 = mhlo.or %11469, %11472 : tensor<4194304xui32> loc(#loc1069)
%11474 = mhlo.xor %11466, %11473 : tensor<4194304xui32> loc(#loc1064)
%11475 = mhlo.add %11466, %11474 : tensor<4194304xui32> loc(#loc1066)
%11476 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1065)
%11477 = "mhlo.broadcast_in_dim"(%11476) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11478 = mhlo.shift_left %11474, %11477 : tensor<4194304xui32> loc(#loc1067)
%11479 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1065)
%11480 = "mhlo.broadcast_in_dim"(%11479) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11481 = mhlo.shift_right_logical %11474, %11480 : tensor<4194304xui32> loc(#loc1068)
%11482 = mhlo.or %11478, %11481 : tensor<4194304xui32> loc(#loc1069)
%11483 = mhlo.xor %11475, %11482 : tensor<4194304xui32> loc(#loc1064)
%11484 = mhlo.add %11475, %11483 : tensor<4194304xui32> loc(#loc1066)
%11485 = mhlo.constant dense<6> : tensor<ui32> loc(#loc1065)
%11486 = "mhlo.broadcast_in_dim"(%11485) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11487 = mhlo.shift_left %11483, %11486 : tensor<4194304xui32> loc(#loc1067)
%11488 = mhlo.constant dense<26> : tensor<ui32> loc(#loc1065)
%11489 = "mhlo.broadcast_in_dim"(%11488) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11490 = mhlo.shift_right_logical %11483, %11489 : tensor<4194304xui32> loc(#loc1068)
%11491 = mhlo.or %11487, %11490 : tensor<4194304xui32> loc(#loc1069)
%11492 = mhlo.xor %11484, %11491 : tensor<4194304xui32> loc(#loc1064)
%11493 = "mhlo.broadcast_in_dim"(%11359) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11494 = mhlo.add %11484, %11493 : tensor<4194304xui32> loc(#loc1066)
%11495 = "mhlo.broadcast_in_dim"(%11361) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11496 = mhlo.add %11492, %11495 : tensor<4194304xui32> loc(#loc1066)
%11497 = mhlo.constant dense<3> : tensor<ui32> loc(#loc1065)
%11498 = "mhlo.broadcast_in_dim"(%11497) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1066)
%11499 = mhlo.add %11496, %11498 : tensor<4194304xui32> loc(#loc1066)
%11500 = mhlo.add %11494, %11499 : tensor<4194304xui32> loc(#loc1066)
%11501 = mhlo.constant dense<17> : tensor<ui32> loc(#loc1065)
%11502 = "mhlo.broadcast_in_dim"(%11501) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11503 = mhlo.shift_left %11499, %11502 : tensor<4194304xui32> loc(#loc1067)
%11504 = mhlo.constant dense<15> : tensor<ui32> loc(#loc1065)
%11505 = "mhlo.broadcast_in_dim"(%11504) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1068)
%11506 = mhlo.shift_right_logical %11499, %11505 : tensor<4194304xui32> loc(#loc1068)
%11507 = mhlo.or %11503, %11506 : tensor<4194304xui32> loc(#loc1069)
%11508 = mhlo.xor %11500, %11507 : tensor<4194304xui32> loc(#loc1064)
%11509 = mhlo.add %11500, %11508 : tensor<4194304xui32> loc(#loc1066)
%11510 = mhlo.constant dense<29> : tensor<ui32> loc(#loc1065)
%11511 = "mhlo.broadcast_in_dim"(%11510) {broadcast_dimensions = dense<> : tensor<0xi64>} : (tensor<ui32>) -> tensor<4194304xui32> loc(#loc1067)
%11512 = mhlo.shift_left %11508, %11511 : tensor<41943
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment