Skip to content

Instantly share code, notes, and snippets.

@stellaraccident

stellaraccident/mnist_train.mlir

Created November 24, 2021 22:22
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save stellaraccident/a87cb6d89f3c076d463585d18f751ae1 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save stellaraccident/a87cb6d89f3c076d463585d18f751ae1 to your computer and use it in GitHub Desktop.
Download ZIP
JAX Exported mnist Trainer/Predictor
Raw
mnist_train.mlir
This file has been truncated, but you can view the full file.
#map0 = affine_map<(d0) -> (d0)>
#map1 = affine_map<() -> ()>
#map2 = affine_map<(d0) -> ()>
#map3 = affine_map<(d0, d1) -> ()>
#map4 = affine_map<(d0, d1) -> (d0, d1)>
#map5 = affine_map<(d0, d1) -> (0, 0)>
#map6 = affine_map<(d0, d1) -> (d1)>
#map7 = affine_map<(d0, d1) -> (0, d1)>
#map8 = affine_map<(d0, d1) -> (d0)>
#map9 = affine_map<(d0, d1) -> (d0, 0)>
#map10 = affine_map<(d0, d1) -> (d1, d0)>
module {
iree_input.global private mutable @opt_state$0 : tensor<784x1024xf32>
iree_input.global private mutable @opt_state$1 : tensor<784x1024xf32>
iree_input.global private mutable @opt_state$2 : tensor<1024xf32>
iree_input.global private mutable @opt_state$3 : tensor<1024xf32>
iree_input.global private mutable @opt_state$4 : tensor<1024x1024xf32>
iree_input.global private mutable @opt_state$5 : tensor<1024x1024xf32>
iree_input.global private mutable @opt_state$6 : tensor<1024xf32>
iree_input.global private mutable @opt_state$7 : tensor<1024xf32>
iree_input.global private mutable @opt_state$8 : tensor<1024x10xf32>
iree_input.global private mutable @opt_state$9 : tensor<1024x10xf32>
iree_input.global private mutable @opt_state$10 : tensor<10xf32>
iree_input.global private mutable @opt_state$11 : tensor<10xf32>
func private @main(%arg0: tensor<2xi32>) -> (tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>) {
%c0_i32 = arith.constant 0 : i32
%cst = arith.constant dense<-1> : tensor<i32>
%cst_0 = arith.constant dense<1> : tensor<i32>
%cst_1 = arith.constant dense<0> : tensor<i32>
%cst_2 = arith.constant dense<false> : tensor<i1>
%cst_3 = arith.constant dense<2147483647> : tensor<i32>
%cst_4 = arith.constant dense<-2147483648> : tensor<i32>
%cst_5 = arith.constant dense<0x7FC00000> : tensor<f32>
%cst_6 = arith.constant dense<1.000000e+00> : tensor<10xf32>
%cst_7 = arith.constant dense<0x7F800000> : tensor<10xf32>
%cst_8 = arith.constant dense<5.000000e+00> : tensor<10xf32>
%cst_9 = arith.constant dense<1.50140941> : tensor<10xf32>
%cst_10 = arith.constant dense<2.83297682> : tensor<10xf32>
%cst_11 = arith.constant dense<0.246640727> : tensor<10xf32>
%cst_12 = arith.constant dense<1.00167406> : tensor<10xf32>
%cst_13 = arith.constant dense<-0.00417768164> : tensor<10xf32>
%cst_14 = arith.constant dense<0.00943887047> : tensor<10xf32>
%cst_15 = arith.constant dense<-0.00125372503> : tensor<10xf32>
%cst_16 = arith.constant dense<-0.0076224613> : tensor<10xf32>
%cst_17 = arith.constant dense<2.1858087E-4> : tensor<10xf32>
%cst_18 = arith.constant dense<0.00573950773> : tensor<10xf32>
%cst_19 = arith.constant dense<-4.39150654E-6> : tensor<10xf32>
%cst_20 = arith.constant dense<-0.00367342844> : tensor<10xf32>
%cst_21 = arith.constant dense<-3.5233877E-6> : tensor<10xf32>
%cst_22 = arith.constant dense<0.00134934322> : tensor<10xf32>
%cst_23 = arith.constant dense<3.43273939E-7> : tensor<10xf32>
%cst_24 = arith.constant dense<1.00950558E-4> : tensor<10xf32>
%cst_25 = arith.constant dense<2.81022636E-8> : tensor<10xf32>
%cst_26 = arith.constant dense<-2.00214257E-4> : tensor<10xf32>
%cst_27 = arith.constant dense<2.500000e+00> : tensor<10xf32>
%cst_28 = arith.constant dense<3.000000e+00> : tensor<10xf32>
%cst_29 = arith.constant dense<1.000000e+00> : tensor<1024x10xf32>
%cst_30 = arith.constant dense<0x7F800000> : tensor<1024x10xf32>
%cst_31 = arith.constant dense<5.000000e+00> : tensor<1024x10xf32>
%cst_32 = arith.constant dense<1.50140941> : tensor<1024x10xf32>
%cst_33 = arith.constant dense<2.83297682> : tensor<1024x10xf32>
%cst_34 = arith.constant dense<0.246640727> : tensor<1024x10xf32>
%cst_35 = arith.constant dense<1.00167406> : tensor<1024x10xf32>
%cst_36 = arith.constant dense<-0.00417768164> : tensor<1024x10xf32>
%cst_37 = arith.constant dense<0.00943887047> : tensor<1024x10xf32>
%cst_38 = arith.constant dense<-0.00125372503> : tensor<1024x10xf32>
%cst_39 = arith.constant dense<-0.0076224613> : tensor<1024x10xf32>
%cst_40 = arith.constant dense<2.1858087E-4> : tensor<1024x10xf32>
%cst_41 = arith.constant dense<0.00573950773> : tensor<1024x10xf32>
%cst_42 = arith.constant dense<-4.39150654E-6> : tensor<1024x10xf32>
%cst_43 = arith.constant dense<-0.00367342844> : tensor<1024x10xf32>
%cst_44 = arith.constant dense<-3.5233877E-6> : tensor<1024x10xf32>
%cst_45 = arith.constant dense<0.00134934322> : tensor<1024x10xf32>
%cst_46 = arith.constant dense<3.43273939E-7> : tensor<1024x10xf32>
%cst_47 = arith.constant dense<1.00950558E-4> : tensor<1024x10xf32>
%cst_48 = arith.constant dense<2.81022636E-8> : tensor<1024x10xf32>
%cst_49 = arith.constant dense<-2.00214257E-4> : tensor<1024x10xf32>
%cst_50 = arith.constant dense<2.500000e+00> : tensor<1024x10xf32>
%cst_51 = arith.constant dense<3.000000e+00> : tensor<1024x10xf32>
%cst_52 = arith.constant dense<-4.000000e+00> : tensor<f32>
%cst_53 = arith.constant dense<4.000000e+00> : tensor<f32>
%cst_54 = arith.constant dense<-2.72614237E-10> : tensor<f32>
%cst_55 = arith.constant dense<2.77068146E-8> : tensor<f32>
%cst_56 = arith.constant dense<-2.10102394E-6> : tensor<f32>
%cst_57 = arith.constant dense<-5.69250624E-5> : tensor<f32>
%cst_58 = arith.constant dense<-7.34990637E-4> : tensor<f32>
%cst_59 = arith.constant dense<-2.954600e-03> : tensor<f32>
%cst_60 = arith.constant dense<-0.0160960332> : tensor<f32>
%cst_61 = arith.constant dense<0.000000e+00> : tensor<f32>
%cst_62 = arith.constant dense<-1.45660715E-5> : tensor<f32>
%cst_63 = arith.constant dense<-2.13374049E-4> : tensor<f32>
%cst_64 = arith.constant dense<-0.00168282702> : tensor<f32>
%cst_65 = arith.constant dense<-0.00737332925> : tensor<f32>
%cst_66 = arith.constant dense<-0.0142647391> : tensor<f32>
%cst_67 = arith.constant dense<1.000000e+00> : tensor<1024xf32>
%cst_68 = arith.constant dense<0x7F800000> : tensor<1024xf32>
%cst_69 = arith.constant dense<5.000000e+00> : tensor<1024xf32>
%cst_70 = arith.constant dense<1.50140941> : tensor<1024xf32>
%cst_71 = arith.constant dense<2.83297682> : tensor<1024xf32>
%cst_72 = arith.constant dense<0.246640727> : tensor<1024xf32>
%cst_73 = arith.constant dense<1.00167406> : tensor<1024xf32>
%cst_74 = arith.constant dense<-0.00417768164> : tensor<1024xf32>
%cst_75 = arith.constant dense<0.00943887047> : tensor<1024xf32>
%cst_76 = arith.constant dense<-0.00125372503> : tensor<1024xf32>
%cst_77 = arith.constant dense<-0.0076224613> : tensor<1024xf32>
%cst_78 = arith.constant dense<2.1858087E-4> : tensor<1024xf32>
%cst_79 = arith.constant dense<0.00573950773> : tensor<1024xf32>
%cst_80 = arith.constant dense<-4.39150654E-6> : tensor<1024xf32>
%cst_81 = arith.constant dense<-0.00367342844> : tensor<1024xf32>
%cst_82 = arith.constant dense<-3.5233877E-6> : tensor<1024xf32>
%cst_83 = arith.constant dense<0.00134934322> : tensor<1024xf32>
%cst_84 = arith.constant dense<3.43273939E-7> : tensor<1024xf32>
%cst_85 = arith.constant dense<1.00950558E-4> : tensor<1024xf32>
%cst_86 = arith.constant dense<2.81022636E-8> : tensor<1024xf32>
%cst_87 = arith.constant dense<-2.00214257E-4> : tensor<1024xf32>
%cst_88 = arith.constant dense<2.500000e+00> : tensor<1024xf32>
%cst_89 = arith.constant dense<3.000000e+00> : tensor<1024xf32>
%cst_90 = arith.constant dense<1.000000e+00> : tensor<1024x1024xf32>
%cst_91 = arith.constant dense<0x7F800000> : tensor<1024x1024xf32>
%cst_92 = arith.constant dense<5.000000e+00> : tensor<1024x1024xf32>
%cst_93 = arith.constant dense<1.50140941> : tensor<1024x1024xf32>
%cst_94 = arith.constant dense<2.83297682> : tensor<1024x1024xf32>
%cst_95 = arith.constant dense<0.246640727> : tensor<1024x1024xf32>
%cst_96 = arith.constant dense<1.00167406> : tensor<1024x1024xf32>
%cst_97 = arith.constant dense<-0.00417768164> : tensor<1024x1024xf32>
%cst_98 = arith.constant dense<0.00943887047> : tensor<1024x1024xf32>
%cst_99 = arith.constant dense<-0.00125372503> : tensor<1024x1024xf32>
%cst_100 = arith.constant dense<-0.0076224613> : tensor<1024x1024xf32>
%cst_101 = arith.constant dense<2.1858087E-4> : tensor<1024x1024xf32>
%cst_102 = arith.constant dense<0.00573950773> : tensor<1024x1024xf32>
%cst_103 = arith.constant dense<-4.39150654E-6> : tensor<1024x1024xf32>
%cst_104 = arith.constant dense<-0.00367342844> : tensor<1024x1024xf32>
%cst_105 = arith.constant dense<-3.5233877E-6> : tensor<1024x1024xf32>
%cst_106 = arith.constant dense<0.00134934322> : tensor<1024x1024xf32>
%cst_107 = arith.constant dense<3.43273939E-7> : tensor<1024x1024xf32>
%cst_108 = arith.constant dense<1.00950558E-4> : tensor<1024x1024xf32>
%cst_109 = arith.constant dense<2.81022636E-8> : tensor<1024x1024xf32>
%cst_110 = arith.constant dense<-2.00214257E-4> : tensor<1024x1024xf32>
%cst_111 = arith.constant dense<2.500000e+00> : tensor<1024x1024xf32>
%cst_112 = arith.constant dense<3.000000e+00> : tensor<1024x1024xf32>
%cst_113 = arith.constant dense<1.000000e+00> : tensor<784x1024xf32>
%cst_114 = arith.constant dense<0x7F800000> : tensor<784x1024xf32>
%cst_115 = arith.constant dense<5.000000e+00> : tensor<784x1024xf32>
%cst_116 = arith.constant dense<1.50140941> : tensor<784x1024xf32>
%cst_117 = arith.constant dense<2.83297682> : tensor<784x1024xf32>
%cst_118 = arith.constant dense<0.246640727> : tensor<784x1024xf32>
%cst_119 = arith.constant dense<1.00167406> : tensor<784x1024xf32>
%cst_120 = arith.constant dense<-0.00417768164> : tensor<784x1024xf32>
%cst_121 = arith.constant dense<0.00943887047> : tensor<784x1024xf32>
%cst_122 = arith.constant dense<-0.00125372503> : tensor<784x1024xf32>
%cst_123 = arith.constant dense<-0.0076224613> : tensor<784x1024xf32>
%cst_124 = arith.constant dense<2.1858087E-4> : tensor<784x1024xf32>
%cst_125 = arith.constant dense<0.00573950773> : tensor<784x1024xf32>
%cst_126 = arith.constant dense<-4.39150654E-6> : tensor<784x1024xf32>
%cst_127 = arith.constant dense<-0.00367342844> : tensor<784x1024xf32>
%cst_128 = arith.constant dense<-3.5233877E-6> : tensor<784x1024xf32>
%cst_129 = arith.constant dense<0.00134934322> : tensor<784x1024xf32>
%cst_130 = arith.constant dense<3.43273939E-7> : tensor<784x1024xf32>
%cst_131 = arith.constant dense<1.00950558E-4> : tensor<784x1024xf32>
%cst_132 = arith.constant dense<2.81022636E-8> : tensor<784x1024xf32>
%cst_133 = arith.constant dense<-2.00214257E-4> : tensor<784x1024xf32>
%cst_134 = arith.constant dense<2.500000e+00> : tensor<784x1024xf32>
%cst_135 = arith.constant dense<3.000000e+00> : tensor<784x1024xf32>
%cst_136 = arith.constant dense<1> : tensor<401408xi32>
%cst_137 = arith.constant dense<2> : tensor<401408xi32>
%cst_138 = arith.constant dense<29> : tensor<401408xi32>
%cst_139 = arith.constant dense<3> : tensor<401408xi32>
%cst_140 = arith.constant dense<16> : tensor<401408xi32>
%cst_141 = arith.constant dense<24> : tensor<401408xi32>
%cst_142 = arith.constant dense<8> : tensor<401408xi32>
%cst_143 = arith.constant dense<4> : tensor<401408xi32>
%cst_144 = arith.constant dense<13> : tensor<401408xi32>
%cst_145 = arith.constant dense<19> : tensor<401408xi32>
%cst_146 = arith.constant dense<15> : tensor<401408xi32>
%cst_147 = arith.constant dense<17> : tensor<401408xi32>
%cst_148 = arith.constant dense<6> : tensor<401408xi32>
%cst_149 = arith.constant dense<26> : tensor<401408xi32>
%cst_150 = arith.constant dense<5> : tensor<401408xi32>
%cst_151 = arith.constant dense<9> : tensor<784x1024xi32>
%cst_152 = arith.constant dense<1065353216> : tensor<784x1024xi32>
%cst_153 = arith.constant dense<1.41421354> : tensor<784x1024xf32>
%cst_154 = arith.constant dense<0.0378109738> : tensor<784x1024xf32>
%cst_155 = arith.constant dense<1> : tensor<524288xi32>
%cst_156 = arith.constant dense<2> : tensor<524288xi32>
%cst_157 = arith.constant dense<29> : tensor<524288xi32>
%cst_158 = arith.constant dense<3> : tensor<524288xi32>
%cst_159 = arith.constant dense<16> : tensor<524288xi32>
%cst_160 = arith.constant dense<24> : tensor<524288xi32>
%cst_161 = arith.constant dense<8> : tensor<524288xi32>
%cst_162 = arith.constant dense<4> : tensor<524288xi32>
%cst_163 = arith.constant dense<13> : tensor<524288xi32>
%cst_164 = arith.constant dense<19> : tensor<524288xi32>
%cst_165 = arith.constant dense<15> : tensor<524288xi32>
%cst_166 = arith.constant dense<17> : tensor<524288xi32>
%cst_167 = arith.constant dense<6> : tensor<524288xi32>
%cst_168 = arith.constant dense<26> : tensor<524288xi32>
%cst_169 = arith.constant dense<5> : tensor<524288xi32>
%cst_170 = arith.constant dense<9> : tensor<1024x1024xi32>
%cst_171 = arith.constant dense<1065353216> : tensor<1024x1024xi32>
%cst_172 = arith.constant dense<1.41421354> : tensor<1024x1024xf32>
%cst_173 = arith.constant dense<0.0355264768> : tensor<1024x1024xf32>
%cst_174 = arith.constant dense<1> : tensor<512xi32>
%cst_175 = arith.constant dense<2> : tensor<512xi32>
%cst_176 = arith.constant dense<29> : tensor<512xi32>
%cst_177 = arith.constant dense<3> : tensor<512xi32>
%cst_178 = arith.constant dense<16> : tensor<512xi32>
%cst_179 = arith.constant dense<24> : tensor<512xi32>
%cst_180 = arith.constant dense<8> : tensor<512xi32>
%cst_181 = arith.constant dense<4> : tensor<512xi32>
%cst_182 = arith.constant dense<13> : tensor<512xi32>
%cst_183 = arith.constant dense<19> : tensor<512xi32>
%cst_184 = arith.constant dense<15> : tensor<512xi32>
%cst_185 = arith.constant dense<17> : tensor<512xi32>
%cst_186 = arith.constant dense<6> : tensor<512xi32>
%cst_187 = arith.constant dense<26> : tensor<512xi32>
%cst_188 = arith.constant dense<5> : tensor<512xi32>
%cst_189 = arith.constant dense<9> : tensor<1024xi32>
%cst_190 = arith.constant dense<1065353216> : tensor<1024xi32>
%cst_191 = arith.constant dense<2.000000e+00> : tensor<1024xf32>
%cst_192 = arith.constant dense<-0.99999994> : tensor<1024xf32>
%cst_193 = arith.constant dense<1.41421354> : tensor<1024xf32>
%cst_194 = arith.constant dense<0.00999999977> : tensor<1024xf32>
%cst_195 = arith.constant dense<-1.41421354> : tensor<f32>
%cst_196 = arith.constant dense<1> : tensor<5120xi32>
%cst_197 = arith.constant dense<2> : tensor<5120xi32>
%cst_198 = arith.constant dense<29> : tensor<5120xi32>
%cst_199 = arith.constant dense<3> : tensor<5120xi32>
%cst_200 = arith.constant dense<16> : tensor<5120xi32>
%cst_201 = arith.constant dense<24> : tensor<5120xi32>
%cst_202 = arith.constant dense<8> : tensor<5120xi32>
%cst_203 = arith.constant dense<4> : tensor<5120xi32>
%cst_204 = arith.constant dense<13> : tensor<5120xi32>
%cst_205 = arith.constant dense<19> : tensor<5120xi32>
%cst_206 = arith.constant dense<15> : tensor<5120xi32>
%cst_207 = arith.constant dense<17> : tensor<5120xi32>
%cst_208 = arith.constant dense<6> : tensor<5120xi32>
%cst_209 = arith.constant dense<26> : tensor<5120xi32>
%cst_210 = arith.constant dense<5> : tensor<5120xi32>
%cst_211 = arith.constant dense<9> : tensor<1024x10xi32>
%cst_212 = arith.constant dense<1065353216> : tensor<1024x10xi32>
%cst_213 = arith.constant dense<1.41421354> : tensor<1024x10xf32>
%cst_214 = arith.constant dense<-2.000000e+00> : tensor<f32>
%cst_215 = arith.constant dense<0x7F800000> : tensor<f32>
%cst_216 = arith.constant dense<2.000000e+00> : tensor<f32>
%cst_217 = arith.constant dense<0xFF800000> : tensor<f32>
%cst_218 = arith.constant dense<0.0499984846> : tensor<1024x10xf32>
%cst_219 = arith.constant dense<1> : tensor<5xi32>
%cst_220 = arith.constant dense<2> : tensor<5xi32>
%cst_221 = arith.constant dense<29> : tensor<5xi32>
%cst_222 = arith.constant dense<3> : tensor<5xi32>
%cst_223 = arith.constant dense<16> : tensor<5xi32>
%cst_224 = arith.constant dense<24> : tensor<5xi32>
%cst_225 = arith.constant dense<8> : tensor<5xi32>
%cst_226 = arith.constant dense<4> : tensor<5xi32>
%cst_227 = arith.constant dense<13> : tensor<5xi32>
%cst_228 = arith.constant dense<19> : tensor<5xi32>
%cst_229 = arith.constant dense<15> : tensor<5xi32>
%cst_230 = arith.constant dense<17> : tensor<5xi32>
%cst_231 = arith.constant dense<6> : tensor<5xi32>
%cst_232 = arith.constant dense<26> : tensor<5xi32>
%cst_233 = arith.constant dense<5> : tensor<5xi32>
%cst_234 = arith.constant dense<9> : tensor<10xi32>
%cst_235 = arith.constant dense<1065353216> : tensor<10xi32>
%cst_236 = arith.constant dense<2.000000e+00> : tensor<10xf32>
%cst_237 = arith.constant dense<-0.99999994> : tensor<10xf32>
%cst_238 = arith.constant dense<1.41421354> : tensor<f32>
%cst_239 = arith.constant dense<1.41421354> : tensor<10xf32>
%cst_240 = arith.constant dense<0.00999999977> : tensor<10xf32>
%cst_241 = arith.constant dense<466688986> : tensor<i32>
%cst_242 = arith.constant dense<1> : tensor<2xi32>
%cst_243 = arith.constant dense<2> : tensor<2xi32>
%cst_244 = arith.constant dense<29> : tensor<2xi32>
%cst_245 = arith.constant dense<3> : tensor<2xi32>
%cst_246 = arith.constant dense<16> : tensor<2xi32>
%cst_247 = arith.constant dense<24> : tensor<2xi32>
%cst_248 = arith.constant dense<8> : tensor<2xi32>
%cst_249 = arith.constant dense<4> : tensor<2xi32>
%cst_250 = arith.constant dense<13> : tensor<2xi32>
%cst_251 = arith.constant dense<19> : tensor<2xi32>
%cst_252 = arith.constant dense<15> : tensor<2xi32>
%cst_253 = arith.constant dense<17> : tensor<2xi32>
%cst_254 = arith.constant dense<6> : tensor<2xi32>
%cst_255 = arith.constant dense<26> : tensor<2xi32>
%cst_256 = arith.constant dense<5> : tensor<2xi32>
%cst_257 = arith.constant dense<0.000000e+00> : tensor<784x1024xf32>
%cst_258 = arith.constant dense<0.000000e+00> : tensor<1024x1024xf32>
%cst_259 = arith.constant dense<0.000000e+00> : tensor<1024xf32>
%cst_260 = arith.constant dense<0.000000e+00> : tensor<1024x10xf32>
%cst_261 = arith.constant dense<0.000000e+00> : tensor<10xf32>
%0 = linalg.init_tensor [4] : tensor<4xi32>
%1 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%0 : tensor<4xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<4xi32>
%2 = tensor.extract_slice %arg0[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3 = linalg.tensor_collapse_shape %2 [] : tensor<1xi32> into tensor<i32>
%4 = tensor.extract_slice %arg0[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%5 = linalg.tensor_collapse_shape %4 [] : tensor<1xi32> into tensor<i32>
%6 = tensor.extract_slice %1[0] [2] [1] : tensor<4xi32> to tensor<2xi32>
%7 = tensor.extract_slice %1[2] [2] [1] : tensor<4xi32> to tensor<2xi32>
%8 = linalg.init_tensor [] : tensor<i32>
%9 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3, %5 : tensor<i32>, tensor<i32>) outs(%8 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%10 = linalg.init_tensor [] : tensor<i32>
%11 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%9, %cst_241 : tensor<i32>, tensor<i32>) outs(%10 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%12 = linalg.init_tensor [2] : tensor<2xi32>
%13 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3 : tensor<i32>) outs(%12 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%14 = linalg.init_tensor [2] : tensor<2xi32>
%15 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %13 : tensor<2xi32>, tensor<2xi32>) outs(%14 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%16 = linalg.init_tensor [2] : tensor<2xi32>
%17 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%5 : tensor<i32>) outs(%16 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%18 = linalg.init_tensor [2] : tensor<2xi32>
%19 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %17 : tensor<2xi32>, tensor<2xi32>) outs(%18 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%20 = linalg.init_tensor [2] : tensor<2xi32>
%21 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%15, %19 : tensor<2xi32>, tensor<2xi32>) outs(%20 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%22 = linalg.init_tensor [2] : tensor<2xi32>
%23 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%19, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%22 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%24 = linalg.init_tensor [2] : tensor<2xi32>
%25 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%19, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%24 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%26 = linalg.init_tensor [2] : tensor<2xi32>
%27 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%23, %25 : tensor<2xi32>, tensor<2xi32>) outs(%26 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%28 = linalg.init_tensor [2] : tensor<2xi32>
%29 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%21, %27 : tensor<2xi32>, tensor<2xi32>) outs(%28 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%30 = linalg.init_tensor [2] : tensor<2xi32>
%31 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%21, %29 : tensor<2xi32>, tensor<2xi32>) outs(%30 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%32 = linalg.init_tensor [2] : tensor<2xi32>
%33 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%29, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%32 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%34 = linalg.init_tensor [2] : tensor<2xi32>
%35 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%29, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%34 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%36 = linalg.init_tensor [2] : tensor<2xi32>
%37 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%33, %35 : tensor<2xi32>, tensor<2xi32>) outs(%36 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%38 = linalg.init_tensor [2] : tensor<2xi32>
%39 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%31, %37 : tensor<2xi32>, tensor<2xi32>) outs(%38 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%40 = linalg.init_tensor [2] : tensor<2xi32>
%41 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%31, %39 : tensor<2xi32>, tensor<2xi32>) outs(%40 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%42 = linalg.init_tensor [2] : tensor<2xi32>
%43 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%39, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%42 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%44 = linalg.init_tensor [2] : tensor<2xi32>
%45 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%39, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%44 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%46 = linalg.init_tensor [2] : tensor<2xi32>
%47 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%43, %45 : tensor<2xi32>, tensor<2xi32>) outs(%46 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%48 = linalg.init_tensor [2] : tensor<2xi32>
%49 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%41, %47 : tensor<2xi32>, tensor<2xi32>) outs(%48 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%50 = linalg.init_tensor [2] : tensor<2xi32>
%51 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%41, %49 : tensor<2xi32>, tensor<2xi32>) outs(%50 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%52 = linalg.init_tensor [2] : tensor<2xi32>
%53 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%49, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%52 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%54 = linalg.init_tensor [2] : tensor<2xi32>
%55 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%49, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%54 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%56 = linalg.init_tensor [2] : tensor<2xi32>
%57 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%53, %55 : tensor<2xi32>, tensor<2xi32>) outs(%56 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%58 = linalg.init_tensor [2] : tensor<2xi32>
%59 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%51, %57 : tensor<2xi32>, tensor<2xi32>) outs(%58 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%60 = linalg.init_tensor [2] : tensor<2xi32>
%61 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%51, %17 : tensor<2xi32>, tensor<2xi32>) outs(%60 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%62 = linalg.init_tensor [2] : tensor<2xi32>
%63 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%11 : tensor<i32>) outs(%62 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%64 = linalg.init_tensor [2] : tensor<2xi32>
%65 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%59, %63 : tensor<2xi32>, tensor<2xi32>) outs(%64 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%66 = linalg.init_tensor [2] : tensor<2xi32>
%67 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%65, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%66 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%68 = linalg.init_tensor [2] : tensor<2xi32>
%69 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%61, %67 : tensor<2xi32>, tensor<2xi32>) outs(%68 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%70 = linalg.init_tensor [2] : tensor<2xi32>
%71 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%67, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%70 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%72 = linalg.init_tensor [2] : tensor<2xi32>
%73 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%67, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%72 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%74 = linalg.init_tensor [2] : tensor<2xi32>
%75 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%71, %73 : tensor<2xi32>, tensor<2xi32>) outs(%74 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%76 = linalg.init_tensor [2] : tensor<2xi32>
%77 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%69, %75 : tensor<2xi32>, tensor<2xi32>) outs(%76 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%78 = linalg.init_tensor [2] : tensor<2xi32>
%79 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%69, %77 : tensor<2xi32>, tensor<2xi32>) outs(%78 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%80 = linalg.init_tensor [2] : tensor<2xi32>
%81 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%77, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%80 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%82 = linalg.init_tensor [2] : tensor<2xi32>
%83 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%77, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%82 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%84 = linalg.init_tensor [2] : tensor<2xi32>
%85 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%81, %83 : tensor<2xi32>, tensor<2xi32>) outs(%84 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%86 = linalg.init_tensor [2] : tensor<2xi32>
%87 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%79, %85 : tensor<2xi32>, tensor<2xi32>) outs(%86 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%88 = linalg.init_tensor [2] : tensor<2xi32>
%89 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%79, %87 : tensor<2xi32>, tensor<2xi32>) outs(%88 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%90 = linalg.init_tensor [2] : tensor<2xi32>
%91 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%87, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%90 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%92 = linalg.init_tensor [2] : tensor<2xi32>
%93 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%87, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%92 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%94 = linalg.init_tensor [2] : tensor<2xi32>
%95 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%91, %93 : tensor<2xi32>, tensor<2xi32>) outs(%94 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%96 = linalg.init_tensor [2] : tensor<2xi32>
%97 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%89, %95 : tensor<2xi32>, tensor<2xi32>) outs(%96 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%98 = linalg.init_tensor [2] : tensor<2xi32>
%99 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%89, %97 : tensor<2xi32>, tensor<2xi32>) outs(%98 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%100 = linalg.init_tensor [2] : tensor<2xi32>
%101 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%97, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%100 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%102 = linalg.init_tensor [2] : tensor<2xi32>
%103 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%97, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%102 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%104 = linalg.init_tensor [2] : tensor<2xi32>
%105 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%101, %103 : tensor<2xi32>, tensor<2xi32>) outs(%104 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%106 = linalg.init_tensor [2] : tensor<2xi32>
%107 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%99, %105 : tensor<2xi32>, tensor<2xi32>) outs(%106 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%108 = linalg.init_tensor [2] : tensor<2xi32>
%109 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%99, %63 : tensor<2xi32>, tensor<2xi32>) outs(%108 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%110 = linalg.init_tensor [2] : tensor<2xi32>
%111 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%107, %13 : tensor<2xi32>, tensor<2xi32>) outs(%110 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%112 = linalg.init_tensor [2] : tensor<2xi32>
%113 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%111, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%112 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%114 = linalg.init_tensor [2] : tensor<2xi32>
%115 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%109, %113 : tensor<2xi32>, tensor<2xi32>) outs(%114 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%116 = linalg.init_tensor [2] : tensor<2xi32>
%117 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%113, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%116 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%118 = linalg.init_tensor [2] : tensor<2xi32>
%119 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%113, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%118 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%120 = linalg.init_tensor [2] : tensor<2xi32>
%121 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%117, %119 : tensor<2xi32>, tensor<2xi32>) outs(%120 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%122 = linalg.init_tensor [2] : tensor<2xi32>
%123 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%115, %121 : tensor<2xi32>, tensor<2xi32>) outs(%122 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%124 = linalg.init_tensor [2] : tensor<2xi32>
%125 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%115, %123 : tensor<2xi32>, tensor<2xi32>) outs(%124 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%126 = linalg.init_tensor [2] : tensor<2xi32>
%127 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%123, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%126 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%128 = linalg.init_tensor [2] : tensor<2xi32>
%129 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%123, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%128 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%130 = linalg.init_tensor [2] : tensor<2xi32>
%131 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%127, %129 : tensor<2xi32>, tensor<2xi32>) outs(%130 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%132 = linalg.init_tensor [2] : tensor<2xi32>
%133 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%125, %131 : tensor<2xi32>, tensor<2xi32>) outs(%132 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%134 = linalg.init_tensor [2] : tensor<2xi32>
%135 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%125, %133 : tensor<2xi32>, tensor<2xi32>) outs(%134 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%136 = linalg.init_tensor [2] : tensor<2xi32>
%137 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%133, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%136 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%138 = linalg.init_tensor [2] : tensor<2xi32>
%139 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%133, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%138 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%140 = linalg.init_tensor [2] : tensor<2xi32>
%141 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%137, %139 : tensor<2xi32>, tensor<2xi32>) outs(%140 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%142 = linalg.init_tensor [2] : tensor<2xi32>
%143 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%135, %141 : tensor<2xi32>, tensor<2xi32>) outs(%142 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%144 = linalg.init_tensor [2] : tensor<2xi32>
%145 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%135, %143 : tensor<2xi32>, tensor<2xi32>) outs(%144 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%146 = linalg.init_tensor [2] : tensor<2xi32>
%147 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%143, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%146 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%148 = linalg.init_tensor [2] : tensor<2xi32>
%149 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%143, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%148 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%150 = linalg.init_tensor [2] : tensor<2xi32>
%151 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%147, %149 : tensor<2xi32>, tensor<2xi32>) outs(%150 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%152 = linalg.init_tensor [2] : tensor<2xi32>
%153 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%145, %151 : tensor<2xi32>, tensor<2xi32>) outs(%152 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%154 = linalg.init_tensor [2] : tensor<2xi32>
%155 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%145, %13 : tensor<2xi32>, tensor<2xi32>) outs(%154 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%156 = linalg.init_tensor [2] : tensor<2xi32>
%157 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%153, %17 : tensor<2xi32>, tensor<2xi32>) outs(%156 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%158 = linalg.init_tensor [2] : tensor<2xi32>
%159 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%157, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%158 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%160 = linalg.init_tensor [2] : tensor<2xi32>
%161 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%155, %159 : tensor<2xi32>, tensor<2xi32>) outs(%160 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%162 = linalg.init_tensor [2] : tensor<2xi32>
%163 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%159, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%162 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%164 = linalg.init_tensor [2] : tensor<2xi32>
%165 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%159, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%164 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%166 = linalg.init_tensor [2] : tensor<2xi32>
%167 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%163, %165 : tensor<2xi32>, tensor<2xi32>) outs(%166 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%168 = linalg.init_tensor [2] : tensor<2xi32>
%169 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%161, %167 : tensor<2xi32>, tensor<2xi32>) outs(%168 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%170 = linalg.init_tensor [2] : tensor<2xi32>
%171 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%161, %169 : tensor<2xi32>, tensor<2xi32>) outs(%170 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%172 = linalg.init_tensor [2] : tensor<2xi32>
%173 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%169, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%172 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%174 = linalg.init_tensor [2] : tensor<2xi32>
%175 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%169, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%174 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%176 = linalg.init_tensor [2] : tensor<2xi32>
%177 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%173, %175 : tensor<2xi32>, tensor<2xi32>) outs(%176 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%178 = linalg.init_tensor [2] : tensor<2xi32>
%179 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%171, %177 : tensor<2xi32>, tensor<2xi32>) outs(%178 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%180 = linalg.init_tensor [2] : tensor<2xi32>
%181 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%171, %179 : tensor<2xi32>, tensor<2xi32>) outs(%180 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%182 = linalg.init_tensor [2] : tensor<2xi32>
%183 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%179, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%182 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%184 = linalg.init_tensor [2] : tensor<2xi32>
%185 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%179, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%184 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%186 = linalg.init_tensor [2] : tensor<2xi32>
%187 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%183, %185 : tensor<2xi32>, tensor<2xi32>) outs(%186 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%188 = linalg.init_tensor [2] : tensor<2xi32>
%189 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%181, %187 : tensor<2xi32>, tensor<2xi32>) outs(%188 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%190 = linalg.init_tensor [2] : tensor<2xi32>
%191 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%181, %189 : tensor<2xi32>, tensor<2xi32>) outs(%190 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%192 = linalg.init_tensor [2] : tensor<2xi32>
%193 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%189, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%192 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%194 = linalg.init_tensor [2] : tensor<2xi32>
%195 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%189, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%194 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%196 = linalg.init_tensor [2] : tensor<2xi32>
%197 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%193, %195 : tensor<2xi32>, tensor<2xi32>) outs(%196 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%198 = linalg.init_tensor [2] : tensor<2xi32>
%199 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%191, %197 : tensor<2xi32>, tensor<2xi32>) outs(%198 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%200 = linalg.init_tensor [2] : tensor<2xi32>
%201 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%191, %17 : tensor<2xi32>, tensor<2xi32>) outs(%200 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%202 = linalg.init_tensor [2] : tensor<2xi32>
%203 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%199, %63 : tensor<2xi32>, tensor<2xi32>) outs(%202 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%204 = linalg.init_tensor [2] : tensor<2xi32>
%205 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%203, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%204 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%206 = linalg.init_tensor [2] : tensor<2xi32>
%207 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%201, %205 : tensor<2xi32>, tensor<2xi32>) outs(%206 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%208 = linalg.init_tensor [2] : tensor<2xi32>
%209 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%205, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%208 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%210 = linalg.init_tensor [2] : tensor<2xi32>
%211 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%205, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%210 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%212 = linalg.init_tensor [2] : tensor<2xi32>
%213 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%209, %211 : tensor<2xi32>, tensor<2xi32>) outs(%212 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%214 = linalg.init_tensor [2] : tensor<2xi32>
%215 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%207, %213 : tensor<2xi32>, tensor<2xi32>) outs(%214 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%216 = linalg.init_tensor [2] : tensor<2xi32>
%217 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%207, %215 : tensor<2xi32>, tensor<2xi32>) outs(%216 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%218 = linalg.init_tensor [2] : tensor<2xi32>
%219 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%215, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%218 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%220 = linalg.init_tensor [2] : tensor<2xi32>
%221 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%215, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%220 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%222 = linalg.init_tensor [2] : tensor<2xi32>
%223 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%219, %221 : tensor<2xi32>, tensor<2xi32>) outs(%222 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%224 = linalg.init_tensor [2] : tensor<2xi32>
%225 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%217, %223 : tensor<2xi32>, tensor<2xi32>) outs(%224 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%226 = linalg.init_tensor [2] : tensor<2xi32>
%227 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%217, %225 : tensor<2xi32>, tensor<2xi32>) outs(%226 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%228 = linalg.init_tensor [2] : tensor<2xi32>
%229 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%225, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%228 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%230 = linalg.init_tensor [2] : tensor<2xi32>
%231 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%225, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%230 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%232 = linalg.init_tensor [2] : tensor<2xi32>
%233 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%229, %231 : tensor<2xi32>, tensor<2xi32>) outs(%232 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%234 = linalg.init_tensor [2] : tensor<2xi32>
%235 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%227, %233 : tensor<2xi32>, tensor<2xi32>) outs(%234 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%236 = linalg.init_tensor [2] : tensor<2xi32>
%237 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%227, %235 : tensor<2xi32>, tensor<2xi32>) outs(%236 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%238 = linalg.init_tensor [2] : tensor<2xi32>
%239 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%235, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%238 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%240 = linalg.init_tensor [2] : tensor<2xi32>
%241 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%235, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%240 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%242 = linalg.init_tensor [2] : tensor<2xi32>
%243 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%239, %241 : tensor<2xi32>, tensor<2xi32>) outs(%242 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%244 = linalg.init_tensor [2] : tensor<2xi32>
%245 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%237, %243 : tensor<2xi32>, tensor<2xi32>) outs(%244 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%246 = linalg.init_tensor [2] : tensor<2xi32>
%247 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%237, %63 : tensor<2xi32>, tensor<2xi32>) outs(%246 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%248 = linalg.init_tensor [2] : tensor<2xi32>
%249 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%245, %13 : tensor<2xi32>, tensor<2xi32>) outs(%248 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%250 = linalg.init_tensor [2] : tensor<2xi32>
%251 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%249, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%250 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%252 = linalg.init_tensor [4] : tensor<4xi32>
%253 = linalg.fill(%c0_i32, %252) : i32, tensor<4xi32> -> tensor<4xi32>
%254 = tensor.insert_slice %247 into %253[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%255 = tensor.insert_slice %251 into %254[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%256 = linalg.tensor_expand_shape %255 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%257 = tensor.extract_slice %256[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%258 = linalg.tensor_collapse_shape %257 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%259 = tensor.extract_slice %256[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%260 = linalg.tensor_collapse_shape %259 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%261 = tensor.extract_slice %260[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%262 = linalg.tensor_collapse_shape %261 [] : tensor<1xi32> into tensor<i32>
%263 = tensor.extract_slice %260[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%264 = linalg.tensor_collapse_shape %263 [] : tensor<1xi32> into tensor<i32>
%265 = linalg.init_tensor [] : tensor<i32>
%266 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%262, %264 : tensor<i32>, tensor<i32>) outs(%265 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%267 = linalg.init_tensor [] : tensor<i32>
%268 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%266, %cst_241 : tensor<i32>, tensor<i32>) outs(%267 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%269 = linalg.init_tensor [2] : tensor<2xi32>
%270 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%262 : tensor<i32>) outs(%269 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%271 = linalg.init_tensor [2] : tensor<2xi32>
%272 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %270 : tensor<2xi32>, tensor<2xi32>) outs(%271 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%273 = linalg.init_tensor [2] : tensor<2xi32>
%274 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%264 : tensor<i32>) outs(%273 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%275 = linalg.init_tensor [2] : tensor<2xi32>
%276 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %274 : tensor<2xi32>, tensor<2xi32>) outs(%275 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%277 = linalg.init_tensor [2] : tensor<2xi32>
%278 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%272, %276 : tensor<2xi32>, tensor<2xi32>) outs(%277 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%279 = linalg.init_tensor [2] : tensor<2xi32>
%280 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%276, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%279 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%281 = linalg.init_tensor [2] : tensor<2xi32>
%282 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%276, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%281 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%283 = linalg.init_tensor [2] : tensor<2xi32>
%284 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%280, %282 : tensor<2xi32>, tensor<2xi32>) outs(%283 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%285 = linalg.init_tensor [2] : tensor<2xi32>
%286 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%278, %284 : tensor<2xi32>, tensor<2xi32>) outs(%285 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%287 = linalg.init_tensor [2] : tensor<2xi32>
%288 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%278, %286 : tensor<2xi32>, tensor<2xi32>) outs(%287 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%289 = linalg.init_tensor [2] : tensor<2xi32>
%290 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%286, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%289 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%291 = linalg.init_tensor [2] : tensor<2xi32>
%292 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%286, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%291 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%293 = linalg.init_tensor [2] : tensor<2xi32>
%294 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%290, %292 : tensor<2xi32>, tensor<2xi32>) outs(%293 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%295 = linalg.init_tensor [2] : tensor<2xi32>
%296 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%288, %294 : tensor<2xi32>, tensor<2xi32>) outs(%295 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%297 = linalg.init_tensor [2] : tensor<2xi32>
%298 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%288, %296 : tensor<2xi32>, tensor<2xi32>) outs(%297 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%299 = linalg.init_tensor [2] : tensor<2xi32>
%300 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%296, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%299 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%301 = linalg.init_tensor [2] : tensor<2xi32>
%302 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%296, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%301 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%303 = linalg.init_tensor [2] : tensor<2xi32>
%304 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%300, %302 : tensor<2xi32>, tensor<2xi32>) outs(%303 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%305 = linalg.init_tensor [2] : tensor<2xi32>
%306 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%298, %304 : tensor<2xi32>, tensor<2xi32>) outs(%305 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%307 = linalg.init_tensor [2] : tensor<2xi32>
%308 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%298, %306 : tensor<2xi32>, tensor<2xi32>) outs(%307 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%309 = linalg.init_tensor [2] : tensor<2xi32>
%310 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%306, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%309 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%311 = linalg.init_tensor [2] : tensor<2xi32>
%312 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%306, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%311 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%313 = linalg.init_tensor [2] : tensor<2xi32>
%314 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%310, %312 : tensor<2xi32>, tensor<2xi32>) outs(%313 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%315 = linalg.init_tensor [2] : tensor<2xi32>
%316 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%308, %314 : tensor<2xi32>, tensor<2xi32>) outs(%315 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%317 = linalg.init_tensor [2] : tensor<2xi32>
%318 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%308, %274 : tensor<2xi32>, tensor<2xi32>) outs(%317 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%319 = linalg.init_tensor [2] : tensor<2xi32>
%320 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%268 : tensor<i32>) outs(%319 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%321 = linalg.init_tensor [2] : tensor<2xi32>
%322 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%316, %320 : tensor<2xi32>, tensor<2xi32>) outs(%321 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%323 = linalg.init_tensor [2] : tensor<2xi32>
%324 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%322, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%323 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%325 = linalg.init_tensor [2] : tensor<2xi32>
%326 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%318, %324 : tensor<2xi32>, tensor<2xi32>) outs(%325 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%327 = linalg.init_tensor [2] : tensor<2xi32>
%328 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%324, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%327 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%329 = linalg.init_tensor [2] : tensor<2xi32>
%330 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%324, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%329 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%331 = linalg.init_tensor [2] : tensor<2xi32>
%332 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%328, %330 : tensor<2xi32>, tensor<2xi32>) outs(%331 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%333 = linalg.init_tensor [2] : tensor<2xi32>
%334 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%326, %332 : tensor<2xi32>, tensor<2xi32>) outs(%333 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%335 = linalg.init_tensor [2] : tensor<2xi32>
%336 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%326, %334 : tensor<2xi32>, tensor<2xi32>) outs(%335 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%337 = linalg.init_tensor [2] : tensor<2xi32>
%338 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%334, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%337 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%339 = linalg.init_tensor [2] : tensor<2xi32>
%340 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%334, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%339 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%341 = linalg.init_tensor [2] : tensor<2xi32>
%342 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%338, %340 : tensor<2xi32>, tensor<2xi32>) outs(%341 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%343 = linalg.init_tensor [2] : tensor<2xi32>
%344 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%336, %342 : tensor<2xi32>, tensor<2xi32>) outs(%343 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%345 = linalg.init_tensor [2] : tensor<2xi32>
%346 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%336, %344 : tensor<2xi32>, tensor<2xi32>) outs(%345 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%347 = linalg.init_tensor [2] : tensor<2xi32>
%348 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%344, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%347 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%349 = linalg.init_tensor [2] : tensor<2xi32>
%350 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%344, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%349 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%351 = linalg.init_tensor [2] : tensor<2xi32>
%352 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%348, %350 : tensor<2xi32>, tensor<2xi32>) outs(%351 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%353 = linalg.init_tensor [2] : tensor<2xi32>
%354 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%346, %352 : tensor<2xi32>, tensor<2xi32>) outs(%353 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%355 = linalg.init_tensor [2] : tensor<2xi32>
%356 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%346, %354 : tensor<2xi32>, tensor<2xi32>) outs(%355 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%357 = linalg.init_tensor [2] : tensor<2xi32>
%358 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%354, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%357 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%359 = linalg.init_tensor [2] : tensor<2xi32>
%360 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%354, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%359 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%361 = linalg.init_tensor [2] : tensor<2xi32>
%362 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%358, %360 : tensor<2xi32>, tensor<2xi32>) outs(%361 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%363 = linalg.init_tensor [2] : tensor<2xi32>
%364 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%356, %362 : tensor<2xi32>, tensor<2xi32>) outs(%363 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%365 = linalg.init_tensor [2] : tensor<2xi32>
%366 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%356, %320 : tensor<2xi32>, tensor<2xi32>) outs(%365 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%367 = linalg.init_tensor [2] : tensor<2xi32>
%368 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%364, %270 : tensor<2xi32>, tensor<2xi32>) outs(%367 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%369 = linalg.init_tensor [2] : tensor<2xi32>
%370 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%368, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%369 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%371 = linalg.init_tensor [2] : tensor<2xi32>
%372 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%366, %370 : tensor<2xi32>, tensor<2xi32>) outs(%371 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%373 = linalg.init_tensor [2] : tensor<2xi32>
%374 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%370, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%373 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%375 = linalg.init_tensor [2] : tensor<2xi32>
%376 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%370, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%375 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%377 = linalg.init_tensor [2] : tensor<2xi32>
%378 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%374, %376 : tensor<2xi32>, tensor<2xi32>) outs(%377 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%379 = linalg.init_tensor [2] : tensor<2xi32>
%380 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%372, %378 : tensor<2xi32>, tensor<2xi32>) outs(%379 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%381 = linalg.init_tensor [2] : tensor<2xi32>
%382 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%372, %380 : tensor<2xi32>, tensor<2xi32>) outs(%381 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%383 = linalg.init_tensor [2] : tensor<2xi32>
%384 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%380, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%383 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%385 = linalg.init_tensor [2] : tensor<2xi32>
%386 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%380, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%385 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%387 = linalg.init_tensor [2] : tensor<2xi32>
%388 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%384, %386 : tensor<2xi32>, tensor<2xi32>) outs(%387 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%389 = linalg.init_tensor [2] : tensor<2xi32>
%390 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%382, %388 : tensor<2xi32>, tensor<2xi32>) outs(%389 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%391 = linalg.init_tensor [2] : tensor<2xi32>
%392 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%382, %390 : tensor<2xi32>, tensor<2xi32>) outs(%391 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%393 = linalg.init_tensor [2] : tensor<2xi32>
%394 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%390, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%393 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%395 = linalg.init_tensor [2] : tensor<2xi32>
%396 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%390, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%395 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%397 = linalg.init_tensor [2] : tensor<2xi32>
%398 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%394, %396 : tensor<2xi32>, tensor<2xi32>) outs(%397 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%399 = linalg.init_tensor [2] : tensor<2xi32>
%400 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%392, %398 : tensor<2xi32>, tensor<2xi32>) outs(%399 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%401 = linalg.init_tensor [2] : tensor<2xi32>
%402 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%392, %400 : tensor<2xi32>, tensor<2xi32>) outs(%401 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%403 = linalg.init_tensor [2] : tensor<2xi32>
%404 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%400, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%403 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%405 = linalg.init_tensor [2] : tensor<2xi32>
%406 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%400, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%405 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%407 = linalg.init_tensor [2] : tensor<2xi32>
%408 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%404, %406 : tensor<2xi32>, tensor<2xi32>) outs(%407 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%409 = linalg.init_tensor [2] : tensor<2xi32>
%410 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%402, %408 : tensor<2xi32>, tensor<2xi32>) outs(%409 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%411 = linalg.init_tensor [2] : tensor<2xi32>
%412 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%402, %270 : tensor<2xi32>, tensor<2xi32>) outs(%411 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%413 = linalg.init_tensor [2] : tensor<2xi32>
%414 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%410, %274 : tensor<2xi32>, tensor<2xi32>) outs(%413 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%415 = linalg.init_tensor [2] : tensor<2xi32>
%416 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%414, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%415 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%417 = linalg.init_tensor [2] : tensor<2xi32>
%418 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%412, %416 : tensor<2xi32>, tensor<2xi32>) outs(%417 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%419 = linalg.init_tensor [2] : tensor<2xi32>
%420 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%416, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%419 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%421 = linalg.init_tensor [2] : tensor<2xi32>
%422 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%416, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%421 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%423 = linalg.init_tensor [2] : tensor<2xi32>
%424 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%420, %422 : tensor<2xi32>, tensor<2xi32>) outs(%423 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%425 = linalg.init_tensor [2] : tensor<2xi32>
%426 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%418, %424 : tensor<2xi32>, tensor<2xi32>) outs(%425 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%427 = linalg.init_tensor [2] : tensor<2xi32>
%428 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%418, %426 : tensor<2xi32>, tensor<2xi32>) outs(%427 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%429 = linalg.init_tensor [2] : tensor<2xi32>
%430 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%426, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%429 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%431 = linalg.init_tensor [2] : tensor<2xi32>
%432 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%426, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%431 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%433 = linalg.init_tensor [2] : tensor<2xi32>
%434 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%430, %432 : tensor<2xi32>, tensor<2xi32>) outs(%433 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%435 = linalg.init_tensor [2] : tensor<2xi32>
%436 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%428, %434 : tensor<2xi32>, tensor<2xi32>) outs(%435 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%437 = linalg.init_tensor [2] : tensor<2xi32>
%438 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%428, %436 : tensor<2xi32>, tensor<2xi32>) outs(%437 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%439 = linalg.init_tensor [2] : tensor<2xi32>
%440 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%436, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%439 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%441 = linalg.init_tensor [2] : tensor<2xi32>
%442 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%436, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%441 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%443 = linalg.init_tensor [2] : tensor<2xi32>
%444 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%440, %442 : tensor<2xi32>, tensor<2xi32>) outs(%443 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%445 = linalg.init_tensor [2] : tensor<2xi32>
%446 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%438, %444 : tensor<2xi32>, tensor<2xi32>) outs(%445 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%447 = linalg.init_tensor [2] : tensor<2xi32>
%448 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%438, %446 : tensor<2xi32>, tensor<2xi32>) outs(%447 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%449 = linalg.init_tensor [2] : tensor<2xi32>
%450 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%446, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%449 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%451 = linalg.init_tensor [2] : tensor<2xi32>
%452 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%446, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%451 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%453 = linalg.init_tensor [2] : tensor<2xi32>
%454 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%450, %452 : tensor<2xi32>, tensor<2xi32>) outs(%453 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%455 = linalg.init_tensor [2] : tensor<2xi32>
%456 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%448, %454 : tensor<2xi32>, tensor<2xi32>) outs(%455 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%457 = linalg.init_tensor [2] : tensor<2xi32>
%458 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%448, %274 : tensor<2xi32>, tensor<2xi32>) outs(%457 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%459 = linalg.init_tensor [2] : tensor<2xi32>
%460 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%456, %320 : tensor<2xi32>, tensor<2xi32>) outs(%459 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%461 = linalg.init_tensor [2] : tensor<2xi32>
%462 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%460, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%461 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%463 = linalg.init_tensor [2] : tensor<2xi32>
%464 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%458, %462 : tensor<2xi32>, tensor<2xi32>) outs(%463 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%465 = linalg.init_tensor [2] : tensor<2xi32>
%466 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%462, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%465 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%467 = linalg.init_tensor [2] : tensor<2xi32>
%468 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%462, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%467 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%469 = linalg.init_tensor [2] : tensor<2xi32>
%470 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%466, %468 : tensor<2xi32>, tensor<2xi32>) outs(%469 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%471 = linalg.init_tensor [2] : tensor<2xi32>
%472 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%464, %470 : tensor<2xi32>, tensor<2xi32>) outs(%471 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%473 = linalg.init_tensor [2] : tensor<2xi32>
%474 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%464, %472 : tensor<2xi32>, tensor<2xi32>) outs(%473 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%475 = linalg.init_tensor [2] : tensor<2xi32>
%476 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%472, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%475 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%477 = linalg.init_tensor [2] : tensor<2xi32>
%478 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%472, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%477 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%479 = linalg.init_tensor [2] : tensor<2xi32>
%480 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%476, %478 : tensor<2xi32>, tensor<2xi32>) outs(%479 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%481 = linalg.init_tensor [2] : tensor<2xi32>
%482 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%474, %480 : tensor<2xi32>, tensor<2xi32>) outs(%481 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%483 = linalg.init_tensor [2] : tensor<2xi32>
%484 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%474, %482 : tensor<2xi32>, tensor<2xi32>) outs(%483 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%485 = linalg.init_tensor [2] : tensor<2xi32>
%486 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%482, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%485 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%487 = linalg.init_tensor [2] : tensor<2xi32>
%488 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%482, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%487 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%489 = linalg.init_tensor [2] : tensor<2xi32>
%490 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%486, %488 : tensor<2xi32>, tensor<2xi32>) outs(%489 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%491 = linalg.init_tensor [2] : tensor<2xi32>
%492 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%484, %490 : tensor<2xi32>, tensor<2xi32>) outs(%491 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%493 = linalg.init_tensor [2] : tensor<2xi32>
%494 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%484, %492 : tensor<2xi32>, tensor<2xi32>) outs(%493 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%495 = linalg.init_tensor [2] : tensor<2xi32>
%496 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%492, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%495 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%497 = linalg.init_tensor [2] : tensor<2xi32>
%498 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%492, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%497 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%499 = linalg.init_tensor [2] : tensor<2xi32>
%500 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%496, %498 : tensor<2xi32>, tensor<2xi32>) outs(%499 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%501 = linalg.init_tensor [2] : tensor<2xi32>
%502 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%494, %500 : tensor<2xi32>, tensor<2xi32>) outs(%501 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%503 = linalg.init_tensor [2] : tensor<2xi32>
%504 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%494, %320 : tensor<2xi32>, tensor<2xi32>) outs(%503 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%505 = linalg.init_tensor [2] : tensor<2xi32>
%506 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%502, %270 : tensor<2xi32>, tensor<2xi32>) outs(%505 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%507 = linalg.init_tensor [2] : tensor<2xi32>
%508 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%506, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%507 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%509 = linalg.init_tensor [4] : tensor<4xi32>
%510 = linalg.fill(%c0_i32, %509) : i32, tensor<4xi32> -> tensor<4xi32>
%511 = tensor.insert_slice %504 into %510[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%512 = tensor.insert_slice %508 into %511[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%513 = linalg.tensor_expand_shape %512 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%514 = tensor.extract_slice %513[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%515 = linalg.tensor_collapse_shape %514 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%516 = tensor.extract_slice %513[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%517 = linalg.tensor_collapse_shape %516 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%518 = linalg.init_tensor [] : tensor<f32>
%519 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_52, %cst_195, %cst_53 : tensor<f32>, tensor<f32>, tensor<f32>) outs(%518 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = arith.minf %arg2, %arg3 : f32
%4408 = arith.maxf %4407, %arg1 : f32
linalg.yield %4408 : f32
} -> tensor<f32>
%520 = linalg.init_tensor [] : tensor<f32>
%521 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%519 : tensor<f32>) outs(%520 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%522 = linalg.init_tensor [] : tensor<f32>
%523 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%521, %cst_61 : tensor<f32>, tensor<f32>) outs(%522 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%524 = linalg.init_tensor [] : tensor<f32>
%525 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%523, %cst_54 : tensor<f32>, tensor<f32>) outs(%524 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%526 = linalg.init_tensor [] : tensor<f32>
%527 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%525, %521 : tensor<f32>, tensor<f32>) outs(%526 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%528 = linalg.init_tensor [] : tensor<f32>
%529 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%527, %cst_55 : tensor<f32>, tensor<f32>) outs(%528 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%530 = linalg.init_tensor [] : tensor<f32>
%531 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%529, %521 : tensor<f32>, tensor<f32>) outs(%530 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%532 = linalg.init_tensor [] : tensor<f32>
%533 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%531, %cst_56 : tensor<f32>, tensor<f32>) outs(%532 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%534 = linalg.init_tensor [] : tensor<f32>
%535 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%533, %521 : tensor<f32>, tensor<f32>) outs(%534 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%536 = linalg.init_tensor [] : tensor<f32>
%537 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%535, %cst_57 : tensor<f32>, tensor<f32>) outs(%536 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%538 = linalg.init_tensor [] : tensor<f32>
%539 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%537, %521 : tensor<f32>, tensor<f32>) outs(%538 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%540 = linalg.init_tensor [] : tensor<f32>
%541 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%539, %cst_58 : tensor<f32>, tensor<f32>) outs(%540 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%542 = linalg.init_tensor [] : tensor<f32>
%543 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%541, %521 : tensor<f32>, tensor<f32>) outs(%542 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%544 = linalg.init_tensor [] : tensor<f32>
%545 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%543, %cst_59 : tensor<f32>, tensor<f32>) outs(%544 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%546 = linalg.init_tensor [] : tensor<f32>
%547 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%545, %521 : tensor<f32>, tensor<f32>) outs(%546 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%548 = linalg.init_tensor [] : tensor<f32>
%549 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%547, %cst_60 : tensor<f32>, tensor<f32>) outs(%548 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%550 = linalg.init_tensor [] : tensor<f32>
%551 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%519, %549 : tensor<f32>, tensor<f32>) outs(%550 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%552 = linalg.init_tensor [] : tensor<f32>
%553 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%523, %cst_62 : tensor<f32>, tensor<f32>) outs(%552 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%554 = linalg.init_tensor [] : tensor<f32>
%555 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%553, %521 : tensor<f32>, tensor<f32>) outs(%554 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%556 = linalg.init_tensor [] : tensor<f32>
%557 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%555, %cst_63 : tensor<f32>, tensor<f32>) outs(%556 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%558 = linalg.init_tensor [] : tensor<f32>
%559 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%557, %521 : tensor<f32>, tensor<f32>) outs(%558 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%560 = linalg.init_tensor [] : tensor<f32>
%561 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%559, %cst_64 : tensor<f32>, tensor<f32>) outs(%560 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%562 = linalg.init_tensor [] : tensor<f32>
%563 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%561, %521 : tensor<f32>, tensor<f32>) outs(%562 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%564 = linalg.init_tensor [] : tensor<f32>
%565 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%563, %cst_65 : tensor<f32>, tensor<f32>) outs(%564 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%566 = linalg.init_tensor [] : tensor<f32>
%567 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%565, %521 : tensor<f32>, tensor<f32>) outs(%566 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%568 = linalg.init_tensor [] : tensor<f32>
%569 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%567, %cst_66 : tensor<f32>, tensor<f32>) outs(%568 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%570 = linalg.init_tensor [] : tensor<f32>
%571 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%551, %569 : tensor<f32>, tensor<f32>) outs(%570 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.divf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%572 = linalg.init_tensor [] : tensor<f32>
%573 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_52, %cst_238, %cst_53 : tensor<f32>, tensor<f32>, tensor<f32>) outs(%572 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = arith.minf %arg2, %arg3 : f32
%4408 = arith.maxf %4407, %arg1 : f32
linalg.yield %4408 : f32
} -> tensor<f32>
%574 = linalg.init_tensor [] : tensor<f32>
%575 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%573 : tensor<f32>) outs(%574 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%576 = linalg.init_tensor [] : tensor<f32>
%577 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%575, %cst_61 : tensor<f32>, tensor<f32>) outs(%576 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%578 = linalg.init_tensor [] : tensor<f32>
%579 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%577, %cst_54 : tensor<f32>, tensor<f32>) outs(%578 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%580 = linalg.init_tensor [] : tensor<f32>
%581 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%579, %575 : tensor<f32>, tensor<f32>) outs(%580 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%582 = linalg.init_tensor [] : tensor<f32>
%583 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%581, %cst_55 : tensor<f32>, tensor<f32>) outs(%582 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%584 = linalg.init_tensor [] : tensor<f32>
%585 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%583, %575 : tensor<f32>, tensor<f32>) outs(%584 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%586 = linalg.init_tensor [] : tensor<f32>
%587 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%585, %cst_56 : tensor<f32>, tensor<f32>) outs(%586 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%588 = linalg.init_tensor [] : tensor<f32>
%589 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%587, %575 : tensor<f32>, tensor<f32>) outs(%588 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%590 = linalg.init_tensor [] : tensor<f32>
%591 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%589, %cst_57 : tensor<f32>, tensor<f32>) outs(%590 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%592 = linalg.init_tensor [] : tensor<f32>
%593 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%591, %575 : tensor<f32>, tensor<f32>) outs(%592 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%594 = linalg.init_tensor [] : tensor<f32>
%595 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%593, %cst_58 : tensor<f32>, tensor<f32>) outs(%594 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%596 = linalg.init_tensor [] : tensor<f32>
%597 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%595, %575 : tensor<f32>, tensor<f32>) outs(%596 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%598 = linalg.init_tensor [] : tensor<f32>
%599 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%597, %cst_59 : tensor<f32>, tensor<f32>) outs(%598 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%600 = linalg.init_tensor [] : tensor<f32>
%601 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%599, %575 : tensor<f32>, tensor<f32>) outs(%600 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%602 = linalg.init_tensor [] : tensor<f32>
%603 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%601, %cst_60 : tensor<f32>, tensor<f32>) outs(%602 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%604 = linalg.init_tensor [] : tensor<f32>
%605 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%573, %603 : tensor<f32>, tensor<f32>) outs(%604 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%606 = linalg.init_tensor [] : tensor<f32>
%607 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%577, %cst_62 : tensor<f32>, tensor<f32>) outs(%606 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%608 = linalg.init_tensor [] : tensor<f32>
%609 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%607, %575 : tensor<f32>, tensor<f32>) outs(%608 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%610 = linalg.init_tensor [] : tensor<f32>
%611 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%609, %cst_63 : tensor<f32>, tensor<f32>) outs(%610 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%612 = linalg.init_tensor [] : tensor<f32>
%613 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%611, %575 : tensor<f32>, tensor<f32>) outs(%612 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%614 = linalg.init_tensor [] : tensor<f32>
%615 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%613, %cst_64 : tensor<f32>, tensor<f32>) outs(%614 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%616 = linalg.init_tensor [] : tensor<f32>
%617 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%615, %575 : tensor<f32>, tensor<f32>) outs(%616 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%618 = linalg.init_tensor [] : tensor<f32>
%619 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%617, %cst_65 : tensor<f32>, tensor<f32>) outs(%618 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%620 = linalg.init_tensor [] : tensor<f32>
%621 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%619, %575 : tensor<f32>, tensor<f32>) outs(%620 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%622 = linalg.init_tensor [] : tensor<f32>
%623 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%621, %cst_66 : tensor<f32>, tensor<f32>) outs(%622 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%624 = linalg.init_tensor [] : tensor<f32>
%625 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%605, %623 : tensor<f32>, tensor<f32>) outs(%624 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.divf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%626 = linalg.init_tensor [1, 1] : tensor<1x1xf32>
%627 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%571 : tensor<f32>) outs(%626 : tensor<1x1xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1x1xf32>
%628 = linalg.init_tensor [802816] : tensor<802816xi32>
%629 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%628 : tensor<802816xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<802816xi32>
%630 = tensor.extract_slice %515[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%631 = linalg.tensor_collapse_shape %630 [] : tensor<1xi32> into tensor<i32>
%632 = tensor.extract_slice %515[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%633 = linalg.tensor_collapse_shape %632 [] : tensor<1xi32> into tensor<i32>
%634 = tensor.extract_slice %629[0] [401408] [1] : tensor<802816xi32> to tensor<401408xi32>
%635 = tensor.extract_slice %629[401408] [401408] [1] : tensor<802816xi32> to tensor<401408xi32>
%636 = linalg.init_tensor [] : tensor<i32>
%637 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%631, %633 : tensor<i32>, tensor<i32>) outs(%636 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%638 = linalg.init_tensor [] : tensor<i32>
%639 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%637, %cst_241 : tensor<i32>, tensor<i32>) outs(%638 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%640 = linalg.init_tensor [401408] : tensor<401408xi32>
%641 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%631 : tensor<i32>) outs(%640 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<401408xi32>
%642 = linalg.init_tensor [401408] : tensor<401408xi32>
%643 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%634, %641 : tensor<401408xi32>, tensor<401408xi32>) outs(%642 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%644 = linalg.init_tensor [401408] : tensor<401408xi32>
%645 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%633 : tensor<i32>) outs(%644 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<401408xi32>
%646 = linalg.init_tensor [401408] : tensor<401408xi32>
%647 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%635, %645 : tensor<401408xi32>, tensor<401408xi32>) outs(%646 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%648 = linalg.init_tensor [401408] : tensor<401408xi32>
%649 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%643, %647 : tensor<401408xi32>, tensor<401408xi32>) outs(%648 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%650 = linalg.init_tensor [401408] : tensor<401408xi32>
%651 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%647, %cst_144 : tensor<401408xi32>, tensor<401408xi32>) outs(%650 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%652 = linalg.init_tensor [401408] : tensor<401408xi32>
%653 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%647, %cst_145 : tensor<401408xi32>, tensor<401408xi32>) outs(%652 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%654 = linalg.init_tensor [401408] : tensor<401408xi32>
%655 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%651, %653 : tensor<401408xi32>, tensor<401408xi32>) outs(%654 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%656 = linalg.init_tensor [401408] : tensor<401408xi32>
%657 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%649, %655 : tensor<401408xi32>, tensor<401408xi32>) outs(%656 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%658 = linalg.init_tensor [401408] : tensor<401408xi32>
%659 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%649, %657 : tensor<401408xi32>, tensor<401408xi32>) outs(%658 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%660 = linalg.init_tensor [401408] : tensor<401408xi32>
%661 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%657, %cst_146 : tensor<401408xi32>, tensor<401408xi32>) outs(%660 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%662 = linalg.init_tensor [401408] : tensor<401408xi32>
%663 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%657, %cst_147 : tensor<401408xi32>, tensor<401408xi32>) outs(%662 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%664 = linalg.init_tensor [401408] : tensor<401408xi32>
%665 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%661, %663 : tensor<401408xi32>, tensor<401408xi32>) outs(%664 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%666 = linalg.init_tensor [401408] : tensor<401408xi32>
%667 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%659, %665 : tensor<401408xi32>, tensor<401408xi32>) outs(%666 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%668 = linalg.init_tensor [401408] : tensor<401408xi32>
%669 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%659, %667 : tensor<401408xi32>, tensor<401408xi32>) outs(%668 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%670 = linalg.init_tensor [401408] : tensor<401408xi32>
%671 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%667, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%670 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%672 = linalg.init_tensor [401408] : tensor<401408xi32>
%673 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%667, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%672 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%674 = linalg.init_tensor [401408] : tensor<401408xi32>
%675 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%671, %673 : tensor<401408xi32>, tensor<401408xi32>) outs(%674 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%676 = linalg.init_tensor [401408] : tensor<401408xi32>
%677 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%669, %675 : tensor<401408xi32>, tensor<401408xi32>) outs(%676 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%678 = linalg.init_tensor [401408] : tensor<401408xi32>
%679 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%669, %677 : tensor<401408xi32>, tensor<401408xi32>) outs(%678 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%680 = linalg.init_tensor [401408] : tensor<401408xi32>
%681 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%677, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%680 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%682 = linalg.init_tensor [401408] : tensor<401408xi32>
%683 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%677, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%682 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%684 = linalg.init_tensor [401408] : tensor<401408xi32>
%685 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%681, %683 : tensor<401408xi32>, tensor<401408xi32>) outs(%684 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%686 = linalg.init_tensor [401408] : tensor<401408xi32>
%687 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%679, %685 : tensor<401408xi32>, tensor<401408xi32>) outs(%686 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%688 = linalg.init_tensor [401408] : tensor<401408xi32>
%689 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%679, %645 : tensor<401408xi32>, tensor<401408xi32>) outs(%688 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%690 = linalg.init_tensor [401408] : tensor<401408xi32>
%691 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%639 : tensor<i32>) outs(%690 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<401408xi32>
%692 = linalg.init_tensor [401408] : tensor<401408xi32>
%693 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%687, %691 : tensor<401408xi32>, tensor<401408xi32>) outs(%692 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%694 = linalg.init_tensor [401408] : tensor<401408xi32>
%695 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%693, %cst_136 : tensor<401408xi32>, tensor<401408xi32>) outs(%694 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%696 = linalg.init_tensor [401408] : tensor<401408xi32>
%697 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%689, %695 : tensor<401408xi32>, tensor<401408xi32>) outs(%696 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%698 = linalg.init_tensor [401408] : tensor<401408xi32>
%699 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%695, %cst_147 : tensor<401408xi32>, tensor<401408xi32>) outs(%698 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%700 = linalg.init_tensor [401408] : tensor<401408xi32>
%701 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%695, %cst_146 : tensor<401408xi32>, tensor<401408xi32>) outs(%700 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%702 = linalg.init_tensor [401408] : tensor<401408xi32>
%703 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%699, %701 : tensor<401408xi32>, tensor<401408xi32>) outs(%702 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%704 = linalg.init_tensor [401408] : tensor<401408xi32>
%705 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%697, %703 : tensor<401408xi32>, tensor<401408xi32>) outs(%704 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%706 = linalg.init_tensor [401408] : tensor<401408xi32>
%707 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%697, %705 : tensor<401408xi32>, tensor<401408xi32>) outs(%706 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%708 = linalg.init_tensor [401408] : tensor<401408xi32>
%709 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%705, %cst_138 : tensor<401408xi32>, tensor<401408xi32>) outs(%708 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%710 = linalg.init_tensor [401408] : tensor<401408xi32>
%711 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%705, %cst_139 : tensor<401408xi32>, tensor<401408xi32>) outs(%710 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%712 = linalg.init_tensor [401408] : tensor<401408xi32>
%713 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%709, %711 : tensor<401408xi32>, tensor<401408xi32>) outs(%712 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%714 = linalg.init_tensor [401408] : tensor<401408xi32>
%715 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%707, %713 : tensor<401408xi32>, tensor<401408xi32>) outs(%714 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%716 = linalg.init_tensor [401408] : tensor<401408xi32>
%717 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%707, %715 : tensor<401408xi32>, tensor<401408xi32>) outs(%716 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%718 = linalg.init_tensor [401408] : tensor<401408xi32>
%719 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%715, %cst_140 : tensor<401408xi32>, tensor<401408xi32>) outs(%718 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%720 = linalg.init_tensor [401408] : tensor<401408xi32>
%721 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%715, %cst_140 : tensor<401408xi32>, tensor<401408xi32>) outs(%720 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%722 = linalg.init_tensor [401408] : tensor<401408xi32>
%723 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%719, %721 : tensor<401408xi32>, tensor<401408xi32>) outs(%722 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%724 = linalg.init_tensor [401408] : tensor<401408xi32>
%725 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%717, %723 : tensor<401408xi32>, tensor<401408xi32>) outs(%724 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%726 = linalg.init_tensor [401408] : tensor<401408xi32>
%727 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%717, %725 : tensor<401408xi32>, tensor<401408xi32>) outs(%726 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%728 = linalg.init_tensor [401408] : tensor<401408xi32>
%729 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%725, %cst_141 : tensor<401408xi32>, tensor<401408xi32>) outs(%728 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%730 = linalg.init_tensor [401408] : tensor<401408xi32>
%731 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%725, %cst_142 : tensor<401408xi32>, tensor<401408xi32>) outs(%730 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%732 = linalg.init_tensor [401408] : tensor<401408xi32>
%733 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%729, %731 : tensor<401408xi32>, tensor<401408xi32>) outs(%732 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%734 = linalg.init_tensor [401408] : tensor<401408xi32>
%735 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%727, %733 : tensor<401408xi32>, tensor<401408xi32>) outs(%734 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%736 = linalg.init_tensor [401408] : tensor<401408xi32>
%737 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%727, %691 : tensor<401408xi32>, tensor<401408xi32>) outs(%736 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%738 = linalg.init_tensor [401408] : tensor<401408xi32>
%739 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%735, %641 : tensor<401408xi32>, tensor<401408xi32>) outs(%738 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%740 = linalg.init_tensor [401408] : tensor<401408xi32>
%741 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%739, %cst_137 : tensor<401408xi32>, tensor<401408xi32>) outs(%740 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%742 = linalg.init_tensor [401408] : tensor<401408xi32>
%743 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%737, %741 : tensor<401408xi32>, tensor<401408xi32>) outs(%742 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%744 = linalg.init_tensor [401408] : tensor<401408xi32>
%745 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%741, %cst_144 : tensor<401408xi32>, tensor<401408xi32>) outs(%744 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%746 = linalg.init_tensor [401408] : tensor<401408xi32>
%747 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%741, %cst_145 : tensor<401408xi32>, tensor<401408xi32>) outs(%746 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%748 = linalg.init_tensor [401408] : tensor<401408xi32>
%749 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%745, %747 : tensor<401408xi32>, tensor<401408xi32>) outs(%748 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%750 = linalg.init_tensor [401408] : tensor<401408xi32>
%751 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%743, %749 : tensor<401408xi32>, tensor<401408xi32>) outs(%750 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%752 = linalg.init_tensor [401408] : tensor<401408xi32>
%753 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%743, %751 : tensor<401408xi32>, tensor<401408xi32>) outs(%752 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%754 = linalg.init_tensor [401408] : tensor<401408xi32>
%755 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%751, %cst_146 : tensor<401408xi32>, tensor<401408xi32>) outs(%754 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%756 = linalg.init_tensor [401408] : tensor<401408xi32>
%757 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%751, %cst_147 : tensor<401408xi32>, tensor<401408xi32>) outs(%756 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%758 = linalg.init_tensor [401408] : tensor<401408xi32>
%759 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%755, %757 : tensor<401408xi32>, tensor<401408xi32>) outs(%758 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%760 = linalg.init_tensor [401408] : tensor<401408xi32>
%761 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%753, %759 : tensor<401408xi32>, tensor<401408xi32>) outs(%760 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%762 = linalg.init_tensor [401408] : tensor<401408xi32>
%763 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%753, %761 : tensor<401408xi32>, tensor<401408xi32>) outs(%762 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%764 = linalg.init_tensor [401408] : tensor<401408xi32>
%765 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%761, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%764 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%766 = linalg.init_tensor [401408] : tensor<401408xi32>
%767 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%761, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%766 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%768 = linalg.init_tensor [401408] : tensor<401408xi32>
%769 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%765, %767 : tensor<401408xi32>, tensor<401408xi32>) outs(%768 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%770 = linalg.init_tensor [401408] : tensor<401408xi32>
%771 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%763, %769 : tensor<401408xi32>, tensor<401408xi32>) outs(%770 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%772 = linalg.init_tensor [401408] : tensor<401408xi32>
%773 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%763, %771 : tensor<401408xi32>, tensor<401408xi32>) outs(%772 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%774 = linalg.init_tensor [401408] : tensor<401408xi32>
%775 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%771, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%774 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%776 = linalg.init_tensor [401408] : tensor<401408xi32>
%777 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%771, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%776 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%778 = linalg.init_tensor [401408] : tensor<401408xi32>
%779 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%775, %777 : tensor<401408xi32>, tensor<401408xi32>) outs(%778 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%780 = linalg.init_tensor [401408] : tensor<401408xi32>
%781 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%773, %779 : tensor<401408xi32>, tensor<401408xi32>) outs(%780 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%782 = linalg.init_tensor [401408] : tensor<401408xi32>
%783 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%773, %641 : tensor<401408xi32>, tensor<401408xi32>) outs(%782 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%784 = linalg.init_tensor [401408] : tensor<401408xi32>
%785 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%781, %645 : tensor<401408xi32>, tensor<401408xi32>) outs(%784 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%786 = linalg.init_tensor [401408] : tensor<401408xi32>
%787 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%785, %cst_139 : tensor<401408xi32>, tensor<401408xi32>) outs(%786 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%788 = linalg.init_tensor [401408] : tensor<401408xi32>
%789 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%783, %787 : tensor<401408xi32>, tensor<401408xi32>) outs(%788 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%790 = linalg.init_tensor [401408] : tensor<401408xi32>
%791 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%787, %cst_147 : tensor<401408xi32>, tensor<401408xi32>) outs(%790 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%792 = linalg.init_tensor [401408] : tensor<401408xi32>
%793 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%787, %cst_146 : tensor<401408xi32>, tensor<401408xi32>) outs(%792 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%794 = linalg.init_tensor [401408] : tensor<401408xi32>
%795 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%791, %793 : tensor<401408xi32>, tensor<401408xi32>) outs(%794 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%796 = linalg.init_tensor [401408] : tensor<401408xi32>
%797 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%789, %795 : tensor<401408xi32>, tensor<401408xi32>) outs(%796 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%798 = linalg.init_tensor [401408] : tensor<401408xi32>
%799 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%789, %797 : tensor<401408xi32>, tensor<401408xi32>) outs(%798 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%800 = linalg.init_tensor [401408] : tensor<401408xi32>
%801 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%797, %cst_138 : tensor<401408xi32>, tensor<401408xi32>) outs(%800 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%802 = linalg.init_tensor [401408] : tensor<401408xi32>
%803 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%797, %cst_139 : tensor<401408xi32>, tensor<401408xi32>) outs(%802 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%804 = linalg.init_tensor [401408] : tensor<401408xi32>
%805 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%801, %803 : tensor<401408xi32>, tensor<401408xi32>) outs(%804 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%806 = linalg.init_tensor [401408] : tensor<401408xi32>
%807 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%799, %805 : tensor<401408xi32>, tensor<401408xi32>) outs(%806 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%808 = linalg.init_tensor [401408] : tensor<401408xi32>
%809 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%799, %807 : tensor<401408xi32>, tensor<401408xi32>) outs(%808 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%810 = linalg.init_tensor [401408] : tensor<401408xi32>
%811 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%807, %cst_140 : tensor<401408xi32>, tensor<401408xi32>) outs(%810 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%812 = linalg.init_tensor [401408] : tensor<401408xi32>
%813 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%807, %cst_140 : tensor<401408xi32>, tensor<401408xi32>) outs(%812 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%814 = linalg.init_tensor [401408] : tensor<401408xi32>
%815 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%811, %813 : tensor<401408xi32>, tensor<401408xi32>) outs(%814 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%816 = linalg.init_tensor [401408] : tensor<401408xi32>
%817 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%809, %815 : tensor<401408xi32>, tensor<401408xi32>) outs(%816 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%818 = linalg.init_tensor [401408] : tensor<401408xi32>
%819 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%809, %817 : tensor<401408xi32>, tensor<401408xi32>) outs(%818 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%820 = linalg.init_tensor [401408] : tensor<401408xi32>
%821 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%817, %cst_141 : tensor<401408xi32>, tensor<401408xi32>) outs(%820 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%822 = linalg.init_tensor [401408] : tensor<401408xi32>
%823 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%817, %cst_142 : tensor<401408xi32>, tensor<401408xi32>) outs(%822 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%824 = linalg.init_tensor [401408] : tensor<401408xi32>
%825 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%821, %823 : tensor<401408xi32>, tensor<401408xi32>) outs(%824 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%826 = linalg.init_tensor [401408] : tensor<401408xi32>
%827 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%819, %825 : tensor<401408xi32>, tensor<401408xi32>) outs(%826 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%828 = linalg.init_tensor [401408] : tensor<401408xi32>
%829 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%819, %645 : tensor<401408xi32>, tensor<401408xi32>) outs(%828 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%830 = linalg.init_tensor [401408] : tensor<401408xi32>
%831 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%827, %691 : tensor<401408xi32>, tensor<401408xi32>) outs(%830 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%832 = linalg.init_tensor [401408] : tensor<401408xi32>
%833 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%831, %cst_143 : tensor<401408xi32>, tensor<401408xi32>) outs(%832 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%834 = linalg.init_tensor [401408] : tensor<401408xi32>
%835 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%829, %833 : tensor<401408xi32>, tensor<401408xi32>) outs(%834 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%836 = linalg.init_tensor [401408] : tensor<401408xi32>
%837 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%833, %cst_144 : tensor<401408xi32>, tensor<401408xi32>) outs(%836 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%838 = linalg.init_tensor [401408] : tensor<401408xi32>
%839 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%833, %cst_145 : tensor<401408xi32>, tensor<401408xi32>) outs(%838 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%840 = linalg.init_tensor [401408] : tensor<401408xi32>
%841 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%837, %839 : tensor<401408xi32>, tensor<401408xi32>) outs(%840 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%842 = linalg.init_tensor [401408] : tensor<401408xi32>
%843 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%835, %841 : tensor<401408xi32>, tensor<401408xi32>) outs(%842 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%844 = linalg.init_tensor [401408] : tensor<401408xi32>
%845 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%835, %843 : tensor<401408xi32>, tensor<401408xi32>) outs(%844 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%846 = linalg.init_tensor [401408] : tensor<401408xi32>
%847 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%843, %cst_146 : tensor<401408xi32>, tensor<401408xi32>) outs(%846 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%848 = linalg.init_tensor [401408] : tensor<401408xi32>
%849 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%843, %cst_147 : tensor<401408xi32>, tensor<401408xi32>) outs(%848 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%850 = linalg.init_tensor [401408] : tensor<401408xi32>
%851 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%847, %849 : tensor<401408xi32>, tensor<401408xi32>) outs(%850 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%852 = linalg.init_tensor [401408] : tensor<401408xi32>
%853 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%845, %851 : tensor<401408xi32>, tensor<401408xi32>) outs(%852 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%854 = linalg.init_tensor [401408] : tensor<401408xi32>
%855 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%845, %853 : tensor<401408xi32>, tensor<401408xi32>) outs(%854 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%856 = linalg.init_tensor [401408] : tensor<401408xi32>
%857 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%853, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%856 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%858 = linalg.init_tensor [401408] : tensor<401408xi32>
%859 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%853, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%858 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%860 = linalg.init_tensor [401408] : tensor<401408xi32>
%861 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%857, %859 : tensor<401408xi32>, tensor<401408xi32>) outs(%860 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%862 = linalg.init_tensor [401408] : tensor<401408xi32>
%863 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%855, %861 : tensor<401408xi32>, tensor<401408xi32>) outs(%862 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%864 = linalg.init_tensor [401408] : tensor<401408xi32>
%865 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%855, %863 : tensor<401408xi32>, tensor<401408xi32>) outs(%864 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%866 = linalg.init_tensor [401408] : tensor<401408xi32>
%867 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%863, %cst_148 : tensor<401408xi32>, tensor<401408xi32>) outs(%866 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%868 = linalg.init_tensor [401408] : tensor<401408xi32>
%869 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%863, %cst_149 : tensor<401408xi32>, tensor<401408xi32>) outs(%868 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%870 = linalg.init_tensor [401408] : tensor<401408xi32>
%871 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%867, %869 : tensor<401408xi32>, tensor<401408xi32>) outs(%870 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%872 = linalg.init_tensor [401408] : tensor<401408xi32>
%873 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%865, %871 : tensor<401408xi32>, tensor<401408xi32>) outs(%872 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%874 = linalg.init_tensor [401408] : tensor<401408xi32>
%875 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%865, %691 : tensor<401408xi32>, tensor<401408xi32>) outs(%874 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%876 = linalg.init_tensor [401408] : tensor<401408xi32>
%877 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%873, %641 : tensor<401408xi32>, tensor<401408xi32>) outs(%876 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%878 = linalg.init_tensor [401408] : tensor<401408xi32>
%879 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%877, %cst_150 : tensor<401408xi32>, tensor<401408xi32>) outs(%878 : tensor<401408xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<401408xi32>
%880 = linalg.init_tensor [802816] : tensor<802816xi32>
%881 = linalg.fill(%c0_i32, %880) : i32, tensor<802816xi32> -> tensor<802816xi32>
%882 = tensor.insert_slice %875 into %881[0] [401408] [1] : tensor<401408xi32> into tensor<802816xi32>
%883 = tensor.insert_slice %879 into %882[401408] [401408] [1] : tensor<401408xi32> into tensor<802816xi32>
%884 = linalg.tensor_expand_shape %883 [[0, 1]] : tensor<802816xi32> into tensor<784x1024xi32>
%885 = linalg.init_tensor [784, 1024] : tensor<784x1024xi32>
%886 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%884, %cst_151 : tensor<784x1024xi32>, tensor<784x1024xi32>) outs(%885 : tensor<784x1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<784x1024xi32>
%887 = linalg.init_tensor [784, 1024] : tensor<784x1024xi32>
%888 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%886, %cst_152 : tensor<784x1024xi32>, tensor<784x1024xi32>) outs(%887 : tensor<784x1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<784x1024xi32>
%889 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%890 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%888 : tensor<784x1024xi32>) outs(%889 : tensor<784x1024xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%891 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%892 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%890, %cst_113 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%891 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%893 = linalg.init_tensor [] : tensor<f32>
%894 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%625, %571 : tensor<f32>, tensor<f32>) outs(%893 : tensor<f32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<f32>
%895 = linalg.init_tensor [1, 1] : tensor<1x1xf32>
%896 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%894 : tensor<f32>) outs(%895 : tensor<1x1xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1x1xf32>
%897 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%898 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%896 : tensor<1x1xf32>) outs(%897 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<784x1024xf32>
%899 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%900 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%892, %898 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%899 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%901 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%902 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%627 : tensor<1x1xf32>) outs(%901 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<784x1024xf32>
%903 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%904 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%900, %902 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%903 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%905 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%906 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%902, %904 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%905 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%907 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%908 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%906 : tensor<784x1024xf32>) outs(%907 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%909 = linalg.init_tensor [784, 1024] : tensor<784x1024xi1>
%910 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%908, %cst_113 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%909 : tensor<784x1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<784x1024xi1>
%911 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%912 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%906, %cst_114 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%911 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%913 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%914 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%906 : tensor<784x1024xf32>) outs(%913 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%915 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%916 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%914, %906 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%915 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%917 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%918 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%916, %cst_113 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%917 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%919 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%920 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%918 : tensor<784x1024xf32>) outs(%919 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%921 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%922 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%920 : tensor<784x1024xf32>) outs(%921 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%923 = linalg.init_tensor [784, 1024] : tensor<784x1024xi1>
%924 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%922, %cst_115 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%923 : tensor<784x1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<784x1024xi1>
%925 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%926 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_116, %cst_117 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%925 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%927 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%928 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_118, %cst_119 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%927 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%929 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%930 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_120, %cst_121 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%929 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%931 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%932 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_122, %cst_123 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%931 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%933 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%934 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_124, %cst_125 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%933 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%935 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%936 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_126, %cst_127 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%935 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%937 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%938 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_128, %cst_129 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%937 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%939 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%940 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_130, %cst_131 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%939 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%941 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%942 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %cst_132, %cst_133 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%941 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%943 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%944 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%922, %cst_134 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%943 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%945 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%946 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%922 : tensor<784x1024xf32>) outs(%945 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%947 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%948 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%946, %cst_135 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%947 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%949 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%950 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%924, %944, %948 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%949 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%951 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%952 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%942, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%951 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%953 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%954 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%940, %952 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%953 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%955 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%956 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%954, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%955 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%957 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%958 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%938, %956 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%957 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%959 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%960 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%958, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%959 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%961 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%962 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%936, %960 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%961 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%963 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%964 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%962, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%963 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%965 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%966 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%934, %964 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%965 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%967 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%968 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%966, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%967 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%969 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%970 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%932, %968 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%969 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%971 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%972 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%970, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%971 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%973 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%974 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%930, %972 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%973 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%975 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%976 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%974, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%975 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%977 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%978 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%928, %976 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%977 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%979 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%980 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%978, %950 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%979 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%981 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%982 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%926, %980 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%981 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%983 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%984 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%982, %906 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%983 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%985 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%986 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%910, %912, %984 : tensor<784x1024xi1>, tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%985 : tensor<784x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%987 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%988 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%986, %cst_153 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%987 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%989 = linalg.init_tensor [] : tensor<i32>
%990 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_214 : tensor<f32>) outs(%989 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%991 = linalg.init_tensor [] : tensor<i32>
%992 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_215 : tensor<f32>) outs(%991 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%993 = linalg.init_tensor [] : tensor<i32>
%994 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_5 : tensor<f32>) outs(%993 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%995 = linalg.init_tensor [] : tensor<i32>
%996 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%990, %cst_3 : tensor<i32>, tensor<i32>) outs(%995 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%997 = linalg.init_tensor [] : tensor<i32>
%998 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%992, %cst_3 : tensor<i32>, tensor<i32>) outs(%997 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%999 = linalg.init_tensor [] : tensor<i1>
%1000 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%996, %cst_1 : tensor<i32>, tensor<i32>) outs(%999 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi eq, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1001 = linalg.init_tensor [] : tensor<i1>
%1002 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%998, %cst_1 : tensor<i32>, tensor<i32>) outs(%1001 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi eq, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1003 = linalg.init_tensor [] : tensor<i32>
%1004 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%990, %cst_4 : tensor<i32>, tensor<i32>) outs(%1003 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1005 = linalg.init_tensor [] : tensor<i32>
%1006 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%992, %cst_4 : tensor<i32>, tensor<i32>) outs(%1005 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1007 = linalg.init_tensor [] : tensor<i32>
%1008 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1006, %cst_0 : tensor<i32>, tensor<i32>) outs(%1007 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1009 = linalg.init_tensor [] : tensor<i1>
%1010 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1004, %1006 : tensor<i32>, tensor<i32>) outs(%1009 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi ne, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1011 = linalg.init_tensor [] : tensor<i1>
%1012 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%996, %998 : tensor<i32>, tensor<i32>) outs(%1011 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi sgt, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1013 = linalg.init_tensor [] : tensor<i1>
%1014 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1012, %1010 : tensor<i1>, tensor<i1>) outs(%1013 : tensor<i1>) {
^bb0(%arg1: i1, %arg2: i1, %arg3: i1): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i1
linalg.yield %4407 : i1
} -> tensor<i1>
%1015 = linalg.init_tensor [] : tensor<i32>
%1016 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1014, %cst, %cst_0 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1015 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1017 = linalg.init_tensor [] : tensor<i32>
%1018 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%990, %1016 : tensor<i32>, tensor<i32>) outs(%1017 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1019 = linalg.init_tensor [] : tensor<i32>
%1020 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1002, %992, %1008 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1019 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1021 = linalg.init_tensor [] : tensor<i32>
%1022 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1000, %1020, %1018 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1021 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1023 = linalg.init_tensor [] : tensor<i32>
%1024 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_2, %992, %1022 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1023 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1025 = linalg.init_tensor [] : tensor<i32>
%1026 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_2, %994, %1024 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1025 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1027 = linalg.init_tensor [] : tensor<f32>
%1028 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%1026 : tensor<i32>) outs(%1027 : tensor<f32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<f32>
%1029 = linalg.init_tensor [] : tensor<i32>
%1030 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_216 : tensor<f32>) outs(%1029 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1031 = linalg.init_tensor [] : tensor<i32>
%1032 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_217 : tensor<f32>) outs(%1031 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1033 = linalg.init_tensor [] : tensor<i32>
%1034 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%cst_5 : tensor<f32>) outs(%1033 : tensor<i32>) {
^bb0(%arg1: f32, %arg2: i32): // no predecessors
%4407 = arith.bitcast %arg1 : f32 to i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1035 = linalg.init_tensor [] : tensor<i32>
%1036 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1030, %cst_3 : tensor<i32>, tensor<i32>) outs(%1035 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1037 = linalg.init_tensor [] : tensor<i32>
%1038 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1032, %cst_3 : tensor<i32>, tensor<i32>) outs(%1037 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1039 = linalg.init_tensor [] : tensor<i1>
%1040 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1036, %cst_1 : tensor<i32>, tensor<i32>) outs(%1039 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi eq, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1041 = linalg.init_tensor [] : tensor<i1>
%1042 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1038, %cst_1 : tensor<i32>, tensor<i32>) outs(%1041 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi eq, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1043 = linalg.init_tensor [] : tensor<i32>
%1044 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1030, %cst_4 : tensor<i32>, tensor<i32>) outs(%1043 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1045 = linalg.init_tensor [] : tensor<i32>
%1046 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1032, %cst_4 : tensor<i32>, tensor<i32>) outs(%1045 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.andi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1047 = linalg.init_tensor [] : tensor<i32>
%1048 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1046, %cst_0 : tensor<i32>, tensor<i32>) outs(%1047 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1049 = linalg.init_tensor [] : tensor<i1>
%1050 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1044, %1046 : tensor<i32>, tensor<i32>) outs(%1049 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi ne, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1051 = linalg.init_tensor [] : tensor<i1>
%1052 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1036, %1038 : tensor<i32>, tensor<i32>) outs(%1051 : tensor<i1>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i1): // no predecessors
%4407 = arith.cmpi sgt, %arg1, %arg2 : i32
linalg.yield %4407 : i1
} -> tensor<i1>
%1053 = linalg.init_tensor [] : tensor<i1>
%1054 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1052, %1050 : tensor<i1>, tensor<i1>) outs(%1053 : tensor<i1>) {
^bb0(%arg1: i1, %arg2: i1, %arg3: i1): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i1
linalg.yield %4407 : i1
} -> tensor<i1>
%1055 = linalg.init_tensor [] : tensor<i32>
%1056 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1054, %cst, %cst_0 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1055 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1057 = linalg.init_tensor [] : tensor<i32>
%1058 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1030, %1056 : tensor<i32>, tensor<i32>) outs(%1057 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1059 = linalg.init_tensor [] : tensor<i32>
%1060 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1042, %1032, %1048 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1059 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1061 = linalg.init_tensor [] : tensor<i32>
%1062 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%1040, %1060, %1058 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1061 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1063 = linalg.init_tensor [] : tensor<i32>
%1064 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_2, %1032, %1062 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1063 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1065 = linalg.init_tensor [] : tensor<i32>
%1066 = linalg.generic {indexing_maps = [#map1, #map1, #map1, #map1], iterator_types = []} ins(%cst_2, %1034, %1064 : tensor<i1>, tensor<i32>, tensor<i32>) outs(%1065 : tensor<i32>) {
^bb0(%arg1: i1, %arg2: i32, %arg3: i32, %arg4: i32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1067 = linalg.init_tensor [] : tensor<f32>
%1068 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = []} ins(%1066 : tensor<i32>) outs(%1067 : tensor<f32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<f32>
%1069 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%1070 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1028 : tensor<f32>) outs(%1069 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<784x1024xf32>
%1071 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%1072 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%1070, %988 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%1071 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%1073 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%1074 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1068 : tensor<f32>) outs(%1073 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<784x1024xf32>
%1075 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%1076 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%1074, %1072 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%1075 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.minf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%1077 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%1078 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%1076, %cst_154 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%1077 : tensor<784x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<784x1024xf32>
%1079 = linalg.init_tensor [1024] : tensor<1024xi32>
%1080 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%1079 : tensor<1024xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<1024xi32>
%1081 = tensor.extract_slice %517[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1082 = linalg.tensor_collapse_shape %1081 [] : tensor<1xi32> into tensor<i32>
%1083 = tensor.extract_slice %517[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1084 = linalg.tensor_collapse_shape %1083 [] : tensor<1xi32> into tensor<i32>
%1085 = tensor.extract_slice %1080[0] [512] [1] : tensor<1024xi32> to tensor<512xi32>
%1086 = tensor.extract_slice %1080[512] [512] [1] : tensor<1024xi32> to tensor<512xi32>
%1087 = linalg.init_tensor [] : tensor<i32>
%1088 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1082, %1084 : tensor<i32>, tensor<i32>) outs(%1087 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1089 = linalg.init_tensor [] : tensor<i32>
%1090 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1088, %cst_241 : tensor<i32>, tensor<i32>) outs(%1089 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1091 = linalg.init_tensor [512] : tensor<512xi32>
%1092 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1082 : tensor<i32>) outs(%1091 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%1093 = linalg.init_tensor [512] : tensor<512xi32>
%1094 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1085, %1092 : tensor<512xi32>, tensor<512xi32>) outs(%1093 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1095 = linalg.init_tensor [512] : tensor<512xi32>
%1096 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1084 : tensor<i32>) outs(%1095 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%1097 = linalg.init_tensor [512] : tensor<512xi32>
%1098 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1086, %1096 : tensor<512xi32>, tensor<512xi32>) outs(%1097 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1099 = linalg.init_tensor [512] : tensor<512xi32>
%1100 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1094, %1098 : tensor<512xi32>, tensor<512xi32>) outs(%1099 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1101 = linalg.init_tensor [512] : tensor<512xi32>
%1102 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1098, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%1101 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1103 = linalg.init_tensor [512] : tensor<512xi32>
%1104 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1098, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%1103 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1105 = linalg.init_tensor [512] : tensor<512xi32>
%1106 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1102, %1104 : tensor<512xi32>, tensor<512xi32>) outs(%1105 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1107 = linalg.init_tensor [512] : tensor<512xi32>
%1108 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1100, %1106 : tensor<512xi32>, tensor<512xi32>) outs(%1107 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1109 = linalg.init_tensor [512] : tensor<512xi32>
%1110 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1100, %1108 : tensor<512xi32>, tensor<512xi32>) outs(%1109 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1111 = linalg.init_tensor [512] : tensor<512xi32>
%1112 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1108, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%1111 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1113 = linalg.init_tensor [512] : tensor<512xi32>
%1114 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1108, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%1113 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1115 = linalg.init_tensor [512] : tensor<512xi32>
%1116 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1112, %1114 : tensor<512xi32>, tensor<512xi32>) outs(%1115 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1117 = linalg.init_tensor [512] : tensor<512xi32>
%1118 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1110, %1116 : tensor<512xi32>, tensor<512xi32>) outs(%1117 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1119 = linalg.init_tensor [512] : tensor<512xi32>
%1120 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1110, %1118 : tensor<512xi32>, tensor<512xi32>) outs(%1119 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1121 = linalg.init_tensor [512] : tensor<512xi32>
%1122 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1118, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1121 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1123 = linalg.init_tensor [512] : tensor<512xi32>
%1124 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1118, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1123 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1125 = linalg.init_tensor [512] : tensor<512xi32>
%1126 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1122, %1124 : tensor<512xi32>, tensor<512xi32>) outs(%1125 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1127 = linalg.init_tensor [512] : tensor<512xi32>
%1128 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1120, %1126 : tensor<512xi32>, tensor<512xi32>) outs(%1127 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1129 = linalg.init_tensor [512] : tensor<512xi32>
%1130 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1120, %1128 : tensor<512xi32>, tensor<512xi32>) outs(%1129 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1131 = linalg.init_tensor [512] : tensor<512xi32>
%1132 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1128, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1131 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1133 = linalg.init_tensor [512] : tensor<512xi32>
%1134 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1128, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1133 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1135 = linalg.init_tensor [512] : tensor<512xi32>
%1136 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1132, %1134 : tensor<512xi32>, tensor<512xi32>) outs(%1135 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1137 = linalg.init_tensor [512] : tensor<512xi32>
%1138 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1130, %1136 : tensor<512xi32>, tensor<512xi32>) outs(%1137 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1139 = linalg.init_tensor [512] : tensor<512xi32>
%1140 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1130, %1096 : tensor<512xi32>, tensor<512xi32>) outs(%1139 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1141 = linalg.init_tensor [512] : tensor<512xi32>
%1142 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1090 : tensor<i32>) outs(%1141 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%1143 = linalg.init_tensor [512] : tensor<512xi32>
%1144 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1138, %1142 : tensor<512xi32>, tensor<512xi32>) outs(%1143 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1145 = linalg.init_tensor [512] : tensor<512xi32>
%1146 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1144, %cst_174 : tensor<512xi32>, tensor<512xi32>) outs(%1145 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1147 = linalg.init_tensor [512] : tensor<512xi32>
%1148 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1140, %1146 : tensor<512xi32>, tensor<512xi32>) outs(%1147 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1149 = linalg.init_tensor [512] : tensor<512xi32>
%1150 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1146, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%1149 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1151 = linalg.init_tensor [512] : tensor<512xi32>
%1152 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1146, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%1151 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1153 = linalg.init_tensor [512] : tensor<512xi32>
%1154 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1150, %1152 : tensor<512xi32>, tensor<512xi32>) outs(%1153 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1155 = linalg.init_tensor [512] : tensor<512xi32>
%1156 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1148, %1154 : tensor<512xi32>, tensor<512xi32>) outs(%1155 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1157 = linalg.init_tensor [512] : tensor<512xi32>
%1158 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1148, %1156 : tensor<512xi32>, tensor<512xi32>) outs(%1157 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1159 = linalg.init_tensor [512] : tensor<512xi32>
%1160 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1156, %cst_176 : tensor<512xi32>, tensor<512xi32>) outs(%1159 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1161 = linalg.init_tensor [512] : tensor<512xi32>
%1162 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1156, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%1161 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1163 = linalg.init_tensor [512] : tensor<512xi32>
%1164 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1160, %1162 : tensor<512xi32>, tensor<512xi32>) outs(%1163 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1165 = linalg.init_tensor [512] : tensor<512xi32>
%1166 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1158, %1164 : tensor<512xi32>, tensor<512xi32>) outs(%1165 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1167 = linalg.init_tensor [512] : tensor<512xi32>
%1168 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1158, %1166 : tensor<512xi32>, tensor<512xi32>) outs(%1167 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1169 = linalg.init_tensor [512] : tensor<512xi32>
%1170 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1166, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%1169 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1171 = linalg.init_tensor [512] : tensor<512xi32>
%1172 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1166, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%1171 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1173 = linalg.init_tensor [512] : tensor<512xi32>
%1174 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1170, %1172 : tensor<512xi32>, tensor<512xi32>) outs(%1173 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1175 = linalg.init_tensor [512] : tensor<512xi32>
%1176 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1168, %1174 : tensor<512xi32>, tensor<512xi32>) outs(%1175 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1177 = linalg.init_tensor [512] : tensor<512xi32>
%1178 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1168, %1176 : tensor<512xi32>, tensor<512xi32>) outs(%1177 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1179 = linalg.init_tensor [512] : tensor<512xi32>
%1180 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1176, %cst_179 : tensor<512xi32>, tensor<512xi32>) outs(%1179 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1181 = linalg.init_tensor [512] : tensor<512xi32>
%1182 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1176, %cst_180 : tensor<512xi32>, tensor<512xi32>) outs(%1181 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1183 = linalg.init_tensor [512] : tensor<512xi32>
%1184 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1180, %1182 : tensor<512xi32>, tensor<512xi32>) outs(%1183 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1185 = linalg.init_tensor [512] : tensor<512xi32>
%1186 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1178, %1184 : tensor<512xi32>, tensor<512xi32>) outs(%1185 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1187 = linalg.init_tensor [512] : tensor<512xi32>
%1188 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1178, %1142 : tensor<512xi32>, tensor<512xi32>) outs(%1187 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1189 = linalg.init_tensor [512] : tensor<512xi32>
%1190 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1186, %1092 : tensor<512xi32>, tensor<512xi32>) outs(%1189 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1191 = linalg.init_tensor [512] : tensor<512xi32>
%1192 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1190, %cst_175 : tensor<512xi32>, tensor<512xi32>) outs(%1191 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1193 = linalg.init_tensor [512] : tensor<512xi32>
%1194 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1188, %1192 : tensor<512xi32>, tensor<512xi32>) outs(%1193 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1195 = linalg.init_tensor [512] : tensor<512xi32>
%1196 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1192, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%1195 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1197 = linalg.init_tensor [512] : tensor<512xi32>
%1198 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1192, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%1197 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1199 = linalg.init_tensor [512] : tensor<512xi32>
%1200 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1196, %1198 : tensor<512xi32>, tensor<512xi32>) outs(%1199 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1201 = linalg.init_tensor [512] : tensor<512xi32>
%1202 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1194, %1200 : tensor<512xi32>, tensor<512xi32>) outs(%1201 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1203 = linalg.init_tensor [512] : tensor<512xi32>
%1204 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1194, %1202 : tensor<512xi32>, tensor<512xi32>) outs(%1203 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1205 = linalg.init_tensor [512] : tensor<512xi32>
%1206 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1202, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%1205 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1207 = linalg.init_tensor [512] : tensor<512xi32>
%1208 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1202, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%1207 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1209 = linalg.init_tensor [512] : tensor<512xi32>
%1210 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1206, %1208 : tensor<512xi32>, tensor<512xi32>) outs(%1209 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1211 = linalg.init_tensor [512] : tensor<512xi32>
%1212 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1204, %1210 : tensor<512xi32>, tensor<512xi32>) outs(%1211 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1213 = linalg.init_tensor [512] : tensor<512xi32>
%1214 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1204, %1212 : tensor<512xi32>, tensor<512xi32>) outs(%1213 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1215 = linalg.init_tensor [512] : tensor<512xi32>
%1216 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1212, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1215 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1217 = linalg.init_tensor [512] : tensor<512xi32>
%1218 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1212, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1217 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1219 = linalg.init_tensor [512] : tensor<512xi32>
%1220 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1216, %1218 : tensor<512xi32>, tensor<512xi32>) outs(%1219 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1221 = linalg.init_tensor [512] : tensor<512xi32>
%1222 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1214, %1220 : tensor<512xi32>, tensor<512xi32>) outs(%1221 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1223 = linalg.init_tensor [512] : tensor<512xi32>
%1224 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1214, %1222 : tensor<512xi32>, tensor<512xi32>) outs(%1223 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1225 = linalg.init_tensor [512] : tensor<512xi32>
%1226 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1222, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1225 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1227 = linalg.init_tensor [512] : tensor<512xi32>
%1228 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1222, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1227 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1229 = linalg.init_tensor [512] : tensor<512xi32>
%1230 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1226, %1228 : tensor<512xi32>, tensor<512xi32>) outs(%1229 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1231 = linalg.init_tensor [512] : tensor<512xi32>
%1232 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1224, %1230 : tensor<512xi32>, tensor<512xi32>) outs(%1231 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1233 = linalg.init_tensor [512] : tensor<512xi32>
%1234 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1224, %1092 : tensor<512xi32>, tensor<512xi32>) outs(%1233 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1235 = linalg.init_tensor [512] : tensor<512xi32>
%1236 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1232, %1096 : tensor<512xi32>, tensor<512xi32>) outs(%1235 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1237 = linalg.init_tensor [512] : tensor<512xi32>
%1238 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1236, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%1237 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1239 = linalg.init_tensor [512] : tensor<512xi32>
%1240 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1234, %1238 : tensor<512xi32>, tensor<512xi32>) outs(%1239 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1241 = linalg.init_tensor [512] : tensor<512xi32>
%1242 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1238, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%1241 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1243 = linalg.init_tensor [512] : tensor<512xi32>
%1244 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1238, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%1243 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1245 = linalg.init_tensor [512] : tensor<512xi32>
%1246 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1242, %1244 : tensor<512xi32>, tensor<512xi32>) outs(%1245 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1247 = linalg.init_tensor [512] : tensor<512xi32>
%1248 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1240, %1246 : tensor<512xi32>, tensor<512xi32>) outs(%1247 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1249 = linalg.init_tensor [512] : tensor<512xi32>
%1250 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1240, %1248 : tensor<512xi32>, tensor<512xi32>) outs(%1249 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1251 = linalg.init_tensor [512] : tensor<512xi32>
%1252 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1248, %cst_176 : tensor<512xi32>, tensor<512xi32>) outs(%1251 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1253 = linalg.init_tensor [512] : tensor<512xi32>
%1254 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1248, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%1253 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1255 = linalg.init_tensor [512] : tensor<512xi32>
%1256 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1252, %1254 : tensor<512xi32>, tensor<512xi32>) outs(%1255 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1257 = linalg.init_tensor [512] : tensor<512xi32>
%1258 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1250, %1256 : tensor<512xi32>, tensor<512xi32>) outs(%1257 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1259 = linalg.init_tensor [512] : tensor<512xi32>
%1260 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1250, %1258 : tensor<512xi32>, tensor<512xi32>) outs(%1259 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1261 = linalg.init_tensor [512] : tensor<512xi32>
%1262 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1258, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%1261 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1263 = linalg.init_tensor [512] : tensor<512xi32>
%1264 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1258, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%1263 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1265 = linalg.init_tensor [512] : tensor<512xi32>
%1266 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1262, %1264 : tensor<512xi32>, tensor<512xi32>) outs(%1265 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1267 = linalg.init_tensor [512] : tensor<512xi32>
%1268 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1260, %1266 : tensor<512xi32>, tensor<512xi32>) outs(%1267 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1269 = linalg.init_tensor [512] : tensor<512xi32>
%1270 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1260, %1268 : tensor<512xi32>, tensor<512xi32>) outs(%1269 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1271 = linalg.init_tensor [512] : tensor<512xi32>
%1272 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1268, %cst_179 : tensor<512xi32>, tensor<512xi32>) outs(%1271 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1273 = linalg.init_tensor [512] : tensor<512xi32>
%1274 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1268, %cst_180 : tensor<512xi32>, tensor<512xi32>) outs(%1273 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1275 = linalg.init_tensor [512] : tensor<512xi32>
%1276 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1272, %1274 : tensor<512xi32>, tensor<512xi32>) outs(%1275 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1277 = linalg.init_tensor [512] : tensor<512xi32>
%1278 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1270, %1276 : tensor<512xi32>, tensor<512xi32>) outs(%1277 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1279 = linalg.init_tensor [512] : tensor<512xi32>
%1280 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1270, %1096 : tensor<512xi32>, tensor<512xi32>) outs(%1279 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1281 = linalg.init_tensor [512] : tensor<512xi32>
%1282 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1278, %1142 : tensor<512xi32>, tensor<512xi32>) outs(%1281 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1283 = linalg.init_tensor [512] : tensor<512xi32>
%1284 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1282, %cst_181 : tensor<512xi32>, tensor<512xi32>) outs(%1283 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1285 = linalg.init_tensor [512] : tensor<512xi32>
%1286 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1280, %1284 : tensor<512xi32>, tensor<512xi32>) outs(%1285 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1287 = linalg.init_tensor [512] : tensor<512xi32>
%1288 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1284, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%1287 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1289 = linalg.init_tensor [512] : tensor<512xi32>
%1290 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1284, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%1289 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1291 = linalg.init_tensor [512] : tensor<512xi32>
%1292 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1288, %1290 : tensor<512xi32>, tensor<512xi32>) outs(%1291 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1293 = linalg.init_tensor [512] : tensor<512xi32>
%1294 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1286, %1292 : tensor<512xi32>, tensor<512xi32>) outs(%1293 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1295 = linalg.init_tensor [512] : tensor<512xi32>
%1296 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1286, %1294 : tensor<512xi32>, tensor<512xi32>) outs(%1295 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1297 = linalg.init_tensor [512] : tensor<512xi32>
%1298 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1294, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%1297 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1299 = linalg.init_tensor [512] : tensor<512xi32>
%1300 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1294, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%1299 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1301 = linalg.init_tensor [512] : tensor<512xi32>
%1302 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1298, %1300 : tensor<512xi32>, tensor<512xi32>) outs(%1301 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1303 = linalg.init_tensor [512] : tensor<512xi32>
%1304 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1296, %1302 : tensor<512xi32>, tensor<512xi32>) outs(%1303 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1305 = linalg.init_tensor [512] : tensor<512xi32>
%1306 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1296, %1304 : tensor<512xi32>, tensor<512xi32>) outs(%1305 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1307 = linalg.init_tensor [512] : tensor<512xi32>
%1308 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1304, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1307 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1309 = linalg.init_tensor [512] : tensor<512xi32>
%1310 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1304, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1309 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1311 = linalg.init_tensor [512] : tensor<512xi32>
%1312 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1308, %1310 : tensor<512xi32>, tensor<512xi32>) outs(%1311 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1313 = linalg.init_tensor [512] : tensor<512xi32>
%1314 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1306, %1312 : tensor<512xi32>, tensor<512xi32>) outs(%1313 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1315 = linalg.init_tensor [512] : tensor<512xi32>
%1316 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1306, %1314 : tensor<512xi32>, tensor<512xi32>) outs(%1315 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1317 = linalg.init_tensor [512] : tensor<512xi32>
%1318 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1314, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%1317 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1319 = linalg.init_tensor [512] : tensor<512xi32>
%1320 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1314, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%1319 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1321 = linalg.init_tensor [512] : tensor<512xi32>
%1322 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1318, %1320 : tensor<512xi32>, tensor<512xi32>) outs(%1321 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1323 = linalg.init_tensor [512] : tensor<512xi32>
%1324 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1316, %1322 : tensor<512xi32>, tensor<512xi32>) outs(%1323 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1325 = linalg.init_tensor [512] : tensor<512xi32>
%1326 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1316, %1142 : tensor<512xi32>, tensor<512xi32>) outs(%1325 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1327 = linalg.init_tensor [512] : tensor<512xi32>
%1328 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1324, %1092 : tensor<512xi32>, tensor<512xi32>) outs(%1327 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1329 = linalg.init_tensor [512] : tensor<512xi32>
%1330 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1328, %cst_188 : tensor<512xi32>, tensor<512xi32>) outs(%1329 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%1331 = linalg.init_tensor [1024] : tensor<1024xi32>
%1332 = linalg.fill(%c0_i32, %1331) : i32, tensor<1024xi32> -> tensor<1024xi32>
%1333 = tensor.insert_slice %1326 into %1332[0] [512] [1] : tensor<512xi32> into tensor<1024xi32>
%1334 = tensor.insert_slice %1330 into %1333[512] [512] [1] : tensor<512xi32> into tensor<1024xi32>
%1335 = linalg.init_tensor [1024] : tensor<1024xi32>
%1336 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1334, %cst_189 : tensor<1024xi32>, tensor<1024xi32>) outs(%1335 : tensor<1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024xi32>
%1337 = linalg.init_tensor [1024] : tensor<1024xi32>
%1338 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1336, %cst_190 : tensor<1024xi32>, tensor<1024xi32>) outs(%1337 : tensor<1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024xi32>
%1339 = linalg.init_tensor [1024] : tensor<1024xf32>
%1340 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1338 : tensor<1024xi32>) outs(%1339 : tensor<1024xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1341 = linalg.init_tensor [1024] : tensor<1024xf32>
%1342 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1340, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%1341 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1343 = linalg.init_tensor [1024] : tensor<1024xf32>
%1344 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1342, %cst_191 : tensor<1024xf32>, tensor<1024xf32>) outs(%1343 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1345 = linalg.init_tensor [1024] : tensor<1024xf32>
%1346 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1344, %cst_192 : tensor<1024xf32>, tensor<1024xf32>) outs(%1345 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1347 = linalg.init_tensor [1024] : tensor<1024xf32>
%1348 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1346, %cst_192 : tensor<1024xf32>, tensor<1024xf32>) outs(%1347 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1349 = linalg.init_tensor [1024] : tensor<1024xf32>
%1350 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1348 : tensor<1024xf32>) outs(%1349 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1351 = linalg.init_tensor [1024] : tensor<1024xi1>
%1352 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1350, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%1351 : tensor<1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024xi1>
%1353 = linalg.init_tensor [1024] : tensor<1024xf32>
%1354 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1348, %cst_68 : tensor<1024xf32>, tensor<1024xf32>) outs(%1353 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1355 = linalg.init_tensor [1024] : tensor<1024xf32>
%1356 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1348 : tensor<1024xf32>) outs(%1355 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1357 = linalg.init_tensor [1024] : tensor<1024xf32>
%1358 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1356, %1348 : tensor<1024xf32>, tensor<1024xf32>) outs(%1357 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1359 = linalg.init_tensor [1024] : tensor<1024xf32>
%1360 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1358, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%1359 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1361 = linalg.init_tensor [1024] : tensor<1024xf32>
%1362 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1360 : tensor<1024xf32>) outs(%1361 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1363 = linalg.init_tensor [1024] : tensor<1024xf32>
%1364 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1362 : tensor<1024xf32>) outs(%1363 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1365 = linalg.init_tensor [1024] : tensor<1024xi1>
%1366 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1364, %cst_69 : tensor<1024xf32>, tensor<1024xf32>) outs(%1365 : tensor<1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024xi1>
%1367 = linalg.init_tensor [1024] : tensor<1024xf32>
%1368 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_70, %cst_71 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1367 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1369 = linalg.init_tensor [1024] : tensor<1024xf32>
%1370 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_72, %cst_73 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1369 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1371 = linalg.init_tensor [1024] : tensor<1024xf32>
%1372 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_74, %cst_75 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1371 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1373 = linalg.init_tensor [1024] : tensor<1024xf32>
%1374 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_76, %cst_77 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1373 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1375 = linalg.init_tensor [1024] : tensor<1024xf32>
%1376 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_78, %cst_79 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1375 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1377 = linalg.init_tensor [1024] : tensor<1024xf32>
%1378 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_80, %cst_81 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1377 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1379 = linalg.init_tensor [1024] : tensor<1024xf32>
%1380 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_82, %cst_83 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1379 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1381 = linalg.init_tensor [1024] : tensor<1024xf32>
%1382 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_84, %cst_85 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1381 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1383 = linalg.init_tensor [1024] : tensor<1024xf32>
%1384 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %cst_86, %cst_87 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1383 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1385 = linalg.init_tensor [1024] : tensor<1024xf32>
%1386 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1364, %cst_88 : tensor<1024xf32>, tensor<1024xf32>) outs(%1385 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1387 = linalg.init_tensor [1024] : tensor<1024xf32>
%1388 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%1364 : tensor<1024xf32>) outs(%1387 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1389 = linalg.init_tensor [1024] : tensor<1024xf32>
%1390 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1388, %cst_89 : tensor<1024xf32>, tensor<1024xf32>) outs(%1389 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1391 = linalg.init_tensor [1024] : tensor<1024xf32>
%1392 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1366, %1386, %1390 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1391 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1393 = linalg.init_tensor [1024] : tensor<1024xf32>
%1394 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1384, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1393 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1395 = linalg.init_tensor [1024] : tensor<1024xf32>
%1396 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1382, %1394 : tensor<1024xf32>, tensor<1024xf32>) outs(%1395 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1397 = linalg.init_tensor [1024] : tensor<1024xf32>
%1398 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1396, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1397 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1399 = linalg.init_tensor [1024] : tensor<1024xf32>
%1400 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1380, %1398 : tensor<1024xf32>, tensor<1024xf32>) outs(%1399 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1401 = linalg.init_tensor [1024] : tensor<1024xf32>
%1402 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1400, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1401 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1403 = linalg.init_tensor [1024] : tensor<1024xf32>
%1404 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1378, %1402 : tensor<1024xf32>, tensor<1024xf32>) outs(%1403 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1405 = linalg.init_tensor [1024] : tensor<1024xf32>
%1406 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1404, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1405 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1407 = linalg.init_tensor [1024] : tensor<1024xf32>
%1408 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1376, %1406 : tensor<1024xf32>, tensor<1024xf32>) outs(%1407 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1409 = linalg.init_tensor [1024] : tensor<1024xf32>
%1410 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1408, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1409 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1411 = linalg.init_tensor [1024] : tensor<1024xf32>
%1412 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1374, %1410 : tensor<1024xf32>, tensor<1024xf32>) outs(%1411 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1413 = linalg.init_tensor [1024] : tensor<1024xf32>
%1414 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1412, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1413 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1415 = linalg.init_tensor [1024] : tensor<1024xf32>
%1416 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1372, %1414 : tensor<1024xf32>, tensor<1024xf32>) outs(%1415 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1417 = linalg.init_tensor [1024] : tensor<1024xf32>
%1418 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1416, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1417 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1419 = linalg.init_tensor [1024] : tensor<1024xf32>
%1420 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1370, %1418 : tensor<1024xf32>, tensor<1024xf32>) outs(%1419 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1421 = linalg.init_tensor [1024] : tensor<1024xf32>
%1422 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1420, %1392 : tensor<1024xf32>, tensor<1024xf32>) outs(%1421 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1423 = linalg.init_tensor [1024] : tensor<1024xf32>
%1424 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1368, %1422 : tensor<1024xf32>, tensor<1024xf32>) outs(%1423 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1425 = linalg.init_tensor [1024] : tensor<1024xf32>
%1426 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1424, %1348 : tensor<1024xf32>, tensor<1024xf32>) outs(%1425 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1427 = linalg.init_tensor [1024] : tensor<1024xf32>
%1428 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1352, %1354, %1426 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%1427 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1429 = linalg.init_tensor [1024] : tensor<1024xf32>
%1430 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1428, %cst_193 : tensor<1024xf32>, tensor<1024xf32>) outs(%1429 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1431 = linalg.init_tensor [1024] : tensor<1024xf32>
%1432 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1430, %cst_194 : tensor<1024xf32>, tensor<1024xf32>) outs(%1431 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%1433 = tensor.extract_slice %258[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1434 = linalg.tensor_collapse_shape %1433 [] : tensor<1xi32> into tensor<i32>
%1435 = tensor.extract_slice %258[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1436 = linalg.tensor_collapse_shape %1435 [] : tensor<1xi32> into tensor<i32>
%1437 = linalg.init_tensor [] : tensor<i32>
%1438 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1434, %1436 : tensor<i32>, tensor<i32>) outs(%1437 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1439 = linalg.init_tensor [] : tensor<i32>
%1440 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1438, %cst_241 : tensor<i32>, tensor<i32>) outs(%1439 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1441 = linalg.init_tensor [2] : tensor<2xi32>
%1442 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1434 : tensor<i32>) outs(%1441 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1443 = linalg.init_tensor [2] : tensor<2xi32>
%1444 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %1442 : tensor<2xi32>, tensor<2xi32>) outs(%1443 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1445 = linalg.init_tensor [2] : tensor<2xi32>
%1446 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1436 : tensor<i32>) outs(%1445 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1447 = linalg.init_tensor [2] : tensor<2xi32>
%1448 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %1446 : tensor<2xi32>, tensor<2xi32>) outs(%1447 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1449 = linalg.init_tensor [2] : tensor<2xi32>
%1450 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1444, %1448 : tensor<2xi32>, tensor<2xi32>) outs(%1449 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1451 = linalg.init_tensor [2] : tensor<2xi32>
%1452 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1448, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1451 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1453 = linalg.init_tensor [2] : tensor<2xi32>
%1454 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1448, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1453 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1455 = linalg.init_tensor [2] : tensor<2xi32>
%1456 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1452, %1454 : tensor<2xi32>, tensor<2xi32>) outs(%1455 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1457 = linalg.init_tensor [2] : tensor<2xi32>
%1458 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1450, %1456 : tensor<2xi32>, tensor<2xi32>) outs(%1457 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1459 = linalg.init_tensor [2] : tensor<2xi32>
%1460 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1450, %1458 : tensor<2xi32>, tensor<2xi32>) outs(%1459 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1461 = linalg.init_tensor [2] : tensor<2xi32>
%1462 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1458, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1461 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1463 = linalg.init_tensor [2] : tensor<2xi32>
%1464 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1458, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1463 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1465 = linalg.init_tensor [2] : tensor<2xi32>
%1466 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1462, %1464 : tensor<2xi32>, tensor<2xi32>) outs(%1465 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1467 = linalg.init_tensor [2] : tensor<2xi32>
%1468 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1460, %1466 : tensor<2xi32>, tensor<2xi32>) outs(%1467 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1469 = linalg.init_tensor [2] : tensor<2xi32>
%1470 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1460, %1468 : tensor<2xi32>, tensor<2xi32>) outs(%1469 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1471 = linalg.init_tensor [2] : tensor<2xi32>
%1472 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1468, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1471 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1473 = linalg.init_tensor [2] : tensor<2xi32>
%1474 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1468, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1473 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1475 = linalg.init_tensor [2] : tensor<2xi32>
%1476 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1472, %1474 : tensor<2xi32>, tensor<2xi32>) outs(%1475 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1477 = linalg.init_tensor [2] : tensor<2xi32>
%1478 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1470, %1476 : tensor<2xi32>, tensor<2xi32>) outs(%1477 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1479 = linalg.init_tensor [2] : tensor<2xi32>
%1480 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1470, %1478 : tensor<2xi32>, tensor<2xi32>) outs(%1479 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1481 = linalg.init_tensor [2] : tensor<2xi32>
%1482 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1478, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1481 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1483 = linalg.init_tensor [2] : tensor<2xi32>
%1484 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1478, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1483 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1485 = linalg.init_tensor [2] : tensor<2xi32>
%1486 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1482, %1484 : tensor<2xi32>, tensor<2xi32>) outs(%1485 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1487 = linalg.init_tensor [2] : tensor<2xi32>
%1488 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1480, %1486 : tensor<2xi32>, tensor<2xi32>) outs(%1487 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1489 = linalg.init_tensor [2] : tensor<2xi32>
%1490 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1480, %1446 : tensor<2xi32>, tensor<2xi32>) outs(%1489 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1491 = linalg.init_tensor [2] : tensor<2xi32>
%1492 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1440 : tensor<i32>) outs(%1491 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1493 = linalg.init_tensor [2] : tensor<2xi32>
%1494 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1488, %1492 : tensor<2xi32>, tensor<2xi32>) outs(%1493 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1495 = linalg.init_tensor [2] : tensor<2xi32>
%1496 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1494, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%1495 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1497 = linalg.init_tensor [2] : tensor<2xi32>
%1498 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1490, %1496 : tensor<2xi32>, tensor<2xi32>) outs(%1497 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1499 = linalg.init_tensor [2] : tensor<2xi32>
%1500 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1496, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1499 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1501 = linalg.init_tensor [2] : tensor<2xi32>
%1502 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1496, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1501 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1503 = linalg.init_tensor [2] : tensor<2xi32>
%1504 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1500, %1502 : tensor<2xi32>, tensor<2xi32>) outs(%1503 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1505 = linalg.init_tensor [2] : tensor<2xi32>
%1506 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1498, %1504 : tensor<2xi32>, tensor<2xi32>) outs(%1505 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1507 = linalg.init_tensor [2] : tensor<2xi32>
%1508 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1498, %1506 : tensor<2xi32>, tensor<2xi32>) outs(%1507 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1509 = linalg.init_tensor [2] : tensor<2xi32>
%1510 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1506, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%1509 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1511 = linalg.init_tensor [2] : tensor<2xi32>
%1512 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1506, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1511 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1513 = linalg.init_tensor [2] : tensor<2xi32>
%1514 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1510, %1512 : tensor<2xi32>, tensor<2xi32>) outs(%1513 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1515 = linalg.init_tensor [2] : tensor<2xi32>
%1516 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1508, %1514 : tensor<2xi32>, tensor<2xi32>) outs(%1515 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1517 = linalg.init_tensor [2] : tensor<2xi32>
%1518 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1508, %1516 : tensor<2xi32>, tensor<2xi32>) outs(%1517 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1519 = linalg.init_tensor [2] : tensor<2xi32>
%1520 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1516, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1519 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1521 = linalg.init_tensor [2] : tensor<2xi32>
%1522 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1516, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1521 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1523 = linalg.init_tensor [2] : tensor<2xi32>
%1524 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1520, %1522 : tensor<2xi32>, tensor<2xi32>) outs(%1523 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1525 = linalg.init_tensor [2] : tensor<2xi32>
%1526 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1518, %1524 : tensor<2xi32>, tensor<2xi32>) outs(%1525 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1527 = linalg.init_tensor [2] : tensor<2xi32>
%1528 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1518, %1526 : tensor<2xi32>, tensor<2xi32>) outs(%1527 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1529 = linalg.init_tensor [2] : tensor<2xi32>
%1530 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1526, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%1529 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1531 = linalg.init_tensor [2] : tensor<2xi32>
%1532 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1526, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%1531 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1533 = linalg.init_tensor [2] : tensor<2xi32>
%1534 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1530, %1532 : tensor<2xi32>, tensor<2xi32>) outs(%1533 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1535 = linalg.init_tensor [2] : tensor<2xi32>
%1536 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1528, %1534 : tensor<2xi32>, tensor<2xi32>) outs(%1535 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1537 = linalg.init_tensor [2] : tensor<2xi32>
%1538 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1528, %1492 : tensor<2xi32>, tensor<2xi32>) outs(%1537 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1539 = linalg.init_tensor [2] : tensor<2xi32>
%1540 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1536, %1442 : tensor<2xi32>, tensor<2xi32>) outs(%1539 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1541 = linalg.init_tensor [2] : tensor<2xi32>
%1542 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1540, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%1541 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1543 = linalg.init_tensor [2] : tensor<2xi32>
%1544 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1538, %1542 : tensor<2xi32>, tensor<2xi32>) outs(%1543 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1545 = linalg.init_tensor [2] : tensor<2xi32>
%1546 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1542, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1545 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1547 = linalg.init_tensor [2] : tensor<2xi32>
%1548 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1542, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1547 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1549 = linalg.init_tensor [2] : tensor<2xi32>
%1550 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1546, %1548 : tensor<2xi32>, tensor<2xi32>) outs(%1549 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1551 = linalg.init_tensor [2] : tensor<2xi32>
%1552 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1544, %1550 : tensor<2xi32>, tensor<2xi32>) outs(%1551 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1553 = linalg.init_tensor [2] : tensor<2xi32>
%1554 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1544, %1552 : tensor<2xi32>, tensor<2xi32>) outs(%1553 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1555 = linalg.init_tensor [2] : tensor<2xi32>
%1556 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1552, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1555 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1557 = linalg.init_tensor [2] : tensor<2xi32>
%1558 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1552, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1557 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1559 = linalg.init_tensor [2] : tensor<2xi32>
%1560 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1556, %1558 : tensor<2xi32>, tensor<2xi32>) outs(%1559 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1561 = linalg.init_tensor [2] : tensor<2xi32>
%1562 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1554, %1560 : tensor<2xi32>, tensor<2xi32>) outs(%1561 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1563 = linalg.init_tensor [2] : tensor<2xi32>
%1564 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1554, %1562 : tensor<2xi32>, tensor<2xi32>) outs(%1563 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1565 = linalg.init_tensor [2] : tensor<2xi32>
%1566 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1562, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1565 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1567 = linalg.init_tensor [2] : tensor<2xi32>
%1568 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1562, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1567 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1569 = linalg.init_tensor [2] : tensor<2xi32>
%1570 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1566, %1568 : tensor<2xi32>, tensor<2xi32>) outs(%1569 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1571 = linalg.init_tensor [2] : tensor<2xi32>
%1572 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1564, %1570 : tensor<2xi32>, tensor<2xi32>) outs(%1571 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1573 = linalg.init_tensor [2] : tensor<2xi32>
%1574 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1564, %1572 : tensor<2xi32>, tensor<2xi32>) outs(%1573 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1575 = linalg.init_tensor [2] : tensor<2xi32>
%1576 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1572, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1575 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1577 = linalg.init_tensor [2] : tensor<2xi32>
%1578 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1572, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1577 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1579 = linalg.init_tensor [2] : tensor<2xi32>
%1580 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1576, %1578 : tensor<2xi32>, tensor<2xi32>) outs(%1579 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1581 = linalg.init_tensor [2] : tensor<2xi32>
%1582 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1574, %1580 : tensor<2xi32>, tensor<2xi32>) outs(%1581 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1583 = linalg.init_tensor [2] : tensor<2xi32>
%1584 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1574, %1442 : tensor<2xi32>, tensor<2xi32>) outs(%1583 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1585 = linalg.init_tensor [2] : tensor<2xi32>
%1586 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1582, %1446 : tensor<2xi32>, tensor<2xi32>) outs(%1585 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1587 = linalg.init_tensor [2] : tensor<2xi32>
%1588 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1586, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1587 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1589 = linalg.init_tensor [2] : tensor<2xi32>
%1590 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1584, %1588 : tensor<2xi32>, tensor<2xi32>) outs(%1589 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1591 = linalg.init_tensor [2] : tensor<2xi32>
%1592 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1588, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1591 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1593 = linalg.init_tensor [2] : tensor<2xi32>
%1594 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1588, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1593 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1595 = linalg.init_tensor [2] : tensor<2xi32>
%1596 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1592, %1594 : tensor<2xi32>, tensor<2xi32>) outs(%1595 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1597 = linalg.init_tensor [2] : tensor<2xi32>
%1598 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1590, %1596 : tensor<2xi32>, tensor<2xi32>) outs(%1597 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1599 = linalg.init_tensor [2] : tensor<2xi32>
%1600 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1590, %1598 : tensor<2xi32>, tensor<2xi32>) outs(%1599 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1601 = linalg.init_tensor [2] : tensor<2xi32>
%1602 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1598, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%1601 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1603 = linalg.init_tensor [2] : tensor<2xi32>
%1604 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1598, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1603 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1605 = linalg.init_tensor [2] : tensor<2xi32>
%1606 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1602, %1604 : tensor<2xi32>, tensor<2xi32>) outs(%1605 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1607 = linalg.init_tensor [2] : tensor<2xi32>
%1608 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1600, %1606 : tensor<2xi32>, tensor<2xi32>) outs(%1607 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1609 = linalg.init_tensor [2] : tensor<2xi32>
%1610 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1600, %1608 : tensor<2xi32>, tensor<2xi32>) outs(%1609 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1611 = linalg.init_tensor [2] : tensor<2xi32>
%1612 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1608, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1611 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1613 = linalg.init_tensor [2] : tensor<2xi32>
%1614 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1608, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1613 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1615 = linalg.init_tensor [2] : tensor<2xi32>
%1616 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1612, %1614 : tensor<2xi32>, tensor<2xi32>) outs(%1615 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1617 = linalg.init_tensor [2] : tensor<2xi32>
%1618 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1610, %1616 : tensor<2xi32>, tensor<2xi32>) outs(%1617 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1619 = linalg.init_tensor [2] : tensor<2xi32>
%1620 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1610, %1618 : tensor<2xi32>, tensor<2xi32>) outs(%1619 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1621 = linalg.init_tensor [2] : tensor<2xi32>
%1622 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1618, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%1621 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1623 = linalg.init_tensor [2] : tensor<2xi32>
%1624 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1618, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%1623 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1625 = linalg.init_tensor [2] : tensor<2xi32>
%1626 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1622, %1624 : tensor<2xi32>, tensor<2xi32>) outs(%1625 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1627 = linalg.init_tensor [2] : tensor<2xi32>
%1628 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1620, %1626 : tensor<2xi32>, tensor<2xi32>) outs(%1627 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1629 = linalg.init_tensor [2] : tensor<2xi32>
%1630 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1620, %1446 : tensor<2xi32>, tensor<2xi32>) outs(%1629 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1631 = linalg.init_tensor [2] : tensor<2xi32>
%1632 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1628, %1492 : tensor<2xi32>, tensor<2xi32>) outs(%1631 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1633 = linalg.init_tensor [2] : tensor<2xi32>
%1634 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1632, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%1633 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1635 = linalg.init_tensor [2] : tensor<2xi32>
%1636 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1630, %1634 : tensor<2xi32>, tensor<2xi32>) outs(%1635 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1637 = linalg.init_tensor [2] : tensor<2xi32>
%1638 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1634, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1637 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1639 = linalg.init_tensor [2] : tensor<2xi32>
%1640 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1634, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1639 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1641 = linalg.init_tensor [2] : tensor<2xi32>
%1642 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1638, %1640 : tensor<2xi32>, tensor<2xi32>) outs(%1641 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1643 = linalg.init_tensor [2] : tensor<2xi32>
%1644 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1636, %1642 : tensor<2xi32>, tensor<2xi32>) outs(%1643 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1645 = linalg.init_tensor [2] : tensor<2xi32>
%1646 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1636, %1644 : tensor<2xi32>, tensor<2xi32>) outs(%1645 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1647 = linalg.init_tensor [2] : tensor<2xi32>
%1648 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1644, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1647 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1649 = linalg.init_tensor [2] : tensor<2xi32>
%1650 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1644, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1649 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1651 = linalg.init_tensor [2] : tensor<2xi32>
%1652 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1648, %1650 : tensor<2xi32>, tensor<2xi32>) outs(%1651 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1653 = linalg.init_tensor [2] : tensor<2xi32>
%1654 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1646, %1652 : tensor<2xi32>, tensor<2xi32>) outs(%1653 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1655 = linalg.init_tensor [2] : tensor<2xi32>
%1656 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1646, %1654 : tensor<2xi32>, tensor<2xi32>) outs(%1655 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1657 = linalg.init_tensor [2] : tensor<2xi32>
%1658 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1654, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1657 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1659 = linalg.init_tensor [2] : tensor<2xi32>
%1660 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1654, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1659 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1661 = linalg.init_tensor [2] : tensor<2xi32>
%1662 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1658, %1660 : tensor<2xi32>, tensor<2xi32>) outs(%1661 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1663 = linalg.init_tensor [2] : tensor<2xi32>
%1664 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1656, %1662 : tensor<2xi32>, tensor<2xi32>) outs(%1663 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1665 = linalg.init_tensor [2] : tensor<2xi32>
%1666 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1656, %1664 : tensor<2xi32>, tensor<2xi32>) outs(%1665 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1667 = linalg.init_tensor [2] : tensor<2xi32>
%1668 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1664, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1667 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1669 = linalg.init_tensor [2] : tensor<2xi32>
%1670 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1664, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1669 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1671 = linalg.init_tensor [2] : tensor<2xi32>
%1672 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1668, %1670 : tensor<2xi32>, tensor<2xi32>) outs(%1671 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1673 = linalg.init_tensor [2] : tensor<2xi32>
%1674 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1666, %1672 : tensor<2xi32>, tensor<2xi32>) outs(%1673 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1675 = linalg.init_tensor [2] : tensor<2xi32>
%1676 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1666, %1492 : tensor<2xi32>, tensor<2xi32>) outs(%1675 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1677 = linalg.init_tensor [2] : tensor<2xi32>
%1678 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1674, %1442 : tensor<2xi32>, tensor<2xi32>) outs(%1677 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1679 = linalg.init_tensor [2] : tensor<2xi32>
%1680 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1678, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%1679 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1681 = linalg.init_tensor [4] : tensor<4xi32>
%1682 = linalg.fill(%c0_i32, %1681) : i32, tensor<4xi32> -> tensor<4xi32>
%1683 = tensor.insert_slice %1676 into %1682[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%1684 = tensor.insert_slice %1680 into %1683[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%1685 = linalg.tensor_expand_shape %1684 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%1686 = tensor.extract_slice %1685[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%1687 = linalg.tensor_collapse_shape %1686 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%1688 = tensor.extract_slice %1687[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1689 = linalg.tensor_collapse_shape %1688 [] : tensor<1xi32> into tensor<i32>
%1690 = tensor.extract_slice %1687[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1691 = linalg.tensor_collapse_shape %1690 [] : tensor<1xi32> into tensor<i32>
%1692 = linalg.init_tensor [] : tensor<i32>
%1693 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1689, %1691 : tensor<i32>, tensor<i32>) outs(%1692 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1694 = linalg.init_tensor [] : tensor<i32>
%1695 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1693, %cst_241 : tensor<i32>, tensor<i32>) outs(%1694 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1696 = linalg.init_tensor [2] : tensor<2xi32>
%1697 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1689 : tensor<i32>) outs(%1696 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1698 = linalg.init_tensor [2] : tensor<2xi32>
%1699 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %1697 : tensor<2xi32>, tensor<2xi32>) outs(%1698 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1700 = linalg.init_tensor [2] : tensor<2xi32>
%1701 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1691 : tensor<i32>) outs(%1700 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1702 = linalg.init_tensor [2] : tensor<2xi32>
%1703 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %1701 : tensor<2xi32>, tensor<2xi32>) outs(%1702 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1704 = linalg.init_tensor [2] : tensor<2xi32>
%1705 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1699, %1703 : tensor<2xi32>, tensor<2xi32>) outs(%1704 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1706 = linalg.init_tensor [2] : tensor<2xi32>
%1707 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1703, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1706 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1708 = linalg.init_tensor [2] : tensor<2xi32>
%1709 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1703, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1708 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1710 = linalg.init_tensor [2] : tensor<2xi32>
%1711 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1707, %1709 : tensor<2xi32>, tensor<2xi32>) outs(%1710 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1712 = linalg.init_tensor [2] : tensor<2xi32>
%1713 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1705, %1711 : tensor<2xi32>, tensor<2xi32>) outs(%1712 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1714 = linalg.init_tensor [2] : tensor<2xi32>
%1715 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1705, %1713 : tensor<2xi32>, tensor<2xi32>) outs(%1714 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1716 = linalg.init_tensor [2] : tensor<2xi32>
%1717 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1713, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1716 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1718 = linalg.init_tensor [2] : tensor<2xi32>
%1719 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1713, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1718 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1720 = linalg.init_tensor [2] : tensor<2xi32>
%1721 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1717, %1719 : tensor<2xi32>, tensor<2xi32>) outs(%1720 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1722 = linalg.init_tensor [2] : tensor<2xi32>
%1723 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1715, %1721 : tensor<2xi32>, tensor<2xi32>) outs(%1722 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1724 = linalg.init_tensor [2] : tensor<2xi32>
%1725 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1715, %1723 : tensor<2xi32>, tensor<2xi32>) outs(%1724 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1726 = linalg.init_tensor [2] : tensor<2xi32>
%1727 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1723, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1726 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1728 = linalg.init_tensor [2] : tensor<2xi32>
%1729 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1723, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1728 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1730 = linalg.init_tensor [2] : tensor<2xi32>
%1731 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1727, %1729 : tensor<2xi32>, tensor<2xi32>) outs(%1730 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1732 = linalg.init_tensor [2] : tensor<2xi32>
%1733 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1725, %1731 : tensor<2xi32>, tensor<2xi32>) outs(%1732 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1734 = linalg.init_tensor [2] : tensor<2xi32>
%1735 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1725, %1733 : tensor<2xi32>, tensor<2xi32>) outs(%1734 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1736 = linalg.init_tensor [2] : tensor<2xi32>
%1737 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1733, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1736 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1738 = linalg.init_tensor [2] : tensor<2xi32>
%1739 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1733, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1738 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1740 = linalg.init_tensor [2] : tensor<2xi32>
%1741 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1737, %1739 : tensor<2xi32>, tensor<2xi32>) outs(%1740 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1742 = linalg.init_tensor [2] : tensor<2xi32>
%1743 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1735, %1741 : tensor<2xi32>, tensor<2xi32>) outs(%1742 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1744 = linalg.init_tensor [2] : tensor<2xi32>
%1745 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1735, %1701 : tensor<2xi32>, tensor<2xi32>) outs(%1744 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1746 = linalg.init_tensor [2] : tensor<2xi32>
%1747 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1695 : tensor<i32>) outs(%1746 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1748 = linalg.init_tensor [2] : tensor<2xi32>
%1749 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1743, %1747 : tensor<2xi32>, tensor<2xi32>) outs(%1748 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1750 = linalg.init_tensor [2] : tensor<2xi32>
%1751 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1749, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%1750 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1752 = linalg.init_tensor [2] : tensor<2xi32>
%1753 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1745, %1751 : tensor<2xi32>, tensor<2xi32>) outs(%1752 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1754 = linalg.init_tensor [2] : tensor<2xi32>
%1755 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1751, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1754 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1756 = linalg.init_tensor [2] : tensor<2xi32>
%1757 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1751, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1756 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1758 = linalg.init_tensor [2] : tensor<2xi32>
%1759 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1755, %1757 : tensor<2xi32>, tensor<2xi32>) outs(%1758 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1760 = linalg.init_tensor [2] : tensor<2xi32>
%1761 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1753, %1759 : tensor<2xi32>, tensor<2xi32>) outs(%1760 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1762 = linalg.init_tensor [2] : tensor<2xi32>
%1763 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1753, %1761 : tensor<2xi32>, tensor<2xi32>) outs(%1762 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1764 = linalg.init_tensor [2] : tensor<2xi32>
%1765 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1761, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%1764 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1766 = linalg.init_tensor [2] : tensor<2xi32>
%1767 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1761, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1766 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1768 = linalg.init_tensor [2] : tensor<2xi32>
%1769 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1765, %1767 : tensor<2xi32>, tensor<2xi32>) outs(%1768 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1770 = linalg.init_tensor [2] : tensor<2xi32>
%1771 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1763, %1769 : tensor<2xi32>, tensor<2xi32>) outs(%1770 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1772 = linalg.init_tensor [2] : tensor<2xi32>
%1773 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1763, %1771 : tensor<2xi32>, tensor<2xi32>) outs(%1772 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1774 = linalg.init_tensor [2] : tensor<2xi32>
%1775 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1771, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1774 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1776 = linalg.init_tensor [2] : tensor<2xi32>
%1777 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1771, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1776 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1778 = linalg.init_tensor [2] : tensor<2xi32>
%1779 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1775, %1777 : tensor<2xi32>, tensor<2xi32>) outs(%1778 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1780 = linalg.init_tensor [2] : tensor<2xi32>
%1781 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1773, %1779 : tensor<2xi32>, tensor<2xi32>) outs(%1780 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1782 = linalg.init_tensor [2] : tensor<2xi32>
%1783 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1773, %1781 : tensor<2xi32>, tensor<2xi32>) outs(%1782 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1784 = linalg.init_tensor [2] : tensor<2xi32>
%1785 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1781, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%1784 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1786 = linalg.init_tensor [2] : tensor<2xi32>
%1787 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1781, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%1786 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1788 = linalg.init_tensor [2] : tensor<2xi32>
%1789 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1785, %1787 : tensor<2xi32>, tensor<2xi32>) outs(%1788 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1790 = linalg.init_tensor [2] : tensor<2xi32>
%1791 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1783, %1789 : tensor<2xi32>, tensor<2xi32>) outs(%1790 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1792 = linalg.init_tensor [2] : tensor<2xi32>
%1793 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1783, %1747 : tensor<2xi32>, tensor<2xi32>) outs(%1792 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1794 = linalg.init_tensor [2] : tensor<2xi32>
%1795 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1791, %1697 : tensor<2xi32>, tensor<2xi32>) outs(%1794 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1796 = linalg.init_tensor [2] : tensor<2xi32>
%1797 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1795, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%1796 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1798 = linalg.init_tensor [2] : tensor<2xi32>
%1799 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1793, %1797 : tensor<2xi32>, tensor<2xi32>) outs(%1798 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1800 = linalg.init_tensor [2] : tensor<2xi32>
%1801 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1797, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1800 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1802 = linalg.init_tensor [2] : tensor<2xi32>
%1803 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1797, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1802 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1804 = linalg.init_tensor [2] : tensor<2xi32>
%1805 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1801, %1803 : tensor<2xi32>, tensor<2xi32>) outs(%1804 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1806 = linalg.init_tensor [2] : tensor<2xi32>
%1807 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1799, %1805 : tensor<2xi32>, tensor<2xi32>) outs(%1806 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1808 = linalg.init_tensor [2] : tensor<2xi32>
%1809 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1799, %1807 : tensor<2xi32>, tensor<2xi32>) outs(%1808 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1810 = linalg.init_tensor [2] : tensor<2xi32>
%1811 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1807, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1810 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1812 = linalg.init_tensor [2] : tensor<2xi32>
%1813 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1807, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1812 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1814 = linalg.init_tensor [2] : tensor<2xi32>
%1815 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1811, %1813 : tensor<2xi32>, tensor<2xi32>) outs(%1814 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1816 = linalg.init_tensor [2] : tensor<2xi32>
%1817 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1809, %1815 : tensor<2xi32>, tensor<2xi32>) outs(%1816 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1818 = linalg.init_tensor [2] : tensor<2xi32>
%1819 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1809, %1817 : tensor<2xi32>, tensor<2xi32>) outs(%1818 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1820 = linalg.init_tensor [2] : tensor<2xi32>
%1821 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1817, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1820 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1822 = linalg.init_tensor [2] : tensor<2xi32>
%1823 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1817, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1822 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1824 = linalg.init_tensor [2] : tensor<2xi32>
%1825 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1821, %1823 : tensor<2xi32>, tensor<2xi32>) outs(%1824 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1826 = linalg.init_tensor [2] : tensor<2xi32>
%1827 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1819, %1825 : tensor<2xi32>, tensor<2xi32>) outs(%1826 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1828 = linalg.init_tensor [2] : tensor<2xi32>
%1829 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1819, %1827 : tensor<2xi32>, tensor<2xi32>) outs(%1828 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1830 = linalg.init_tensor [2] : tensor<2xi32>
%1831 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1827, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1830 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1832 = linalg.init_tensor [2] : tensor<2xi32>
%1833 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1827, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1832 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1834 = linalg.init_tensor [2] : tensor<2xi32>
%1835 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1831, %1833 : tensor<2xi32>, tensor<2xi32>) outs(%1834 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1836 = linalg.init_tensor [2] : tensor<2xi32>
%1837 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1829, %1835 : tensor<2xi32>, tensor<2xi32>) outs(%1836 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1838 = linalg.init_tensor [2] : tensor<2xi32>
%1839 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1829, %1697 : tensor<2xi32>, tensor<2xi32>) outs(%1838 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1840 = linalg.init_tensor [2] : tensor<2xi32>
%1841 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1837, %1701 : tensor<2xi32>, tensor<2xi32>) outs(%1840 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1842 = linalg.init_tensor [2] : tensor<2xi32>
%1843 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1841, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1842 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1844 = linalg.init_tensor [2] : tensor<2xi32>
%1845 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1839, %1843 : tensor<2xi32>, tensor<2xi32>) outs(%1844 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1846 = linalg.init_tensor [2] : tensor<2xi32>
%1847 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1843, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1846 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1848 = linalg.init_tensor [2] : tensor<2xi32>
%1849 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1843, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1848 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1850 = linalg.init_tensor [2] : tensor<2xi32>
%1851 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1847, %1849 : tensor<2xi32>, tensor<2xi32>) outs(%1850 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1852 = linalg.init_tensor [2] : tensor<2xi32>
%1853 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1845, %1851 : tensor<2xi32>, tensor<2xi32>) outs(%1852 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1854 = linalg.init_tensor [2] : tensor<2xi32>
%1855 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1845, %1853 : tensor<2xi32>, tensor<2xi32>) outs(%1854 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1856 = linalg.init_tensor [2] : tensor<2xi32>
%1857 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1853, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%1856 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1858 = linalg.init_tensor [2] : tensor<2xi32>
%1859 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1853, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%1858 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1860 = linalg.init_tensor [2] : tensor<2xi32>
%1861 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1857, %1859 : tensor<2xi32>, tensor<2xi32>) outs(%1860 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1862 = linalg.init_tensor [2] : tensor<2xi32>
%1863 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1855, %1861 : tensor<2xi32>, tensor<2xi32>) outs(%1862 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1864 = linalg.init_tensor [2] : tensor<2xi32>
%1865 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1855, %1863 : tensor<2xi32>, tensor<2xi32>) outs(%1864 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1866 = linalg.init_tensor [2] : tensor<2xi32>
%1867 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1863, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1866 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1868 = linalg.init_tensor [2] : tensor<2xi32>
%1869 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1863, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%1868 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1870 = linalg.init_tensor [2] : tensor<2xi32>
%1871 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1867, %1869 : tensor<2xi32>, tensor<2xi32>) outs(%1870 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1872 = linalg.init_tensor [2] : tensor<2xi32>
%1873 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1865, %1871 : tensor<2xi32>, tensor<2xi32>) outs(%1872 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1874 = linalg.init_tensor [2] : tensor<2xi32>
%1875 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1865, %1873 : tensor<2xi32>, tensor<2xi32>) outs(%1874 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1876 = linalg.init_tensor [2] : tensor<2xi32>
%1877 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1873, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%1876 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1878 = linalg.init_tensor [2] : tensor<2xi32>
%1879 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1873, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%1878 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1880 = linalg.init_tensor [2] : tensor<2xi32>
%1881 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1877, %1879 : tensor<2xi32>, tensor<2xi32>) outs(%1880 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1882 = linalg.init_tensor [2] : tensor<2xi32>
%1883 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1875, %1881 : tensor<2xi32>, tensor<2xi32>) outs(%1882 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1884 = linalg.init_tensor [2] : tensor<2xi32>
%1885 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1875, %1701 : tensor<2xi32>, tensor<2xi32>) outs(%1884 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1886 = linalg.init_tensor [2] : tensor<2xi32>
%1887 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1883, %1747 : tensor<2xi32>, tensor<2xi32>) outs(%1886 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1888 = linalg.init_tensor [2] : tensor<2xi32>
%1889 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1887, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%1888 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1890 = linalg.init_tensor [2] : tensor<2xi32>
%1891 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1885, %1889 : tensor<2xi32>, tensor<2xi32>) outs(%1890 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1892 = linalg.init_tensor [2] : tensor<2xi32>
%1893 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1889, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1892 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1894 = linalg.init_tensor [2] : tensor<2xi32>
%1895 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1889, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1894 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1896 = linalg.init_tensor [2] : tensor<2xi32>
%1897 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1893, %1895 : tensor<2xi32>, tensor<2xi32>) outs(%1896 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1898 = linalg.init_tensor [2] : tensor<2xi32>
%1899 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1891, %1897 : tensor<2xi32>, tensor<2xi32>) outs(%1898 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1900 = linalg.init_tensor [2] : tensor<2xi32>
%1901 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1891, %1899 : tensor<2xi32>, tensor<2xi32>) outs(%1900 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1902 = linalg.init_tensor [2] : tensor<2xi32>
%1903 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1899, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1902 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1904 = linalg.init_tensor [2] : tensor<2xi32>
%1905 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1899, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1904 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1906 = linalg.init_tensor [2] : tensor<2xi32>
%1907 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1903, %1905 : tensor<2xi32>, tensor<2xi32>) outs(%1906 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1908 = linalg.init_tensor [2] : tensor<2xi32>
%1909 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1901, %1907 : tensor<2xi32>, tensor<2xi32>) outs(%1908 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1910 = linalg.init_tensor [2] : tensor<2xi32>
%1911 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1901, %1909 : tensor<2xi32>, tensor<2xi32>) outs(%1910 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1912 = linalg.init_tensor [2] : tensor<2xi32>
%1913 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1909, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1912 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1914 = linalg.init_tensor [2] : tensor<2xi32>
%1915 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1909, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1914 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1916 = linalg.init_tensor [2] : tensor<2xi32>
%1917 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1913, %1915 : tensor<2xi32>, tensor<2xi32>) outs(%1916 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1918 = linalg.init_tensor [2] : tensor<2xi32>
%1919 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1911, %1917 : tensor<2xi32>, tensor<2xi32>) outs(%1918 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1920 = linalg.init_tensor [2] : tensor<2xi32>
%1921 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1911, %1919 : tensor<2xi32>, tensor<2xi32>) outs(%1920 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1922 = linalg.init_tensor [2] : tensor<2xi32>
%1923 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1919, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1922 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1924 = linalg.init_tensor [2] : tensor<2xi32>
%1925 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1919, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1924 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1926 = linalg.init_tensor [2] : tensor<2xi32>
%1927 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1923, %1925 : tensor<2xi32>, tensor<2xi32>) outs(%1926 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1928 = linalg.init_tensor [2] : tensor<2xi32>
%1929 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1921, %1927 : tensor<2xi32>, tensor<2xi32>) outs(%1928 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1930 = linalg.init_tensor [2] : tensor<2xi32>
%1931 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1921, %1747 : tensor<2xi32>, tensor<2xi32>) outs(%1930 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1932 = linalg.init_tensor [2] : tensor<2xi32>
%1933 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1929, %1697 : tensor<2xi32>, tensor<2xi32>) outs(%1932 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1934 = linalg.init_tensor [2] : tensor<2xi32>
%1935 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1933, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%1934 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1936 = linalg.init_tensor [4] : tensor<4xi32>
%1937 = linalg.fill(%c0_i32, %1936) : i32, tensor<4xi32> -> tensor<4xi32>
%1938 = tensor.insert_slice %1931 into %1937[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%1939 = tensor.insert_slice %1935 into %1938[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%1940 = linalg.tensor_expand_shape %1939 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%1941 = tensor.extract_slice %1940[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%1942 = linalg.tensor_collapse_shape %1941 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%1943 = tensor.extract_slice %1940[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%1944 = linalg.tensor_collapse_shape %1943 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%1945 = tensor.extract_slice %1944[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1946 = linalg.tensor_collapse_shape %1945 [] : tensor<1xi32> into tensor<i32>
%1947 = tensor.extract_slice %1944[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%1948 = linalg.tensor_collapse_shape %1947 [] : tensor<1xi32> into tensor<i32>
%1949 = linalg.init_tensor [] : tensor<i32>
%1950 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1946, %1948 : tensor<i32>, tensor<i32>) outs(%1949 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1951 = linalg.init_tensor [] : tensor<i32>
%1952 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%1950, %cst_241 : tensor<i32>, tensor<i32>) outs(%1951 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%1953 = linalg.init_tensor [2] : tensor<2xi32>
%1954 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1946 : tensor<i32>) outs(%1953 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1955 = linalg.init_tensor [2] : tensor<2xi32>
%1956 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %1954 : tensor<2xi32>, tensor<2xi32>) outs(%1955 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1957 = linalg.init_tensor [2] : tensor<2xi32>
%1958 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1948 : tensor<i32>) outs(%1957 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%1959 = linalg.init_tensor [2] : tensor<2xi32>
%1960 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %1958 : tensor<2xi32>, tensor<2xi32>) outs(%1959 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1961 = linalg.init_tensor [2] : tensor<2xi32>
%1962 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1956, %1960 : tensor<2xi32>, tensor<2xi32>) outs(%1961 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1963 = linalg.init_tensor [2] : tensor<2xi32>
%1964 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1960, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%1963 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1965 = linalg.init_tensor [2] : tensor<2xi32>
%1966 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1960, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%1965 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1967 = linalg.init_tensor [2] : tensor<2xi32>
%1968 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1964, %1966 : tensor<2xi32>, tensor<2xi32>) outs(%1967 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1969 = linalg.init_tensor [2] : tensor<2xi32>
%1970 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1962, %1968 : tensor<2xi32>, tensor<2xi32>) outs(%1969 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1971 = linalg.init_tensor [2] : tensor<2xi32>
%1972 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1962, %1970 : tensor<2xi32>, tensor<2xi32>) outs(%1971 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1973 = linalg.init_tensor [2] : tensor<2xi32>
%1974 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1970, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%1973 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1975 = linalg.init_tensor [2] : tensor<2xi32>
%1976 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1970, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%1975 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1977 = linalg.init_tensor [2] : tensor<2xi32>
%1978 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1974, %1976 : tensor<2xi32>, tensor<2xi32>) outs(%1977 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1979 = linalg.init_tensor [2] : tensor<2xi32>
%1980 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1972, %1978 : tensor<2xi32>, tensor<2xi32>) outs(%1979 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1981 = linalg.init_tensor [2] : tensor<2xi32>
%1982 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1972, %1980 : tensor<2xi32>, tensor<2xi32>) outs(%1981 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1983 = linalg.init_tensor [2] : tensor<2xi32>
%1984 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1980, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1983 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1985 = linalg.init_tensor [2] : tensor<2xi32>
%1986 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1980, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1985 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1987 = linalg.init_tensor [2] : tensor<2xi32>
%1988 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1984, %1986 : tensor<2xi32>, tensor<2xi32>) outs(%1987 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1989 = linalg.init_tensor [2] : tensor<2xi32>
%1990 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1982, %1988 : tensor<2xi32>, tensor<2xi32>) outs(%1989 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1991 = linalg.init_tensor [2] : tensor<2xi32>
%1992 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1982, %1990 : tensor<2xi32>, tensor<2xi32>) outs(%1991 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1993 = linalg.init_tensor [2] : tensor<2xi32>
%1994 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1990, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%1993 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1995 = linalg.init_tensor [2] : tensor<2xi32>
%1996 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1990, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%1995 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1997 = linalg.init_tensor [2] : tensor<2xi32>
%1998 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1994, %1996 : tensor<2xi32>, tensor<2xi32>) outs(%1997 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%1999 = linalg.init_tensor [2] : tensor<2xi32>
%2000 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1992, %1998 : tensor<2xi32>, tensor<2xi32>) outs(%1999 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2001 = linalg.init_tensor [2] : tensor<2xi32>
%2002 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1992, %1958 : tensor<2xi32>, tensor<2xi32>) outs(%2001 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2003 = linalg.init_tensor [2] : tensor<2xi32>
%2004 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%1952 : tensor<i32>) outs(%2003 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%2005 = linalg.init_tensor [2] : tensor<2xi32>
%2006 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2000, %2004 : tensor<2xi32>, tensor<2xi32>) outs(%2005 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2007 = linalg.init_tensor [2] : tensor<2xi32>
%2008 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2006, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%2007 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2009 = linalg.init_tensor [2] : tensor<2xi32>
%2010 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2002, %2008 : tensor<2xi32>, tensor<2xi32>) outs(%2009 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2011 = linalg.init_tensor [2] : tensor<2xi32>
%2012 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2008, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2011 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2013 = linalg.init_tensor [2] : tensor<2xi32>
%2014 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2008, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2013 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2015 = linalg.init_tensor [2] : tensor<2xi32>
%2016 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2012, %2014 : tensor<2xi32>, tensor<2xi32>) outs(%2015 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2017 = linalg.init_tensor [2] : tensor<2xi32>
%2018 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2010, %2016 : tensor<2xi32>, tensor<2xi32>) outs(%2017 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2019 = linalg.init_tensor [2] : tensor<2xi32>
%2020 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2010, %2018 : tensor<2xi32>, tensor<2xi32>) outs(%2019 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2021 = linalg.init_tensor [2] : tensor<2xi32>
%2022 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2018, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%2021 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2023 = linalg.init_tensor [2] : tensor<2xi32>
%2024 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2018, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%2023 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2025 = linalg.init_tensor [2] : tensor<2xi32>
%2026 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2022, %2024 : tensor<2xi32>, tensor<2xi32>) outs(%2025 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2027 = linalg.init_tensor [2] : tensor<2xi32>
%2028 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2020, %2026 : tensor<2xi32>, tensor<2xi32>) outs(%2027 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2029 = linalg.init_tensor [2] : tensor<2xi32>
%2030 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2020, %2028 : tensor<2xi32>, tensor<2xi32>) outs(%2029 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2031 = linalg.init_tensor [2] : tensor<2xi32>
%2032 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2028, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%2031 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2033 = linalg.init_tensor [2] : tensor<2xi32>
%2034 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2028, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%2033 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2035 = linalg.init_tensor [2] : tensor<2xi32>
%2036 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2032, %2034 : tensor<2xi32>, tensor<2xi32>) outs(%2035 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2037 = linalg.init_tensor [2] : tensor<2xi32>
%2038 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2030, %2036 : tensor<2xi32>, tensor<2xi32>) outs(%2037 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2039 = linalg.init_tensor [2] : tensor<2xi32>
%2040 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2030, %2038 : tensor<2xi32>, tensor<2xi32>) outs(%2039 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2041 = linalg.init_tensor [2] : tensor<2xi32>
%2042 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2038, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%2041 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2043 = linalg.init_tensor [2] : tensor<2xi32>
%2044 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2038, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%2043 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2045 = linalg.init_tensor [2] : tensor<2xi32>
%2046 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2042, %2044 : tensor<2xi32>, tensor<2xi32>) outs(%2045 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2047 = linalg.init_tensor [2] : tensor<2xi32>
%2048 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2040, %2046 : tensor<2xi32>, tensor<2xi32>) outs(%2047 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2049 = linalg.init_tensor [2] : tensor<2xi32>
%2050 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2040, %2004 : tensor<2xi32>, tensor<2xi32>) outs(%2049 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2051 = linalg.init_tensor [2] : tensor<2xi32>
%2052 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2048, %1954 : tensor<2xi32>, tensor<2xi32>) outs(%2051 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2053 = linalg.init_tensor [2] : tensor<2xi32>
%2054 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2052, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%2053 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2055 = linalg.init_tensor [2] : tensor<2xi32>
%2056 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2050, %2054 : tensor<2xi32>, tensor<2xi32>) outs(%2055 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2057 = linalg.init_tensor [2] : tensor<2xi32>
%2058 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2054, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%2057 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2059 = linalg.init_tensor [2] : tensor<2xi32>
%2060 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2054, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%2059 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2061 = linalg.init_tensor [2] : tensor<2xi32>
%2062 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2058, %2060 : tensor<2xi32>, tensor<2xi32>) outs(%2061 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2063 = linalg.init_tensor [2] : tensor<2xi32>
%2064 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2056, %2062 : tensor<2xi32>, tensor<2xi32>) outs(%2063 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2065 = linalg.init_tensor [2] : tensor<2xi32>
%2066 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2056, %2064 : tensor<2xi32>, tensor<2xi32>) outs(%2065 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2067 = linalg.init_tensor [2] : tensor<2xi32>
%2068 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2064, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2067 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2069 = linalg.init_tensor [2] : tensor<2xi32>
%2070 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2064, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2069 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2071 = linalg.init_tensor [2] : tensor<2xi32>
%2072 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2068, %2070 : tensor<2xi32>, tensor<2xi32>) outs(%2071 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2073 = linalg.init_tensor [2] : tensor<2xi32>
%2074 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2066, %2072 : tensor<2xi32>, tensor<2xi32>) outs(%2073 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2075 = linalg.init_tensor [2] : tensor<2xi32>
%2076 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2066, %2074 : tensor<2xi32>, tensor<2xi32>) outs(%2075 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2077 = linalg.init_tensor [2] : tensor<2xi32>
%2078 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2074, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2077 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2079 = linalg.init_tensor [2] : tensor<2xi32>
%2080 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2074, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2079 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2081 = linalg.init_tensor [2] : tensor<2xi32>
%2082 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2078, %2080 : tensor<2xi32>, tensor<2xi32>) outs(%2081 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2083 = linalg.init_tensor [2] : tensor<2xi32>
%2084 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2076, %2082 : tensor<2xi32>, tensor<2xi32>) outs(%2083 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2085 = linalg.init_tensor [2] : tensor<2xi32>
%2086 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2076, %2084 : tensor<2xi32>, tensor<2xi32>) outs(%2085 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2087 = linalg.init_tensor [2] : tensor<2xi32>
%2088 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2084, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2087 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2089 = linalg.init_tensor [2] : tensor<2xi32>
%2090 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2084, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2089 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2091 = linalg.init_tensor [2] : tensor<2xi32>
%2092 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2088, %2090 : tensor<2xi32>, tensor<2xi32>) outs(%2091 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2093 = linalg.init_tensor [2] : tensor<2xi32>
%2094 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2086, %2092 : tensor<2xi32>, tensor<2xi32>) outs(%2093 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2095 = linalg.init_tensor [2] : tensor<2xi32>
%2096 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2086, %1954 : tensor<2xi32>, tensor<2xi32>) outs(%2095 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2097 = linalg.init_tensor [2] : tensor<2xi32>
%2098 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2094, %1958 : tensor<2xi32>, tensor<2xi32>) outs(%2097 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2099 = linalg.init_tensor [2] : tensor<2xi32>
%2100 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2098, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%2099 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2101 = linalg.init_tensor [2] : tensor<2xi32>
%2102 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2096, %2100 : tensor<2xi32>, tensor<2xi32>) outs(%2101 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2103 = linalg.init_tensor [2] : tensor<2xi32>
%2104 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2100, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2103 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2105 = linalg.init_tensor [2] : tensor<2xi32>
%2106 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2100, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2105 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2107 = linalg.init_tensor [2] : tensor<2xi32>
%2108 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2104, %2106 : tensor<2xi32>, tensor<2xi32>) outs(%2107 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2109 = linalg.init_tensor [2] : tensor<2xi32>
%2110 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2102, %2108 : tensor<2xi32>, tensor<2xi32>) outs(%2109 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2111 = linalg.init_tensor [2] : tensor<2xi32>
%2112 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2102, %2110 : tensor<2xi32>, tensor<2xi32>) outs(%2111 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2113 = linalg.init_tensor [2] : tensor<2xi32>
%2114 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2110, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%2113 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2115 = linalg.init_tensor [2] : tensor<2xi32>
%2116 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2110, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%2115 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2117 = linalg.init_tensor [2] : tensor<2xi32>
%2118 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2114, %2116 : tensor<2xi32>, tensor<2xi32>) outs(%2117 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2119 = linalg.init_tensor [2] : tensor<2xi32>
%2120 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2112, %2118 : tensor<2xi32>, tensor<2xi32>) outs(%2119 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2121 = linalg.init_tensor [2] : tensor<2xi32>
%2122 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2112, %2120 : tensor<2xi32>, tensor<2xi32>) outs(%2121 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2123 = linalg.init_tensor [2] : tensor<2xi32>
%2124 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2120, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%2123 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2125 = linalg.init_tensor [2] : tensor<2xi32>
%2126 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2120, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%2125 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2127 = linalg.init_tensor [2] : tensor<2xi32>
%2128 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2124, %2126 : tensor<2xi32>, tensor<2xi32>) outs(%2127 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2129 = linalg.init_tensor [2] : tensor<2xi32>
%2130 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2122, %2128 : tensor<2xi32>, tensor<2xi32>) outs(%2129 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2131 = linalg.init_tensor [2] : tensor<2xi32>
%2132 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2122, %2130 : tensor<2xi32>, tensor<2xi32>) outs(%2131 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2133 = linalg.init_tensor [2] : tensor<2xi32>
%2134 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2130, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%2133 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2135 = linalg.init_tensor [2] : tensor<2xi32>
%2136 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2130, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%2135 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2137 = linalg.init_tensor [2] : tensor<2xi32>
%2138 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2134, %2136 : tensor<2xi32>, tensor<2xi32>) outs(%2137 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2139 = linalg.init_tensor [2] : tensor<2xi32>
%2140 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2132, %2138 : tensor<2xi32>, tensor<2xi32>) outs(%2139 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2141 = linalg.init_tensor [2] : tensor<2xi32>
%2142 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2132, %1958 : tensor<2xi32>, tensor<2xi32>) outs(%2141 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2143 = linalg.init_tensor [2] : tensor<2xi32>
%2144 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2140, %2004 : tensor<2xi32>, tensor<2xi32>) outs(%2143 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2145 = linalg.init_tensor [2] : tensor<2xi32>
%2146 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2144, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%2145 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2147 = linalg.init_tensor [2] : tensor<2xi32>
%2148 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2142, %2146 : tensor<2xi32>, tensor<2xi32>) outs(%2147 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2149 = linalg.init_tensor [2] : tensor<2xi32>
%2150 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2146, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%2149 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2151 = linalg.init_tensor [2] : tensor<2xi32>
%2152 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2146, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%2151 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2153 = linalg.init_tensor [2] : tensor<2xi32>
%2154 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2150, %2152 : tensor<2xi32>, tensor<2xi32>) outs(%2153 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2155 = linalg.init_tensor [2] : tensor<2xi32>
%2156 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2148, %2154 : tensor<2xi32>, tensor<2xi32>) outs(%2155 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2157 = linalg.init_tensor [2] : tensor<2xi32>
%2158 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2148, %2156 : tensor<2xi32>, tensor<2xi32>) outs(%2157 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2159 = linalg.init_tensor [2] : tensor<2xi32>
%2160 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2156, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2159 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2161 = linalg.init_tensor [2] : tensor<2xi32>
%2162 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2156, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2161 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2163 = linalg.init_tensor [2] : tensor<2xi32>
%2164 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2160, %2162 : tensor<2xi32>, tensor<2xi32>) outs(%2163 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2165 = linalg.init_tensor [2] : tensor<2xi32>
%2166 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2158, %2164 : tensor<2xi32>, tensor<2xi32>) outs(%2165 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2167 = linalg.init_tensor [2] : tensor<2xi32>
%2168 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2158, %2166 : tensor<2xi32>, tensor<2xi32>) outs(%2167 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2169 = linalg.init_tensor [2] : tensor<2xi32>
%2170 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2166, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2169 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2171 = linalg.init_tensor [2] : tensor<2xi32>
%2172 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2166, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2171 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2173 = linalg.init_tensor [2] : tensor<2xi32>
%2174 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2170, %2172 : tensor<2xi32>, tensor<2xi32>) outs(%2173 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2175 = linalg.init_tensor [2] : tensor<2xi32>
%2176 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2168, %2174 : tensor<2xi32>, tensor<2xi32>) outs(%2175 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2177 = linalg.init_tensor [2] : tensor<2xi32>
%2178 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2168, %2176 : tensor<2xi32>, tensor<2xi32>) outs(%2177 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2179 = linalg.init_tensor [2] : tensor<2xi32>
%2180 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2176, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2179 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2181 = linalg.init_tensor [2] : tensor<2xi32>
%2182 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2176, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2181 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2183 = linalg.init_tensor [2] : tensor<2xi32>
%2184 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2180, %2182 : tensor<2xi32>, tensor<2xi32>) outs(%2183 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2185 = linalg.init_tensor [2] : tensor<2xi32>
%2186 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2178, %2184 : tensor<2xi32>, tensor<2xi32>) outs(%2185 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2187 = linalg.init_tensor [2] : tensor<2xi32>
%2188 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2178, %2004 : tensor<2xi32>, tensor<2xi32>) outs(%2187 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2189 = linalg.init_tensor [2] : tensor<2xi32>
%2190 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2186, %1954 : tensor<2xi32>, tensor<2xi32>) outs(%2189 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2191 = linalg.init_tensor [2] : tensor<2xi32>
%2192 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2190, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%2191 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2193 = linalg.init_tensor [4] : tensor<4xi32>
%2194 = linalg.fill(%c0_i32, %2193) : i32, tensor<4xi32> -> tensor<4xi32>
%2195 = tensor.insert_slice %2188 into %2194[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%2196 = tensor.insert_slice %2192 into %2195[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%2197 = linalg.tensor_expand_shape %2196 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%2198 = tensor.extract_slice %2197[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%2199 = linalg.tensor_collapse_shape %2198 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%2200 = tensor.extract_slice %2197[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%2201 = linalg.tensor_collapse_shape %2200 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%2202 = linalg.init_tensor [1048576] : tensor<1048576xi32>
%2203 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%2202 : tensor<1048576xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<1048576xi32>
%2204 = tensor.extract_slice %2199[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2205 = linalg.tensor_collapse_shape %2204 [] : tensor<1xi32> into tensor<i32>
%2206 = tensor.extract_slice %2199[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2207 = linalg.tensor_collapse_shape %2206 [] : tensor<1xi32> into tensor<i32>
%2208 = tensor.extract_slice %2203[0] [524288] [1] : tensor<1048576xi32> to tensor<524288xi32>
%2209 = tensor.extract_slice %2203[524288] [524288] [1] : tensor<1048576xi32> to tensor<524288xi32>
%2210 = linalg.init_tensor [] : tensor<i32>
%2211 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2205, %2207 : tensor<i32>, tensor<i32>) outs(%2210 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2212 = linalg.init_tensor [] : tensor<i32>
%2213 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2211, %cst_241 : tensor<i32>, tensor<i32>) outs(%2212 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2214 = linalg.init_tensor [524288] : tensor<524288xi32>
%2215 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2205 : tensor<i32>) outs(%2214 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<524288xi32>
%2216 = linalg.init_tensor [524288] : tensor<524288xi32>
%2217 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2208, %2215 : tensor<524288xi32>, tensor<524288xi32>) outs(%2216 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2218 = linalg.init_tensor [524288] : tensor<524288xi32>
%2219 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2207 : tensor<i32>) outs(%2218 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<524288xi32>
%2220 = linalg.init_tensor [524288] : tensor<524288xi32>
%2221 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2209, %2219 : tensor<524288xi32>, tensor<524288xi32>) outs(%2220 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2222 = linalg.init_tensor [524288] : tensor<524288xi32>
%2223 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2217, %2221 : tensor<524288xi32>, tensor<524288xi32>) outs(%2222 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2224 = linalg.init_tensor [524288] : tensor<524288xi32>
%2225 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2221, %cst_163 : tensor<524288xi32>, tensor<524288xi32>) outs(%2224 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2226 = linalg.init_tensor [524288] : tensor<524288xi32>
%2227 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2221, %cst_164 : tensor<524288xi32>, tensor<524288xi32>) outs(%2226 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2228 = linalg.init_tensor [524288] : tensor<524288xi32>
%2229 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2225, %2227 : tensor<524288xi32>, tensor<524288xi32>) outs(%2228 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2230 = linalg.init_tensor [524288] : tensor<524288xi32>
%2231 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2223, %2229 : tensor<524288xi32>, tensor<524288xi32>) outs(%2230 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2232 = linalg.init_tensor [524288] : tensor<524288xi32>
%2233 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2223, %2231 : tensor<524288xi32>, tensor<524288xi32>) outs(%2232 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2234 = linalg.init_tensor [524288] : tensor<524288xi32>
%2235 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2231, %cst_165 : tensor<524288xi32>, tensor<524288xi32>) outs(%2234 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2236 = linalg.init_tensor [524288] : tensor<524288xi32>
%2237 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2231, %cst_166 : tensor<524288xi32>, tensor<524288xi32>) outs(%2236 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2238 = linalg.init_tensor [524288] : tensor<524288xi32>
%2239 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2235, %2237 : tensor<524288xi32>, tensor<524288xi32>) outs(%2238 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2240 = linalg.init_tensor [524288] : tensor<524288xi32>
%2241 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2233, %2239 : tensor<524288xi32>, tensor<524288xi32>) outs(%2240 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2242 = linalg.init_tensor [524288] : tensor<524288xi32>
%2243 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2233, %2241 : tensor<524288xi32>, tensor<524288xi32>) outs(%2242 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2244 = linalg.init_tensor [524288] : tensor<524288xi32>
%2245 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2241, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2244 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2246 = linalg.init_tensor [524288] : tensor<524288xi32>
%2247 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2241, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2246 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2248 = linalg.init_tensor [524288] : tensor<524288xi32>
%2249 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2245, %2247 : tensor<524288xi32>, tensor<524288xi32>) outs(%2248 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2250 = linalg.init_tensor [524288] : tensor<524288xi32>
%2251 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2243, %2249 : tensor<524288xi32>, tensor<524288xi32>) outs(%2250 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2252 = linalg.init_tensor [524288] : tensor<524288xi32>
%2253 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2243, %2251 : tensor<524288xi32>, tensor<524288xi32>) outs(%2252 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2254 = linalg.init_tensor [524288] : tensor<524288xi32>
%2255 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2251, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2254 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2256 = linalg.init_tensor [524288] : tensor<524288xi32>
%2257 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2251, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2256 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2258 = linalg.init_tensor [524288] : tensor<524288xi32>
%2259 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2255, %2257 : tensor<524288xi32>, tensor<524288xi32>) outs(%2258 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2260 = linalg.init_tensor [524288] : tensor<524288xi32>
%2261 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2253, %2259 : tensor<524288xi32>, tensor<524288xi32>) outs(%2260 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2262 = linalg.init_tensor [524288] : tensor<524288xi32>
%2263 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2253, %2219 : tensor<524288xi32>, tensor<524288xi32>) outs(%2262 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2264 = linalg.init_tensor [524288] : tensor<524288xi32>
%2265 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2213 : tensor<i32>) outs(%2264 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<524288xi32>
%2266 = linalg.init_tensor [524288] : tensor<524288xi32>
%2267 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2261, %2265 : tensor<524288xi32>, tensor<524288xi32>) outs(%2266 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2268 = linalg.init_tensor [524288] : tensor<524288xi32>
%2269 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2267, %cst_155 : tensor<524288xi32>, tensor<524288xi32>) outs(%2268 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2270 = linalg.init_tensor [524288] : tensor<524288xi32>
%2271 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2263, %2269 : tensor<524288xi32>, tensor<524288xi32>) outs(%2270 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2272 = linalg.init_tensor [524288] : tensor<524288xi32>
%2273 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2269, %cst_166 : tensor<524288xi32>, tensor<524288xi32>) outs(%2272 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2274 = linalg.init_tensor [524288] : tensor<524288xi32>
%2275 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2269, %cst_165 : tensor<524288xi32>, tensor<524288xi32>) outs(%2274 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2276 = linalg.init_tensor [524288] : tensor<524288xi32>
%2277 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2273, %2275 : tensor<524288xi32>, tensor<524288xi32>) outs(%2276 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2278 = linalg.init_tensor [524288] : tensor<524288xi32>
%2279 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2271, %2277 : tensor<524288xi32>, tensor<524288xi32>) outs(%2278 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2280 = linalg.init_tensor [524288] : tensor<524288xi32>
%2281 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2271, %2279 : tensor<524288xi32>, tensor<524288xi32>) outs(%2280 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2282 = linalg.init_tensor [524288] : tensor<524288xi32>
%2283 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2279, %cst_157 : tensor<524288xi32>, tensor<524288xi32>) outs(%2282 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2284 = linalg.init_tensor [524288] : tensor<524288xi32>
%2285 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2279, %cst_158 : tensor<524288xi32>, tensor<524288xi32>) outs(%2284 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2286 = linalg.init_tensor [524288] : tensor<524288xi32>
%2287 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2283, %2285 : tensor<524288xi32>, tensor<524288xi32>) outs(%2286 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2288 = linalg.init_tensor [524288] : tensor<524288xi32>
%2289 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2281, %2287 : tensor<524288xi32>, tensor<524288xi32>) outs(%2288 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2290 = linalg.init_tensor [524288] : tensor<524288xi32>
%2291 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2281, %2289 : tensor<524288xi32>, tensor<524288xi32>) outs(%2290 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2292 = linalg.init_tensor [524288] : tensor<524288xi32>
%2293 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2289, %cst_159 : tensor<524288xi32>, tensor<524288xi32>) outs(%2292 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2294 = linalg.init_tensor [524288] : tensor<524288xi32>
%2295 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2289, %cst_159 : tensor<524288xi32>, tensor<524288xi32>) outs(%2294 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2296 = linalg.init_tensor [524288] : tensor<524288xi32>
%2297 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2293, %2295 : tensor<524288xi32>, tensor<524288xi32>) outs(%2296 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2298 = linalg.init_tensor [524288] : tensor<524288xi32>
%2299 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2291, %2297 : tensor<524288xi32>, tensor<524288xi32>) outs(%2298 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2300 = linalg.init_tensor [524288] : tensor<524288xi32>
%2301 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2291, %2299 : tensor<524288xi32>, tensor<524288xi32>) outs(%2300 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2302 = linalg.init_tensor [524288] : tensor<524288xi32>
%2303 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2299, %cst_160 : tensor<524288xi32>, tensor<524288xi32>) outs(%2302 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2304 = linalg.init_tensor [524288] : tensor<524288xi32>
%2305 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2299, %cst_161 : tensor<524288xi32>, tensor<524288xi32>) outs(%2304 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2306 = linalg.init_tensor [524288] : tensor<524288xi32>
%2307 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2303, %2305 : tensor<524288xi32>, tensor<524288xi32>) outs(%2306 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2308 = linalg.init_tensor [524288] : tensor<524288xi32>
%2309 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2301, %2307 : tensor<524288xi32>, tensor<524288xi32>) outs(%2308 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2310 = linalg.init_tensor [524288] : tensor<524288xi32>
%2311 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2301, %2265 : tensor<524288xi32>, tensor<524288xi32>) outs(%2310 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2312 = linalg.init_tensor [524288] : tensor<524288xi32>
%2313 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2309, %2215 : tensor<524288xi32>, tensor<524288xi32>) outs(%2312 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2314 = linalg.init_tensor [524288] : tensor<524288xi32>
%2315 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2313, %cst_156 : tensor<524288xi32>, tensor<524288xi32>) outs(%2314 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2316 = linalg.init_tensor [524288] : tensor<524288xi32>
%2317 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2311, %2315 : tensor<524288xi32>, tensor<524288xi32>) outs(%2316 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2318 = linalg.init_tensor [524288] : tensor<524288xi32>
%2319 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2315, %cst_163 : tensor<524288xi32>, tensor<524288xi32>) outs(%2318 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2320 = linalg.init_tensor [524288] : tensor<524288xi32>
%2321 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2315, %cst_164 : tensor<524288xi32>, tensor<524288xi32>) outs(%2320 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2322 = linalg.init_tensor [524288] : tensor<524288xi32>
%2323 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2319, %2321 : tensor<524288xi32>, tensor<524288xi32>) outs(%2322 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2324 = linalg.init_tensor [524288] : tensor<524288xi32>
%2325 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2317, %2323 : tensor<524288xi32>, tensor<524288xi32>) outs(%2324 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2326 = linalg.init_tensor [524288] : tensor<524288xi32>
%2327 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2317, %2325 : tensor<524288xi32>, tensor<524288xi32>) outs(%2326 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2328 = linalg.init_tensor [524288] : tensor<524288xi32>
%2329 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2325, %cst_165 : tensor<524288xi32>, tensor<524288xi32>) outs(%2328 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2330 = linalg.init_tensor [524288] : tensor<524288xi32>
%2331 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2325, %cst_166 : tensor<524288xi32>, tensor<524288xi32>) outs(%2330 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2332 = linalg.init_tensor [524288] : tensor<524288xi32>
%2333 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2329, %2331 : tensor<524288xi32>, tensor<524288xi32>) outs(%2332 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2334 = linalg.init_tensor [524288] : tensor<524288xi32>
%2335 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2327, %2333 : tensor<524288xi32>, tensor<524288xi32>) outs(%2334 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2336 = linalg.init_tensor [524288] : tensor<524288xi32>
%2337 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2327, %2335 : tensor<524288xi32>, tensor<524288xi32>) outs(%2336 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2338 = linalg.init_tensor [524288] : tensor<524288xi32>
%2339 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2335, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2338 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2340 = linalg.init_tensor [524288] : tensor<524288xi32>
%2341 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2335, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2340 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2342 = linalg.init_tensor [524288] : tensor<524288xi32>
%2343 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2339, %2341 : tensor<524288xi32>, tensor<524288xi32>) outs(%2342 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2344 = linalg.init_tensor [524288] : tensor<524288xi32>
%2345 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2337, %2343 : tensor<524288xi32>, tensor<524288xi32>) outs(%2344 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2346 = linalg.init_tensor [524288] : tensor<524288xi32>
%2347 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2337, %2345 : tensor<524288xi32>, tensor<524288xi32>) outs(%2346 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2348 = linalg.init_tensor [524288] : tensor<524288xi32>
%2349 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2345, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2348 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2350 = linalg.init_tensor [524288] : tensor<524288xi32>
%2351 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2345, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2350 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2352 = linalg.init_tensor [524288] : tensor<524288xi32>
%2353 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2349, %2351 : tensor<524288xi32>, tensor<524288xi32>) outs(%2352 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2354 = linalg.init_tensor [524288] : tensor<524288xi32>
%2355 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2347, %2353 : tensor<524288xi32>, tensor<524288xi32>) outs(%2354 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2356 = linalg.init_tensor [524288] : tensor<524288xi32>
%2357 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2347, %2215 : tensor<524288xi32>, tensor<524288xi32>) outs(%2356 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2358 = linalg.init_tensor [524288] : tensor<524288xi32>
%2359 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2355, %2219 : tensor<524288xi32>, tensor<524288xi32>) outs(%2358 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2360 = linalg.init_tensor [524288] : tensor<524288xi32>
%2361 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2359, %cst_158 : tensor<524288xi32>, tensor<524288xi32>) outs(%2360 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2362 = linalg.init_tensor [524288] : tensor<524288xi32>
%2363 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2357, %2361 : tensor<524288xi32>, tensor<524288xi32>) outs(%2362 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2364 = linalg.init_tensor [524288] : tensor<524288xi32>
%2365 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2361, %cst_166 : tensor<524288xi32>, tensor<524288xi32>) outs(%2364 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2366 = linalg.init_tensor [524288] : tensor<524288xi32>
%2367 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2361, %cst_165 : tensor<524288xi32>, tensor<524288xi32>) outs(%2366 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2368 = linalg.init_tensor [524288] : tensor<524288xi32>
%2369 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2365, %2367 : tensor<524288xi32>, tensor<524288xi32>) outs(%2368 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2370 = linalg.init_tensor [524288] : tensor<524288xi32>
%2371 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2363, %2369 : tensor<524288xi32>, tensor<524288xi32>) outs(%2370 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2372 = linalg.init_tensor [524288] : tensor<524288xi32>
%2373 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2363, %2371 : tensor<524288xi32>, tensor<524288xi32>) outs(%2372 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2374 = linalg.init_tensor [524288] : tensor<524288xi32>
%2375 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2371, %cst_157 : tensor<524288xi32>, tensor<524288xi32>) outs(%2374 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2376 = linalg.init_tensor [524288] : tensor<524288xi32>
%2377 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2371, %cst_158 : tensor<524288xi32>, tensor<524288xi32>) outs(%2376 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2378 = linalg.init_tensor [524288] : tensor<524288xi32>
%2379 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2375, %2377 : tensor<524288xi32>, tensor<524288xi32>) outs(%2378 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2380 = linalg.init_tensor [524288] : tensor<524288xi32>
%2381 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2373, %2379 : tensor<524288xi32>, tensor<524288xi32>) outs(%2380 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2382 = linalg.init_tensor [524288] : tensor<524288xi32>
%2383 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2373, %2381 : tensor<524288xi32>, tensor<524288xi32>) outs(%2382 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2384 = linalg.init_tensor [524288] : tensor<524288xi32>
%2385 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2381, %cst_159 : tensor<524288xi32>, tensor<524288xi32>) outs(%2384 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2386 = linalg.init_tensor [524288] : tensor<524288xi32>
%2387 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2381, %cst_159 : tensor<524288xi32>, tensor<524288xi32>) outs(%2386 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2388 = linalg.init_tensor [524288] : tensor<524288xi32>
%2389 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2385, %2387 : tensor<524288xi32>, tensor<524288xi32>) outs(%2388 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2390 = linalg.init_tensor [524288] : tensor<524288xi32>
%2391 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2383, %2389 : tensor<524288xi32>, tensor<524288xi32>) outs(%2390 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2392 = linalg.init_tensor [524288] : tensor<524288xi32>
%2393 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2383, %2391 : tensor<524288xi32>, tensor<524288xi32>) outs(%2392 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2394 = linalg.init_tensor [524288] : tensor<524288xi32>
%2395 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2391, %cst_160 : tensor<524288xi32>, tensor<524288xi32>) outs(%2394 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2396 = linalg.init_tensor [524288] : tensor<524288xi32>
%2397 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2391, %cst_161 : tensor<524288xi32>, tensor<524288xi32>) outs(%2396 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2398 = linalg.init_tensor [524288] : tensor<524288xi32>
%2399 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2395, %2397 : tensor<524288xi32>, tensor<524288xi32>) outs(%2398 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2400 = linalg.init_tensor [524288] : tensor<524288xi32>
%2401 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2393, %2399 : tensor<524288xi32>, tensor<524288xi32>) outs(%2400 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2402 = linalg.init_tensor [524288] : tensor<524288xi32>
%2403 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2393, %2219 : tensor<524288xi32>, tensor<524288xi32>) outs(%2402 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2404 = linalg.init_tensor [524288] : tensor<524288xi32>
%2405 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2401, %2265 : tensor<524288xi32>, tensor<524288xi32>) outs(%2404 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2406 = linalg.init_tensor [524288] : tensor<524288xi32>
%2407 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2405, %cst_162 : tensor<524288xi32>, tensor<524288xi32>) outs(%2406 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2408 = linalg.init_tensor [524288] : tensor<524288xi32>
%2409 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2403, %2407 : tensor<524288xi32>, tensor<524288xi32>) outs(%2408 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2410 = linalg.init_tensor [524288] : tensor<524288xi32>
%2411 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2407, %cst_163 : tensor<524288xi32>, tensor<524288xi32>) outs(%2410 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2412 = linalg.init_tensor [524288] : tensor<524288xi32>
%2413 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2407, %cst_164 : tensor<524288xi32>, tensor<524288xi32>) outs(%2412 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2414 = linalg.init_tensor [524288] : tensor<524288xi32>
%2415 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2411, %2413 : tensor<524288xi32>, tensor<524288xi32>) outs(%2414 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2416 = linalg.init_tensor [524288] : tensor<524288xi32>
%2417 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2409, %2415 : tensor<524288xi32>, tensor<524288xi32>) outs(%2416 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2418 = linalg.init_tensor [524288] : tensor<524288xi32>
%2419 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2409, %2417 : tensor<524288xi32>, tensor<524288xi32>) outs(%2418 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2420 = linalg.init_tensor [524288] : tensor<524288xi32>
%2421 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2417, %cst_165 : tensor<524288xi32>, tensor<524288xi32>) outs(%2420 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2422 = linalg.init_tensor [524288] : tensor<524288xi32>
%2423 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2417, %cst_166 : tensor<524288xi32>, tensor<524288xi32>) outs(%2422 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2424 = linalg.init_tensor [524288] : tensor<524288xi32>
%2425 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2421, %2423 : tensor<524288xi32>, tensor<524288xi32>) outs(%2424 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2426 = linalg.init_tensor [524288] : tensor<524288xi32>
%2427 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2419, %2425 : tensor<524288xi32>, tensor<524288xi32>) outs(%2426 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2428 = linalg.init_tensor [524288] : tensor<524288xi32>
%2429 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2419, %2427 : tensor<524288xi32>, tensor<524288xi32>) outs(%2428 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2430 = linalg.init_tensor [524288] : tensor<524288xi32>
%2431 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2427, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2430 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2432 = linalg.init_tensor [524288] : tensor<524288xi32>
%2433 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2427, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2432 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2434 = linalg.init_tensor [524288] : tensor<524288xi32>
%2435 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2431, %2433 : tensor<524288xi32>, tensor<524288xi32>) outs(%2434 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2436 = linalg.init_tensor [524288] : tensor<524288xi32>
%2437 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2429, %2435 : tensor<524288xi32>, tensor<524288xi32>) outs(%2436 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2438 = linalg.init_tensor [524288] : tensor<524288xi32>
%2439 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2429, %2437 : tensor<524288xi32>, tensor<524288xi32>) outs(%2438 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2440 = linalg.init_tensor [524288] : tensor<524288xi32>
%2441 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2437, %cst_167 : tensor<524288xi32>, tensor<524288xi32>) outs(%2440 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2442 = linalg.init_tensor [524288] : tensor<524288xi32>
%2443 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2437, %cst_168 : tensor<524288xi32>, tensor<524288xi32>) outs(%2442 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2444 = linalg.init_tensor [524288] : tensor<524288xi32>
%2445 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2441, %2443 : tensor<524288xi32>, tensor<524288xi32>) outs(%2444 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2446 = linalg.init_tensor [524288] : tensor<524288xi32>
%2447 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2439, %2445 : tensor<524288xi32>, tensor<524288xi32>) outs(%2446 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2448 = linalg.init_tensor [524288] : tensor<524288xi32>
%2449 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2439, %2265 : tensor<524288xi32>, tensor<524288xi32>) outs(%2448 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2450 = linalg.init_tensor [524288] : tensor<524288xi32>
%2451 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2447, %2215 : tensor<524288xi32>, tensor<524288xi32>) outs(%2450 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2452 = linalg.init_tensor [524288] : tensor<524288xi32>
%2453 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2451, %cst_169 : tensor<524288xi32>, tensor<524288xi32>) outs(%2452 : tensor<524288xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<524288xi32>
%2454 = linalg.init_tensor [1048576] : tensor<1048576xi32>
%2455 = linalg.fill(%c0_i32, %2454) : i32, tensor<1048576xi32> -> tensor<1048576xi32>
%2456 = tensor.insert_slice %2449 into %2455[0] [524288] [1] : tensor<524288xi32> into tensor<1048576xi32>
%2457 = tensor.insert_slice %2453 into %2456[524288] [524288] [1] : tensor<524288xi32> into tensor<1048576xi32>
%2458 = linalg.tensor_expand_shape %2457 [[0, 1]] : tensor<1048576xi32> into tensor<1024x1024xi32>
%2459 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xi32>
%2460 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2458, %cst_170 : tensor<1024x1024xi32>, tensor<1024x1024xi32>) outs(%2459 : tensor<1024x1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024x1024xi32>
%2461 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xi32>
%2462 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2460, %cst_171 : tensor<1024x1024xi32>, tensor<1024x1024xi32>) outs(%2461 : tensor<1024x1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024x1024xi32>
%2463 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2464 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2462 : tensor<1024x1024xi32>) outs(%2463 : tensor<1024x1024xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2465 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2466 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2464, %cst_90 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2465 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2467 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2468 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%896 : tensor<1x1xf32>) outs(%2467 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x1024xf32>
%2469 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2470 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2466, %2468 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2469 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2471 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2472 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%627 : tensor<1x1xf32>) outs(%2471 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x1024xf32>
%2473 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2474 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2470, %2472 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2473 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2475 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2476 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2472, %2474 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2475 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2477 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2478 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2476 : tensor<1024x1024xf32>) outs(%2477 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2479 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xi1>
%2480 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2478, %cst_90 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2479 : tensor<1024x1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024x1024xi1>
%2481 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2482 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2476, %cst_91 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2481 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2483 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2484 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2476 : tensor<1024x1024xf32>) outs(%2483 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2485 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2486 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2484, %2476 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2485 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2487 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2488 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2486, %cst_90 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2487 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2489 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2490 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2488 : tensor<1024x1024xf32>) outs(%2489 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2491 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2492 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2490 : tensor<1024x1024xf32>) outs(%2491 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2493 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xi1>
%2494 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2492, %cst_92 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2493 : tensor<1024x1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024x1024xi1>
%2495 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2496 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_93, %cst_94 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2495 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2497 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2498 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_95, %cst_96 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2497 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2499 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2500 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_97, %cst_98 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2499 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2501 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2502 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_99, %cst_100 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2501 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2503 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2504 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_101, %cst_102 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2503 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2505 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2506 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_103, %cst_104 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2505 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2507 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2508 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_105, %cst_106 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2507 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2509 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2510 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_107, %cst_108 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2509 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2511 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2512 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %cst_109, %cst_110 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2511 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2513 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2514 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2492, %cst_111 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2513 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2515 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2516 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2492 : tensor<1024x1024xf32>) outs(%2515 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2517 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2518 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2516, %cst_112 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2517 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2519 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2520 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2494, %2514, %2518 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2519 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2521 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2522 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2512, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2521 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2523 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2524 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2510, %2522 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2523 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2525 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2526 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2524, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2525 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2527 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2528 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2508, %2526 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2527 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2529 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2530 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2528, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2529 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2531 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2532 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2506, %2530 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2531 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2533 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2534 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2532, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2533 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2535 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2536 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2504, %2534 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2535 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2537 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2538 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2536, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2537 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2539 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2540 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2502, %2538 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2539 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2541 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2542 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2540, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2541 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2543 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2544 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2500, %2542 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2543 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2545 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2546 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2544, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2545 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2547 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2548 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2498, %2546 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2547 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2549 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2550 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2548, %2520 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2549 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2551 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2552 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2496, %2550 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2551 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2553 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2554 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2552, %2476 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2553 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2555 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2556 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2480, %2482, %2554 : tensor<1024x1024xi1>, tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2555 : tensor<1024x1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2557 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2558 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2556, %cst_172 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2557 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2559 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2560 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1028 : tensor<f32>) outs(%2559 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x1024xf32>
%2561 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2562 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2560, %2558 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2561 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2563 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2564 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1068 : tensor<f32>) outs(%2563 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x1024xf32>
%2565 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2566 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2564, %2562 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2565 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.minf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2567 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%2568 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2566, %cst_173 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%2567 : tensor<1024x1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x1024xf32>
%2569 = tensor.extract_slice %2201[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2570 = linalg.tensor_collapse_shape %2569 [] : tensor<1xi32> into tensor<i32>
%2571 = tensor.extract_slice %2201[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2572 = linalg.tensor_collapse_shape %2571 [] : tensor<1xi32> into tensor<i32>
%2573 = linalg.init_tensor [] : tensor<i32>
%2574 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2570, %2572 : tensor<i32>, tensor<i32>) outs(%2573 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2575 = linalg.init_tensor [] : tensor<i32>
%2576 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2574, %cst_241 : tensor<i32>, tensor<i32>) outs(%2575 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2577 = linalg.init_tensor [512] : tensor<512xi32>
%2578 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2570 : tensor<i32>) outs(%2577 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%2579 = linalg.init_tensor [512] : tensor<512xi32>
%2580 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1085, %2578 : tensor<512xi32>, tensor<512xi32>) outs(%2579 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2581 = linalg.init_tensor [512] : tensor<512xi32>
%2582 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2572 : tensor<i32>) outs(%2581 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%2583 = linalg.init_tensor [512] : tensor<512xi32>
%2584 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%1086, %2582 : tensor<512xi32>, tensor<512xi32>) outs(%2583 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2585 = linalg.init_tensor [512] : tensor<512xi32>
%2586 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2580, %2584 : tensor<512xi32>, tensor<512xi32>) outs(%2585 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2587 = linalg.init_tensor [512] : tensor<512xi32>
%2588 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2584, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%2587 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2589 = linalg.init_tensor [512] : tensor<512xi32>
%2590 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2584, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%2589 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2591 = linalg.init_tensor [512] : tensor<512xi32>
%2592 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2588, %2590 : tensor<512xi32>, tensor<512xi32>) outs(%2591 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2593 = linalg.init_tensor [512] : tensor<512xi32>
%2594 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2586, %2592 : tensor<512xi32>, tensor<512xi32>) outs(%2593 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2595 = linalg.init_tensor [512] : tensor<512xi32>
%2596 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2586, %2594 : tensor<512xi32>, tensor<512xi32>) outs(%2595 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2597 = linalg.init_tensor [512] : tensor<512xi32>
%2598 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2594, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%2597 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2599 = linalg.init_tensor [512] : tensor<512xi32>
%2600 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2594, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%2599 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2601 = linalg.init_tensor [512] : tensor<512xi32>
%2602 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2598, %2600 : tensor<512xi32>, tensor<512xi32>) outs(%2601 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2603 = linalg.init_tensor [512] : tensor<512xi32>
%2604 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2596, %2602 : tensor<512xi32>, tensor<512xi32>) outs(%2603 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2605 = linalg.init_tensor [512] : tensor<512xi32>
%2606 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2596, %2604 : tensor<512xi32>, tensor<512xi32>) outs(%2605 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2607 = linalg.init_tensor [512] : tensor<512xi32>
%2608 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2604, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2607 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2609 = linalg.init_tensor [512] : tensor<512xi32>
%2610 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2604, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2609 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2611 = linalg.init_tensor [512] : tensor<512xi32>
%2612 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2608, %2610 : tensor<512xi32>, tensor<512xi32>) outs(%2611 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2613 = linalg.init_tensor [512] : tensor<512xi32>
%2614 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2606, %2612 : tensor<512xi32>, tensor<512xi32>) outs(%2613 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2615 = linalg.init_tensor [512] : tensor<512xi32>
%2616 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2606, %2614 : tensor<512xi32>, tensor<512xi32>) outs(%2615 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2617 = linalg.init_tensor [512] : tensor<512xi32>
%2618 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2614, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2617 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2619 = linalg.init_tensor [512] : tensor<512xi32>
%2620 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2614, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2619 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2621 = linalg.init_tensor [512] : tensor<512xi32>
%2622 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2618, %2620 : tensor<512xi32>, tensor<512xi32>) outs(%2621 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2623 = linalg.init_tensor [512] : tensor<512xi32>
%2624 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2616, %2622 : tensor<512xi32>, tensor<512xi32>) outs(%2623 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2625 = linalg.init_tensor [512] : tensor<512xi32>
%2626 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2616, %2582 : tensor<512xi32>, tensor<512xi32>) outs(%2625 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2627 = linalg.init_tensor [512] : tensor<512xi32>
%2628 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2576 : tensor<i32>) outs(%2627 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<512xi32>
%2629 = linalg.init_tensor [512] : tensor<512xi32>
%2630 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2624, %2628 : tensor<512xi32>, tensor<512xi32>) outs(%2629 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2631 = linalg.init_tensor [512] : tensor<512xi32>
%2632 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2630, %cst_174 : tensor<512xi32>, tensor<512xi32>) outs(%2631 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2633 = linalg.init_tensor [512] : tensor<512xi32>
%2634 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2626, %2632 : tensor<512xi32>, tensor<512xi32>) outs(%2633 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2635 = linalg.init_tensor [512] : tensor<512xi32>
%2636 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2632, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%2635 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2637 = linalg.init_tensor [512] : tensor<512xi32>
%2638 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2632, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%2637 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2639 = linalg.init_tensor [512] : tensor<512xi32>
%2640 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2636, %2638 : tensor<512xi32>, tensor<512xi32>) outs(%2639 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2641 = linalg.init_tensor [512] : tensor<512xi32>
%2642 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2634, %2640 : tensor<512xi32>, tensor<512xi32>) outs(%2641 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2643 = linalg.init_tensor [512] : tensor<512xi32>
%2644 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2634, %2642 : tensor<512xi32>, tensor<512xi32>) outs(%2643 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2645 = linalg.init_tensor [512] : tensor<512xi32>
%2646 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2642, %cst_176 : tensor<512xi32>, tensor<512xi32>) outs(%2645 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2647 = linalg.init_tensor [512] : tensor<512xi32>
%2648 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2642, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%2647 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2649 = linalg.init_tensor [512] : tensor<512xi32>
%2650 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2646, %2648 : tensor<512xi32>, tensor<512xi32>) outs(%2649 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2651 = linalg.init_tensor [512] : tensor<512xi32>
%2652 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2644, %2650 : tensor<512xi32>, tensor<512xi32>) outs(%2651 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2653 = linalg.init_tensor [512] : tensor<512xi32>
%2654 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2644, %2652 : tensor<512xi32>, tensor<512xi32>) outs(%2653 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2655 = linalg.init_tensor [512] : tensor<512xi32>
%2656 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2652, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%2655 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2657 = linalg.init_tensor [512] : tensor<512xi32>
%2658 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2652, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%2657 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2659 = linalg.init_tensor [512] : tensor<512xi32>
%2660 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2656, %2658 : tensor<512xi32>, tensor<512xi32>) outs(%2659 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2661 = linalg.init_tensor [512] : tensor<512xi32>
%2662 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2654, %2660 : tensor<512xi32>, tensor<512xi32>) outs(%2661 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2663 = linalg.init_tensor [512] : tensor<512xi32>
%2664 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2654, %2662 : tensor<512xi32>, tensor<512xi32>) outs(%2663 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2665 = linalg.init_tensor [512] : tensor<512xi32>
%2666 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2662, %cst_179 : tensor<512xi32>, tensor<512xi32>) outs(%2665 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2667 = linalg.init_tensor [512] : tensor<512xi32>
%2668 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2662, %cst_180 : tensor<512xi32>, tensor<512xi32>) outs(%2667 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2669 = linalg.init_tensor [512] : tensor<512xi32>
%2670 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2666, %2668 : tensor<512xi32>, tensor<512xi32>) outs(%2669 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2671 = linalg.init_tensor [512] : tensor<512xi32>
%2672 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2664, %2670 : tensor<512xi32>, tensor<512xi32>) outs(%2671 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2673 = linalg.init_tensor [512] : tensor<512xi32>
%2674 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2664, %2628 : tensor<512xi32>, tensor<512xi32>) outs(%2673 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2675 = linalg.init_tensor [512] : tensor<512xi32>
%2676 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2672, %2578 : tensor<512xi32>, tensor<512xi32>) outs(%2675 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2677 = linalg.init_tensor [512] : tensor<512xi32>
%2678 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2676, %cst_175 : tensor<512xi32>, tensor<512xi32>) outs(%2677 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2679 = linalg.init_tensor [512] : tensor<512xi32>
%2680 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2674, %2678 : tensor<512xi32>, tensor<512xi32>) outs(%2679 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2681 = linalg.init_tensor [512] : tensor<512xi32>
%2682 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2678, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%2681 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2683 = linalg.init_tensor [512] : tensor<512xi32>
%2684 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2678, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%2683 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2685 = linalg.init_tensor [512] : tensor<512xi32>
%2686 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2682, %2684 : tensor<512xi32>, tensor<512xi32>) outs(%2685 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2687 = linalg.init_tensor [512] : tensor<512xi32>
%2688 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2680, %2686 : tensor<512xi32>, tensor<512xi32>) outs(%2687 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2689 = linalg.init_tensor [512] : tensor<512xi32>
%2690 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2680, %2688 : tensor<512xi32>, tensor<512xi32>) outs(%2689 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2691 = linalg.init_tensor [512] : tensor<512xi32>
%2692 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2688, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%2691 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2693 = linalg.init_tensor [512] : tensor<512xi32>
%2694 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2688, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%2693 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2695 = linalg.init_tensor [512] : tensor<512xi32>
%2696 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2692, %2694 : tensor<512xi32>, tensor<512xi32>) outs(%2695 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2697 = linalg.init_tensor [512] : tensor<512xi32>
%2698 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2690, %2696 : tensor<512xi32>, tensor<512xi32>) outs(%2697 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2699 = linalg.init_tensor [512] : tensor<512xi32>
%2700 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2690, %2698 : tensor<512xi32>, tensor<512xi32>) outs(%2699 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2701 = linalg.init_tensor [512] : tensor<512xi32>
%2702 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2698, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2701 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2703 = linalg.init_tensor [512] : tensor<512xi32>
%2704 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2698, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2703 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2705 = linalg.init_tensor [512] : tensor<512xi32>
%2706 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2702, %2704 : tensor<512xi32>, tensor<512xi32>) outs(%2705 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2707 = linalg.init_tensor [512] : tensor<512xi32>
%2708 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2700, %2706 : tensor<512xi32>, tensor<512xi32>) outs(%2707 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2709 = linalg.init_tensor [512] : tensor<512xi32>
%2710 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2700, %2708 : tensor<512xi32>, tensor<512xi32>) outs(%2709 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2711 = linalg.init_tensor [512] : tensor<512xi32>
%2712 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2708, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2711 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2713 = linalg.init_tensor [512] : tensor<512xi32>
%2714 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2708, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2713 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2715 = linalg.init_tensor [512] : tensor<512xi32>
%2716 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2712, %2714 : tensor<512xi32>, tensor<512xi32>) outs(%2715 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2717 = linalg.init_tensor [512] : tensor<512xi32>
%2718 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2710, %2716 : tensor<512xi32>, tensor<512xi32>) outs(%2717 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2719 = linalg.init_tensor [512] : tensor<512xi32>
%2720 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2710, %2578 : tensor<512xi32>, tensor<512xi32>) outs(%2719 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2721 = linalg.init_tensor [512] : tensor<512xi32>
%2722 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2718, %2582 : tensor<512xi32>, tensor<512xi32>) outs(%2721 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2723 = linalg.init_tensor [512] : tensor<512xi32>
%2724 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2722, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%2723 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2725 = linalg.init_tensor [512] : tensor<512xi32>
%2726 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2720, %2724 : tensor<512xi32>, tensor<512xi32>) outs(%2725 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2727 = linalg.init_tensor [512] : tensor<512xi32>
%2728 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2724, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%2727 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2729 = linalg.init_tensor [512] : tensor<512xi32>
%2730 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2724, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%2729 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2731 = linalg.init_tensor [512] : tensor<512xi32>
%2732 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2728, %2730 : tensor<512xi32>, tensor<512xi32>) outs(%2731 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2733 = linalg.init_tensor [512] : tensor<512xi32>
%2734 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2726, %2732 : tensor<512xi32>, tensor<512xi32>) outs(%2733 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2735 = linalg.init_tensor [512] : tensor<512xi32>
%2736 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2726, %2734 : tensor<512xi32>, tensor<512xi32>) outs(%2735 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2737 = linalg.init_tensor [512] : tensor<512xi32>
%2738 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2734, %cst_176 : tensor<512xi32>, tensor<512xi32>) outs(%2737 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2739 = linalg.init_tensor [512] : tensor<512xi32>
%2740 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2734, %cst_177 : tensor<512xi32>, tensor<512xi32>) outs(%2739 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2741 = linalg.init_tensor [512] : tensor<512xi32>
%2742 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2738, %2740 : tensor<512xi32>, tensor<512xi32>) outs(%2741 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2743 = linalg.init_tensor [512] : tensor<512xi32>
%2744 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2736, %2742 : tensor<512xi32>, tensor<512xi32>) outs(%2743 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2745 = linalg.init_tensor [512] : tensor<512xi32>
%2746 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2736, %2744 : tensor<512xi32>, tensor<512xi32>) outs(%2745 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2747 = linalg.init_tensor [512] : tensor<512xi32>
%2748 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2744, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%2747 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2749 = linalg.init_tensor [512] : tensor<512xi32>
%2750 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2744, %cst_178 : tensor<512xi32>, tensor<512xi32>) outs(%2749 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2751 = linalg.init_tensor [512] : tensor<512xi32>
%2752 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2748, %2750 : tensor<512xi32>, tensor<512xi32>) outs(%2751 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2753 = linalg.init_tensor [512] : tensor<512xi32>
%2754 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2746, %2752 : tensor<512xi32>, tensor<512xi32>) outs(%2753 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2755 = linalg.init_tensor [512] : tensor<512xi32>
%2756 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2746, %2754 : tensor<512xi32>, tensor<512xi32>) outs(%2755 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2757 = linalg.init_tensor [512] : tensor<512xi32>
%2758 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2754, %cst_179 : tensor<512xi32>, tensor<512xi32>) outs(%2757 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2759 = linalg.init_tensor [512] : tensor<512xi32>
%2760 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2754, %cst_180 : tensor<512xi32>, tensor<512xi32>) outs(%2759 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2761 = linalg.init_tensor [512] : tensor<512xi32>
%2762 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2758, %2760 : tensor<512xi32>, tensor<512xi32>) outs(%2761 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2763 = linalg.init_tensor [512] : tensor<512xi32>
%2764 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2756, %2762 : tensor<512xi32>, tensor<512xi32>) outs(%2763 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2765 = linalg.init_tensor [512] : tensor<512xi32>
%2766 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2756, %2582 : tensor<512xi32>, tensor<512xi32>) outs(%2765 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2767 = linalg.init_tensor [512] : tensor<512xi32>
%2768 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2764, %2628 : tensor<512xi32>, tensor<512xi32>) outs(%2767 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2769 = linalg.init_tensor [512] : tensor<512xi32>
%2770 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2768, %cst_181 : tensor<512xi32>, tensor<512xi32>) outs(%2769 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2771 = linalg.init_tensor [512] : tensor<512xi32>
%2772 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2766, %2770 : tensor<512xi32>, tensor<512xi32>) outs(%2771 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2773 = linalg.init_tensor [512] : tensor<512xi32>
%2774 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2770, %cst_182 : tensor<512xi32>, tensor<512xi32>) outs(%2773 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2775 = linalg.init_tensor [512] : tensor<512xi32>
%2776 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2770, %cst_183 : tensor<512xi32>, tensor<512xi32>) outs(%2775 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2777 = linalg.init_tensor [512] : tensor<512xi32>
%2778 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2774, %2776 : tensor<512xi32>, tensor<512xi32>) outs(%2777 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2779 = linalg.init_tensor [512] : tensor<512xi32>
%2780 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2772, %2778 : tensor<512xi32>, tensor<512xi32>) outs(%2779 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2781 = linalg.init_tensor [512] : tensor<512xi32>
%2782 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2772, %2780 : tensor<512xi32>, tensor<512xi32>) outs(%2781 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2783 = linalg.init_tensor [512] : tensor<512xi32>
%2784 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2780, %cst_184 : tensor<512xi32>, tensor<512xi32>) outs(%2783 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2785 = linalg.init_tensor [512] : tensor<512xi32>
%2786 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2780, %cst_185 : tensor<512xi32>, tensor<512xi32>) outs(%2785 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2787 = linalg.init_tensor [512] : tensor<512xi32>
%2788 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2784, %2786 : tensor<512xi32>, tensor<512xi32>) outs(%2787 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2789 = linalg.init_tensor [512] : tensor<512xi32>
%2790 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2782, %2788 : tensor<512xi32>, tensor<512xi32>) outs(%2789 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2791 = linalg.init_tensor [512] : tensor<512xi32>
%2792 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2782, %2790 : tensor<512xi32>, tensor<512xi32>) outs(%2791 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2793 = linalg.init_tensor [512] : tensor<512xi32>
%2794 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2790, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2793 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2795 = linalg.init_tensor [512] : tensor<512xi32>
%2796 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2790, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2795 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2797 = linalg.init_tensor [512] : tensor<512xi32>
%2798 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2794, %2796 : tensor<512xi32>, tensor<512xi32>) outs(%2797 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2799 = linalg.init_tensor [512] : tensor<512xi32>
%2800 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2792, %2798 : tensor<512xi32>, tensor<512xi32>) outs(%2799 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2801 = linalg.init_tensor [512] : tensor<512xi32>
%2802 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2792, %2800 : tensor<512xi32>, tensor<512xi32>) outs(%2801 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2803 = linalg.init_tensor [512] : tensor<512xi32>
%2804 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2800, %cst_186 : tensor<512xi32>, tensor<512xi32>) outs(%2803 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2805 = linalg.init_tensor [512] : tensor<512xi32>
%2806 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2800, %cst_187 : tensor<512xi32>, tensor<512xi32>) outs(%2805 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2807 = linalg.init_tensor [512] : tensor<512xi32>
%2808 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2804, %2806 : tensor<512xi32>, tensor<512xi32>) outs(%2807 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2809 = linalg.init_tensor [512] : tensor<512xi32>
%2810 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2802, %2808 : tensor<512xi32>, tensor<512xi32>) outs(%2809 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2811 = linalg.init_tensor [512] : tensor<512xi32>
%2812 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2802, %2628 : tensor<512xi32>, tensor<512xi32>) outs(%2811 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2813 = linalg.init_tensor [512] : tensor<512xi32>
%2814 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2810, %2578 : tensor<512xi32>, tensor<512xi32>) outs(%2813 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2815 = linalg.init_tensor [512] : tensor<512xi32>
%2816 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2814, %cst_188 : tensor<512xi32>, tensor<512xi32>) outs(%2815 : tensor<512xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<512xi32>
%2817 = linalg.init_tensor [1024] : tensor<1024xi32>
%2818 = linalg.fill(%c0_i32, %2817) : i32, tensor<1024xi32> -> tensor<1024xi32>
%2819 = tensor.insert_slice %2812 into %2818[0] [512] [1] : tensor<512xi32> into tensor<1024xi32>
%2820 = tensor.insert_slice %2816 into %2819[512] [512] [1] : tensor<512xi32> into tensor<1024xi32>
%2821 = linalg.init_tensor [1024] : tensor<1024xi32>
%2822 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2820, %cst_189 : tensor<1024xi32>, tensor<1024xi32>) outs(%2821 : tensor<1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024xi32>
%2823 = linalg.init_tensor [1024] : tensor<1024xi32>
%2824 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2822, %cst_190 : tensor<1024xi32>, tensor<1024xi32>) outs(%2823 : tensor<1024xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024xi32>
%2825 = linalg.init_tensor [1024] : tensor<1024xf32>
%2826 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2824 : tensor<1024xi32>) outs(%2825 : tensor<1024xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2827 = linalg.init_tensor [1024] : tensor<1024xf32>
%2828 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2826, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%2827 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2829 = linalg.init_tensor [1024] : tensor<1024xf32>
%2830 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2828, %cst_191 : tensor<1024xf32>, tensor<1024xf32>) outs(%2829 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2831 = linalg.init_tensor [1024] : tensor<1024xf32>
%2832 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2830, %cst_192 : tensor<1024xf32>, tensor<1024xf32>) outs(%2831 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2833 = linalg.init_tensor [1024] : tensor<1024xf32>
%2834 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2832, %cst_192 : tensor<1024xf32>, tensor<1024xf32>) outs(%2833 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2835 = linalg.init_tensor [1024] : tensor<1024xf32>
%2836 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2834 : tensor<1024xf32>) outs(%2835 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2837 = linalg.init_tensor [1024] : tensor<1024xi1>
%2838 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2836, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%2837 : tensor<1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024xi1>
%2839 = linalg.init_tensor [1024] : tensor<1024xf32>
%2840 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2834, %cst_68 : tensor<1024xf32>, tensor<1024xf32>) outs(%2839 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2841 = linalg.init_tensor [1024] : tensor<1024xf32>
%2842 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2834 : tensor<1024xf32>) outs(%2841 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2843 = linalg.init_tensor [1024] : tensor<1024xf32>
%2844 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2842, %2834 : tensor<1024xf32>, tensor<1024xf32>) outs(%2843 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2845 = linalg.init_tensor [1024] : tensor<1024xf32>
%2846 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2844, %cst_67 : tensor<1024xf32>, tensor<1024xf32>) outs(%2845 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2847 = linalg.init_tensor [1024] : tensor<1024xf32>
%2848 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2846 : tensor<1024xf32>) outs(%2847 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2849 = linalg.init_tensor [1024] : tensor<1024xf32>
%2850 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2848 : tensor<1024xf32>) outs(%2849 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2851 = linalg.init_tensor [1024] : tensor<1024xi1>
%2852 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2850, %cst_69 : tensor<1024xf32>, tensor<1024xf32>) outs(%2851 : tensor<1024xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024xi1>
%2853 = linalg.init_tensor [1024] : tensor<1024xf32>
%2854 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_70, %cst_71 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2853 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2855 = linalg.init_tensor [1024] : tensor<1024xf32>
%2856 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_72, %cst_73 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2855 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2857 = linalg.init_tensor [1024] : tensor<1024xf32>
%2858 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_74, %cst_75 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2857 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2859 = linalg.init_tensor [1024] : tensor<1024xf32>
%2860 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_76, %cst_77 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2859 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2861 = linalg.init_tensor [1024] : tensor<1024xf32>
%2862 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_78, %cst_79 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2861 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2863 = linalg.init_tensor [1024] : tensor<1024xf32>
%2864 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_80, %cst_81 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2863 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2865 = linalg.init_tensor [1024] : tensor<1024xf32>
%2866 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_82, %cst_83 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2865 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2867 = linalg.init_tensor [1024] : tensor<1024xf32>
%2868 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_84, %cst_85 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2867 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2869 = linalg.init_tensor [1024] : tensor<1024xf32>
%2870 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %cst_86, %cst_87 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2869 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2871 = linalg.init_tensor [1024] : tensor<1024xf32>
%2872 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2850, %cst_88 : tensor<1024xf32>, tensor<1024xf32>) outs(%2871 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2873 = linalg.init_tensor [1024] : tensor<1024xf32>
%2874 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%2850 : tensor<1024xf32>) outs(%2873 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2875 = linalg.init_tensor [1024] : tensor<1024xf32>
%2876 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2874, %cst_89 : tensor<1024xf32>, tensor<1024xf32>) outs(%2875 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2877 = linalg.init_tensor [1024] : tensor<1024xf32>
%2878 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2852, %2872, %2876 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2877 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2879 = linalg.init_tensor [1024] : tensor<1024xf32>
%2880 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2870, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2879 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2881 = linalg.init_tensor [1024] : tensor<1024xf32>
%2882 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2868, %2880 : tensor<1024xf32>, tensor<1024xf32>) outs(%2881 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2883 = linalg.init_tensor [1024] : tensor<1024xf32>
%2884 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2882, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2883 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2885 = linalg.init_tensor [1024] : tensor<1024xf32>
%2886 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2866, %2884 : tensor<1024xf32>, tensor<1024xf32>) outs(%2885 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2887 = linalg.init_tensor [1024] : tensor<1024xf32>
%2888 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2886, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2887 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2889 = linalg.init_tensor [1024] : tensor<1024xf32>
%2890 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2864, %2888 : tensor<1024xf32>, tensor<1024xf32>) outs(%2889 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2891 = linalg.init_tensor [1024] : tensor<1024xf32>
%2892 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2890, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2891 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2893 = linalg.init_tensor [1024] : tensor<1024xf32>
%2894 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2862, %2892 : tensor<1024xf32>, tensor<1024xf32>) outs(%2893 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2895 = linalg.init_tensor [1024] : tensor<1024xf32>
%2896 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2894, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2895 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2897 = linalg.init_tensor [1024] : tensor<1024xf32>
%2898 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2860, %2896 : tensor<1024xf32>, tensor<1024xf32>) outs(%2897 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2899 = linalg.init_tensor [1024] : tensor<1024xf32>
%2900 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2898, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2899 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2901 = linalg.init_tensor [1024] : tensor<1024xf32>
%2902 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2858, %2900 : tensor<1024xf32>, tensor<1024xf32>) outs(%2901 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2903 = linalg.init_tensor [1024] : tensor<1024xf32>
%2904 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2902, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2903 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2905 = linalg.init_tensor [1024] : tensor<1024xf32>
%2906 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2856, %2904 : tensor<1024xf32>, tensor<1024xf32>) outs(%2905 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2907 = linalg.init_tensor [1024] : tensor<1024xf32>
%2908 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2906, %2878 : tensor<1024xf32>, tensor<1024xf32>) outs(%2907 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2909 = linalg.init_tensor [1024] : tensor<1024xf32>
%2910 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2854, %2908 : tensor<1024xf32>, tensor<1024xf32>) outs(%2909 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2911 = linalg.init_tensor [1024] : tensor<1024xf32>
%2912 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2910, %2834 : tensor<1024xf32>, tensor<1024xf32>) outs(%2911 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2913 = linalg.init_tensor [1024] : tensor<1024xf32>
%2914 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2838, %2840, %2912 : tensor<1024xi1>, tensor<1024xf32>, tensor<1024xf32>) outs(%2913 : tensor<1024xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2915 = linalg.init_tensor [1024] : tensor<1024xf32>
%2916 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2914, %cst_193 : tensor<1024xf32>, tensor<1024xf32>) outs(%2915 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2917 = linalg.init_tensor [1024] : tensor<1024xf32>
%2918 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2916, %cst_194 : tensor<1024xf32>, tensor<1024xf32>) outs(%2917 : tensor<1024xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024xf32>
%2919 = tensor.extract_slice %1942[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2920 = linalg.tensor_collapse_shape %2919 [] : tensor<1xi32> into tensor<i32>
%2921 = tensor.extract_slice %1942[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%2922 = linalg.tensor_collapse_shape %2921 [] : tensor<1xi32> into tensor<i32>
%2923 = linalg.init_tensor [] : tensor<i32>
%2924 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2920, %2922 : tensor<i32>, tensor<i32>) outs(%2923 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2925 = linalg.init_tensor [] : tensor<i32>
%2926 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%2924, %cst_241 : tensor<i32>, tensor<i32>) outs(%2925 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%2927 = linalg.init_tensor [2] : tensor<2xi32>
%2928 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2920 : tensor<i32>) outs(%2927 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%2929 = linalg.init_tensor [2] : tensor<2xi32>
%2930 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %2928 : tensor<2xi32>, tensor<2xi32>) outs(%2929 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2931 = linalg.init_tensor [2] : tensor<2xi32>
%2932 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2922 : tensor<i32>) outs(%2931 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%2933 = linalg.init_tensor [2] : tensor<2xi32>
%2934 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %2932 : tensor<2xi32>, tensor<2xi32>) outs(%2933 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2935 = linalg.init_tensor [2] : tensor<2xi32>
%2936 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2930, %2934 : tensor<2xi32>, tensor<2xi32>) outs(%2935 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2937 = linalg.init_tensor [2] : tensor<2xi32>
%2938 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2934, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%2937 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2939 = linalg.init_tensor [2] : tensor<2xi32>
%2940 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2934, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%2939 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2941 = linalg.init_tensor [2] : tensor<2xi32>
%2942 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2938, %2940 : tensor<2xi32>, tensor<2xi32>) outs(%2941 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2943 = linalg.init_tensor [2] : tensor<2xi32>
%2944 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2936, %2942 : tensor<2xi32>, tensor<2xi32>) outs(%2943 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2945 = linalg.init_tensor [2] : tensor<2xi32>
%2946 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2936, %2944 : tensor<2xi32>, tensor<2xi32>) outs(%2945 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2947 = linalg.init_tensor [2] : tensor<2xi32>
%2948 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2944, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2947 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2949 = linalg.init_tensor [2] : tensor<2xi32>
%2950 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2944, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2949 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2951 = linalg.init_tensor [2] : tensor<2xi32>
%2952 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2948, %2950 : tensor<2xi32>, tensor<2xi32>) outs(%2951 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2953 = linalg.init_tensor [2] : tensor<2xi32>
%2954 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2946, %2952 : tensor<2xi32>, tensor<2xi32>) outs(%2953 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2955 = linalg.init_tensor [2] : tensor<2xi32>
%2956 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2946, %2954 : tensor<2xi32>, tensor<2xi32>) outs(%2955 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2957 = linalg.init_tensor [2] : tensor<2xi32>
%2958 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2954, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2957 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2959 = linalg.init_tensor [2] : tensor<2xi32>
%2960 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2954, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2959 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2961 = linalg.init_tensor [2] : tensor<2xi32>
%2962 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2958, %2960 : tensor<2xi32>, tensor<2xi32>) outs(%2961 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2963 = linalg.init_tensor [2] : tensor<2xi32>
%2964 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2956, %2962 : tensor<2xi32>, tensor<2xi32>) outs(%2963 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2965 = linalg.init_tensor [2] : tensor<2xi32>
%2966 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2956, %2964 : tensor<2xi32>, tensor<2xi32>) outs(%2965 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2967 = linalg.init_tensor [2] : tensor<2xi32>
%2968 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2964, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%2967 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2969 = linalg.init_tensor [2] : tensor<2xi32>
%2970 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2964, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%2969 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2971 = linalg.init_tensor [2] : tensor<2xi32>
%2972 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2968, %2970 : tensor<2xi32>, tensor<2xi32>) outs(%2971 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2973 = linalg.init_tensor [2] : tensor<2xi32>
%2974 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2966, %2972 : tensor<2xi32>, tensor<2xi32>) outs(%2973 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2975 = linalg.init_tensor [2] : tensor<2xi32>
%2976 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2966, %2932 : tensor<2xi32>, tensor<2xi32>) outs(%2975 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2977 = linalg.init_tensor [2] : tensor<2xi32>
%2978 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%2926 : tensor<i32>) outs(%2977 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%2979 = linalg.init_tensor [2] : tensor<2xi32>
%2980 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2974, %2978 : tensor<2xi32>, tensor<2xi32>) outs(%2979 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2981 = linalg.init_tensor [2] : tensor<2xi32>
%2982 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2980, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%2981 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2983 = linalg.init_tensor [2] : tensor<2xi32>
%2984 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2976, %2982 : tensor<2xi32>, tensor<2xi32>) outs(%2983 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2985 = linalg.init_tensor [2] : tensor<2xi32>
%2986 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2982, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%2985 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2987 = linalg.init_tensor [2] : tensor<2xi32>
%2988 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2982, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%2987 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2989 = linalg.init_tensor [2] : tensor<2xi32>
%2990 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2986, %2988 : tensor<2xi32>, tensor<2xi32>) outs(%2989 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2991 = linalg.init_tensor [2] : tensor<2xi32>
%2992 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2984, %2990 : tensor<2xi32>, tensor<2xi32>) outs(%2991 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2993 = linalg.init_tensor [2] : tensor<2xi32>
%2994 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2984, %2992 : tensor<2xi32>, tensor<2xi32>) outs(%2993 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2995 = linalg.init_tensor [2] : tensor<2xi32>
%2996 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2992, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%2995 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2997 = linalg.init_tensor [2] : tensor<2xi32>
%2998 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2992, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%2997 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%2999 = linalg.init_tensor [2] : tensor<2xi32>
%3000 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2996, %2998 : tensor<2xi32>, tensor<2xi32>) outs(%2999 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3001 = linalg.init_tensor [2] : tensor<2xi32>
%3002 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2994, %3000 : tensor<2xi32>, tensor<2xi32>) outs(%3001 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3003 = linalg.init_tensor [2] : tensor<2xi32>
%3004 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%2994, %3002 : tensor<2xi32>, tensor<2xi32>) outs(%3003 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3005 = linalg.init_tensor [2] : tensor<2xi32>
%3006 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3002, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3005 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3007 = linalg.init_tensor [2] : tensor<2xi32>
%3008 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3002, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3007 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3009 = linalg.init_tensor [2] : tensor<2xi32>
%3010 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3006, %3008 : tensor<2xi32>, tensor<2xi32>) outs(%3009 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3011 = linalg.init_tensor [2] : tensor<2xi32>
%3012 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3004, %3010 : tensor<2xi32>, tensor<2xi32>) outs(%3011 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3013 = linalg.init_tensor [2] : tensor<2xi32>
%3014 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3004, %3012 : tensor<2xi32>, tensor<2xi32>) outs(%3013 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3015 = linalg.init_tensor [2] : tensor<2xi32>
%3016 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3012, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3015 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3017 = linalg.init_tensor [2] : tensor<2xi32>
%3018 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3012, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3017 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3019 = linalg.init_tensor [2] : tensor<2xi32>
%3020 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3016, %3018 : tensor<2xi32>, tensor<2xi32>) outs(%3019 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3021 = linalg.init_tensor [2] : tensor<2xi32>
%3022 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3014, %3020 : tensor<2xi32>, tensor<2xi32>) outs(%3021 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3023 = linalg.init_tensor [2] : tensor<2xi32>
%3024 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3014, %2978 : tensor<2xi32>, tensor<2xi32>) outs(%3023 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3025 = linalg.init_tensor [2] : tensor<2xi32>
%3026 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3022, %2928 : tensor<2xi32>, tensor<2xi32>) outs(%3025 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3027 = linalg.init_tensor [2] : tensor<2xi32>
%3028 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3026, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%3027 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3029 = linalg.init_tensor [2] : tensor<2xi32>
%3030 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3024, %3028 : tensor<2xi32>, tensor<2xi32>) outs(%3029 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3031 = linalg.init_tensor [2] : tensor<2xi32>
%3032 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3028, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3031 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3033 = linalg.init_tensor [2] : tensor<2xi32>
%3034 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3028, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3033 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3035 = linalg.init_tensor [2] : tensor<2xi32>
%3036 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3032, %3034 : tensor<2xi32>, tensor<2xi32>) outs(%3035 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3037 = linalg.init_tensor [2] : tensor<2xi32>
%3038 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3030, %3036 : tensor<2xi32>, tensor<2xi32>) outs(%3037 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3039 = linalg.init_tensor [2] : tensor<2xi32>
%3040 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3030, %3038 : tensor<2xi32>, tensor<2xi32>) outs(%3039 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3041 = linalg.init_tensor [2] : tensor<2xi32>
%3042 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3038, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3041 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3043 = linalg.init_tensor [2] : tensor<2xi32>
%3044 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3038, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3043 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3045 = linalg.init_tensor [2] : tensor<2xi32>
%3046 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3042, %3044 : tensor<2xi32>, tensor<2xi32>) outs(%3045 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3047 = linalg.init_tensor [2] : tensor<2xi32>
%3048 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3040, %3046 : tensor<2xi32>, tensor<2xi32>) outs(%3047 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3049 = linalg.init_tensor [2] : tensor<2xi32>
%3050 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3040, %3048 : tensor<2xi32>, tensor<2xi32>) outs(%3049 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3051 = linalg.init_tensor [2] : tensor<2xi32>
%3052 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3048, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3051 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3053 = linalg.init_tensor [2] : tensor<2xi32>
%3054 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3048, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3053 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3055 = linalg.init_tensor [2] : tensor<2xi32>
%3056 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3052, %3054 : tensor<2xi32>, tensor<2xi32>) outs(%3055 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3057 = linalg.init_tensor [2] : tensor<2xi32>
%3058 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3050, %3056 : tensor<2xi32>, tensor<2xi32>) outs(%3057 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3059 = linalg.init_tensor [2] : tensor<2xi32>
%3060 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3050, %3058 : tensor<2xi32>, tensor<2xi32>) outs(%3059 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3061 = linalg.init_tensor [2] : tensor<2xi32>
%3062 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3058, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3061 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3063 = linalg.init_tensor [2] : tensor<2xi32>
%3064 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3058, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3063 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3065 = linalg.init_tensor [2] : tensor<2xi32>
%3066 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3062, %3064 : tensor<2xi32>, tensor<2xi32>) outs(%3065 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3067 = linalg.init_tensor [2] : tensor<2xi32>
%3068 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3060, %3066 : tensor<2xi32>, tensor<2xi32>) outs(%3067 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3069 = linalg.init_tensor [2] : tensor<2xi32>
%3070 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3060, %2928 : tensor<2xi32>, tensor<2xi32>) outs(%3069 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3071 = linalg.init_tensor [2] : tensor<2xi32>
%3072 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3068, %2932 : tensor<2xi32>, tensor<2xi32>) outs(%3071 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3073 = linalg.init_tensor [2] : tensor<2xi32>
%3074 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3072, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3073 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3075 = linalg.init_tensor [2] : tensor<2xi32>
%3076 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3070, %3074 : tensor<2xi32>, tensor<2xi32>) outs(%3075 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3077 = linalg.init_tensor [2] : tensor<2xi32>
%3078 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3074, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3077 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3079 = linalg.init_tensor [2] : tensor<2xi32>
%3080 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3074, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3079 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3081 = linalg.init_tensor [2] : tensor<2xi32>
%3082 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3078, %3080 : tensor<2xi32>, tensor<2xi32>) outs(%3081 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3083 = linalg.init_tensor [2] : tensor<2xi32>
%3084 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3076, %3082 : tensor<2xi32>, tensor<2xi32>) outs(%3083 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3085 = linalg.init_tensor [2] : tensor<2xi32>
%3086 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3076, %3084 : tensor<2xi32>, tensor<2xi32>) outs(%3085 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3087 = linalg.init_tensor [2] : tensor<2xi32>
%3088 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3084, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%3087 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3089 = linalg.init_tensor [2] : tensor<2xi32>
%3090 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3084, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3089 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3091 = linalg.init_tensor [2] : tensor<2xi32>
%3092 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3088, %3090 : tensor<2xi32>, tensor<2xi32>) outs(%3091 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3093 = linalg.init_tensor [2] : tensor<2xi32>
%3094 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3086, %3092 : tensor<2xi32>, tensor<2xi32>) outs(%3093 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3095 = linalg.init_tensor [2] : tensor<2xi32>
%3096 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3086, %3094 : tensor<2xi32>, tensor<2xi32>) outs(%3095 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3097 = linalg.init_tensor [2] : tensor<2xi32>
%3098 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3094, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3097 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3099 = linalg.init_tensor [2] : tensor<2xi32>
%3100 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3094, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3099 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3101 = linalg.init_tensor [2] : tensor<2xi32>
%3102 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3098, %3100 : tensor<2xi32>, tensor<2xi32>) outs(%3101 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3103 = linalg.init_tensor [2] : tensor<2xi32>
%3104 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3096, %3102 : tensor<2xi32>, tensor<2xi32>) outs(%3103 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3105 = linalg.init_tensor [2] : tensor<2xi32>
%3106 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3096, %3104 : tensor<2xi32>, tensor<2xi32>) outs(%3105 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3107 = linalg.init_tensor [2] : tensor<2xi32>
%3108 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3104, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3107 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3109 = linalg.init_tensor [2] : tensor<2xi32>
%3110 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3104, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3109 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3111 = linalg.init_tensor [2] : tensor<2xi32>
%3112 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3108, %3110 : tensor<2xi32>, tensor<2xi32>) outs(%3111 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3113 = linalg.init_tensor [2] : tensor<2xi32>
%3114 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3106, %3112 : tensor<2xi32>, tensor<2xi32>) outs(%3113 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3115 = linalg.init_tensor [2] : tensor<2xi32>
%3116 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3106, %2932 : tensor<2xi32>, tensor<2xi32>) outs(%3115 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3117 = linalg.init_tensor [2] : tensor<2xi32>
%3118 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3114, %2978 : tensor<2xi32>, tensor<2xi32>) outs(%3117 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3119 = linalg.init_tensor [2] : tensor<2xi32>
%3120 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3118, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%3119 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3121 = linalg.init_tensor [2] : tensor<2xi32>
%3122 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3116, %3120 : tensor<2xi32>, tensor<2xi32>) outs(%3121 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3123 = linalg.init_tensor [2] : tensor<2xi32>
%3124 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3120, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3123 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3125 = linalg.init_tensor [2] : tensor<2xi32>
%3126 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3120, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3125 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3127 = linalg.init_tensor [2] : tensor<2xi32>
%3128 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3124, %3126 : tensor<2xi32>, tensor<2xi32>) outs(%3127 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3129 = linalg.init_tensor [2] : tensor<2xi32>
%3130 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3122, %3128 : tensor<2xi32>, tensor<2xi32>) outs(%3129 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3131 = linalg.init_tensor [2] : tensor<2xi32>
%3132 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3122, %3130 : tensor<2xi32>, tensor<2xi32>) outs(%3131 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3133 = linalg.init_tensor [2] : tensor<2xi32>
%3134 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3130, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3133 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3135 = linalg.init_tensor [2] : tensor<2xi32>
%3136 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3130, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3135 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3137 = linalg.init_tensor [2] : tensor<2xi32>
%3138 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3134, %3136 : tensor<2xi32>, tensor<2xi32>) outs(%3137 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3139 = linalg.init_tensor [2] : tensor<2xi32>
%3140 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3132, %3138 : tensor<2xi32>, tensor<2xi32>) outs(%3139 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3141 = linalg.init_tensor [2] : tensor<2xi32>
%3142 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3132, %3140 : tensor<2xi32>, tensor<2xi32>) outs(%3141 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3143 = linalg.init_tensor [2] : tensor<2xi32>
%3144 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3140, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3143 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3145 = linalg.init_tensor [2] : tensor<2xi32>
%3146 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3140, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3145 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3147 = linalg.init_tensor [2] : tensor<2xi32>
%3148 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3144, %3146 : tensor<2xi32>, tensor<2xi32>) outs(%3147 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3149 = linalg.init_tensor [2] : tensor<2xi32>
%3150 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3142, %3148 : tensor<2xi32>, tensor<2xi32>) outs(%3149 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3151 = linalg.init_tensor [2] : tensor<2xi32>
%3152 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3142, %3150 : tensor<2xi32>, tensor<2xi32>) outs(%3151 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3153 = linalg.init_tensor [2] : tensor<2xi32>
%3154 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3150, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3153 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3155 = linalg.init_tensor [2] : tensor<2xi32>
%3156 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3150, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3155 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3157 = linalg.init_tensor [2] : tensor<2xi32>
%3158 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3154, %3156 : tensor<2xi32>, tensor<2xi32>) outs(%3157 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3159 = linalg.init_tensor [2] : tensor<2xi32>
%3160 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3152, %3158 : tensor<2xi32>, tensor<2xi32>) outs(%3159 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3161 = linalg.init_tensor [2] : tensor<2xi32>
%3162 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3152, %2978 : tensor<2xi32>, tensor<2xi32>) outs(%3161 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3163 = linalg.init_tensor [2] : tensor<2xi32>
%3164 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3160, %2928 : tensor<2xi32>, tensor<2xi32>) outs(%3163 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3165 = linalg.init_tensor [2] : tensor<2xi32>
%3166 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3164, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%3165 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3167 = linalg.init_tensor [4] : tensor<4xi32>
%3168 = linalg.fill(%c0_i32, %3167) : i32, tensor<4xi32> -> tensor<4xi32>
%3169 = tensor.insert_slice %3162 into %3168[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3170 = tensor.insert_slice %3166 into %3169[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3171 = linalg.tensor_expand_shape %3170 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%3172 = tensor.extract_slice %3171[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%3173 = linalg.tensor_collapse_shape %3172 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%3174 = tensor.extract_slice %3173[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3175 = linalg.tensor_collapse_shape %3174 [] : tensor<1xi32> into tensor<i32>
%3176 = tensor.extract_slice %3173[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3177 = linalg.tensor_collapse_shape %3176 [] : tensor<1xi32> into tensor<i32>
%3178 = linalg.init_tensor [] : tensor<i32>
%3179 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3175, %3177 : tensor<i32>, tensor<i32>) outs(%3178 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3180 = linalg.init_tensor [] : tensor<i32>
%3181 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3179, %cst_241 : tensor<i32>, tensor<i32>) outs(%3180 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3182 = linalg.init_tensor [2] : tensor<2xi32>
%3183 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3175 : tensor<i32>) outs(%3182 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3184 = linalg.init_tensor [2] : tensor<2xi32>
%3185 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %3183 : tensor<2xi32>, tensor<2xi32>) outs(%3184 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3186 = linalg.init_tensor [2] : tensor<2xi32>
%3187 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3177 : tensor<i32>) outs(%3186 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3188 = linalg.init_tensor [2] : tensor<2xi32>
%3189 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %3187 : tensor<2xi32>, tensor<2xi32>) outs(%3188 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3190 = linalg.init_tensor [2] : tensor<2xi32>
%3191 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3185, %3189 : tensor<2xi32>, tensor<2xi32>) outs(%3190 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3192 = linalg.init_tensor [2] : tensor<2xi32>
%3193 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3189, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3192 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3194 = linalg.init_tensor [2] : tensor<2xi32>
%3195 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3189, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3194 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3196 = linalg.init_tensor [2] : tensor<2xi32>
%3197 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3193, %3195 : tensor<2xi32>, tensor<2xi32>) outs(%3196 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3198 = linalg.init_tensor [2] : tensor<2xi32>
%3199 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3191, %3197 : tensor<2xi32>, tensor<2xi32>) outs(%3198 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3200 = linalg.init_tensor [2] : tensor<2xi32>
%3201 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3191, %3199 : tensor<2xi32>, tensor<2xi32>) outs(%3200 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3202 = linalg.init_tensor [2] : tensor<2xi32>
%3203 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3199, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3202 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3204 = linalg.init_tensor [2] : tensor<2xi32>
%3205 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3199, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3204 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3206 = linalg.init_tensor [2] : tensor<2xi32>
%3207 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3203, %3205 : tensor<2xi32>, tensor<2xi32>) outs(%3206 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3208 = linalg.init_tensor [2] : tensor<2xi32>
%3209 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3201, %3207 : tensor<2xi32>, tensor<2xi32>) outs(%3208 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3210 = linalg.init_tensor [2] : tensor<2xi32>
%3211 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3201, %3209 : tensor<2xi32>, tensor<2xi32>) outs(%3210 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3212 = linalg.init_tensor [2] : tensor<2xi32>
%3213 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3209, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3212 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3214 = linalg.init_tensor [2] : tensor<2xi32>
%3215 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3209, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3214 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3216 = linalg.init_tensor [2] : tensor<2xi32>
%3217 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3213, %3215 : tensor<2xi32>, tensor<2xi32>) outs(%3216 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3218 = linalg.init_tensor [2] : tensor<2xi32>
%3219 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3211, %3217 : tensor<2xi32>, tensor<2xi32>) outs(%3218 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3220 = linalg.init_tensor [2] : tensor<2xi32>
%3221 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3211, %3219 : tensor<2xi32>, tensor<2xi32>) outs(%3220 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3222 = linalg.init_tensor [2] : tensor<2xi32>
%3223 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3219, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3222 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3224 = linalg.init_tensor [2] : tensor<2xi32>
%3225 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3219, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3224 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3226 = linalg.init_tensor [2] : tensor<2xi32>
%3227 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3223, %3225 : tensor<2xi32>, tensor<2xi32>) outs(%3226 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3228 = linalg.init_tensor [2] : tensor<2xi32>
%3229 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3221, %3227 : tensor<2xi32>, tensor<2xi32>) outs(%3228 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3230 = linalg.init_tensor [2] : tensor<2xi32>
%3231 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3221, %3187 : tensor<2xi32>, tensor<2xi32>) outs(%3230 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3232 = linalg.init_tensor [2] : tensor<2xi32>
%3233 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3181 : tensor<i32>) outs(%3232 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3234 = linalg.init_tensor [2] : tensor<2xi32>
%3235 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3229, %3233 : tensor<2xi32>, tensor<2xi32>) outs(%3234 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3236 = linalg.init_tensor [2] : tensor<2xi32>
%3237 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3235, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%3236 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3238 = linalg.init_tensor [2] : tensor<2xi32>
%3239 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3231, %3237 : tensor<2xi32>, tensor<2xi32>) outs(%3238 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3240 = linalg.init_tensor [2] : tensor<2xi32>
%3241 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3237, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3240 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3242 = linalg.init_tensor [2] : tensor<2xi32>
%3243 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3237, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3242 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3244 = linalg.init_tensor [2] : tensor<2xi32>
%3245 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3241, %3243 : tensor<2xi32>, tensor<2xi32>) outs(%3244 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3246 = linalg.init_tensor [2] : tensor<2xi32>
%3247 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3239, %3245 : tensor<2xi32>, tensor<2xi32>) outs(%3246 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3248 = linalg.init_tensor [2] : tensor<2xi32>
%3249 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3239, %3247 : tensor<2xi32>, tensor<2xi32>) outs(%3248 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3250 = linalg.init_tensor [2] : tensor<2xi32>
%3251 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3247, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%3250 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3252 = linalg.init_tensor [2] : tensor<2xi32>
%3253 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3247, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3252 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3254 = linalg.init_tensor [2] : tensor<2xi32>
%3255 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3251, %3253 : tensor<2xi32>, tensor<2xi32>) outs(%3254 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3256 = linalg.init_tensor [2] : tensor<2xi32>
%3257 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3249, %3255 : tensor<2xi32>, tensor<2xi32>) outs(%3256 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3258 = linalg.init_tensor [2] : tensor<2xi32>
%3259 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3249, %3257 : tensor<2xi32>, tensor<2xi32>) outs(%3258 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3260 = linalg.init_tensor [2] : tensor<2xi32>
%3261 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3257, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3260 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3262 = linalg.init_tensor [2] : tensor<2xi32>
%3263 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3257, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3262 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3264 = linalg.init_tensor [2] : tensor<2xi32>
%3265 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3261, %3263 : tensor<2xi32>, tensor<2xi32>) outs(%3264 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3266 = linalg.init_tensor [2] : tensor<2xi32>
%3267 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3259, %3265 : tensor<2xi32>, tensor<2xi32>) outs(%3266 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3268 = linalg.init_tensor [2] : tensor<2xi32>
%3269 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3259, %3267 : tensor<2xi32>, tensor<2xi32>) outs(%3268 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3270 = linalg.init_tensor [2] : tensor<2xi32>
%3271 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3267, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3270 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3272 = linalg.init_tensor [2] : tensor<2xi32>
%3273 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3267, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3272 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3274 = linalg.init_tensor [2] : tensor<2xi32>
%3275 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3271, %3273 : tensor<2xi32>, tensor<2xi32>) outs(%3274 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3276 = linalg.init_tensor [2] : tensor<2xi32>
%3277 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3269, %3275 : tensor<2xi32>, tensor<2xi32>) outs(%3276 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3278 = linalg.init_tensor [2] : tensor<2xi32>
%3279 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3269, %3233 : tensor<2xi32>, tensor<2xi32>) outs(%3278 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3280 = linalg.init_tensor [2] : tensor<2xi32>
%3281 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3277, %3183 : tensor<2xi32>, tensor<2xi32>) outs(%3280 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3282 = linalg.init_tensor [2] : tensor<2xi32>
%3283 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3281, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%3282 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3284 = linalg.init_tensor [2] : tensor<2xi32>
%3285 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3279, %3283 : tensor<2xi32>, tensor<2xi32>) outs(%3284 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3286 = linalg.init_tensor [2] : tensor<2xi32>
%3287 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3283, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3286 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3288 = linalg.init_tensor [2] : tensor<2xi32>
%3289 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3283, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3288 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3290 = linalg.init_tensor [2] : tensor<2xi32>
%3291 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3287, %3289 : tensor<2xi32>, tensor<2xi32>) outs(%3290 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3292 = linalg.init_tensor [2] : tensor<2xi32>
%3293 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3285, %3291 : tensor<2xi32>, tensor<2xi32>) outs(%3292 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3294 = linalg.init_tensor [2] : tensor<2xi32>
%3295 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3285, %3293 : tensor<2xi32>, tensor<2xi32>) outs(%3294 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3296 = linalg.init_tensor [2] : tensor<2xi32>
%3297 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3293, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3296 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3298 = linalg.init_tensor [2] : tensor<2xi32>
%3299 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3293, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3298 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3300 = linalg.init_tensor [2] : tensor<2xi32>
%3301 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3297, %3299 : tensor<2xi32>, tensor<2xi32>) outs(%3300 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3302 = linalg.init_tensor [2] : tensor<2xi32>
%3303 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3295, %3301 : tensor<2xi32>, tensor<2xi32>) outs(%3302 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3304 = linalg.init_tensor [2] : tensor<2xi32>
%3305 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3295, %3303 : tensor<2xi32>, tensor<2xi32>) outs(%3304 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3306 = linalg.init_tensor [2] : tensor<2xi32>
%3307 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3303, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3306 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3308 = linalg.init_tensor [2] : tensor<2xi32>
%3309 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3303, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3308 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3310 = linalg.init_tensor [2] : tensor<2xi32>
%3311 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3307, %3309 : tensor<2xi32>, tensor<2xi32>) outs(%3310 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3312 = linalg.init_tensor [2] : tensor<2xi32>
%3313 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3305, %3311 : tensor<2xi32>, tensor<2xi32>) outs(%3312 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3314 = linalg.init_tensor [2] : tensor<2xi32>
%3315 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3305, %3313 : tensor<2xi32>, tensor<2xi32>) outs(%3314 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3316 = linalg.init_tensor [2] : tensor<2xi32>
%3317 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3313, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3316 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3318 = linalg.init_tensor [2] : tensor<2xi32>
%3319 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3313, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3318 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3320 = linalg.init_tensor [2] : tensor<2xi32>
%3321 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3317, %3319 : tensor<2xi32>, tensor<2xi32>) outs(%3320 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3322 = linalg.init_tensor [2] : tensor<2xi32>
%3323 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3315, %3321 : tensor<2xi32>, tensor<2xi32>) outs(%3322 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3324 = linalg.init_tensor [2] : tensor<2xi32>
%3325 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3315, %3183 : tensor<2xi32>, tensor<2xi32>) outs(%3324 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3326 = linalg.init_tensor [2] : tensor<2xi32>
%3327 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3323, %3187 : tensor<2xi32>, tensor<2xi32>) outs(%3326 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3328 = linalg.init_tensor [2] : tensor<2xi32>
%3329 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3327, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3328 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3330 = linalg.init_tensor [2] : tensor<2xi32>
%3331 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3325, %3329 : tensor<2xi32>, tensor<2xi32>) outs(%3330 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3332 = linalg.init_tensor [2] : tensor<2xi32>
%3333 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3329, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3332 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3334 = linalg.init_tensor [2] : tensor<2xi32>
%3335 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3329, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3334 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3336 = linalg.init_tensor [2] : tensor<2xi32>
%3337 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3333, %3335 : tensor<2xi32>, tensor<2xi32>) outs(%3336 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3338 = linalg.init_tensor [2] : tensor<2xi32>
%3339 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3331, %3337 : tensor<2xi32>, tensor<2xi32>) outs(%3338 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3340 = linalg.init_tensor [2] : tensor<2xi32>
%3341 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3331, %3339 : tensor<2xi32>, tensor<2xi32>) outs(%3340 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3342 = linalg.init_tensor [2] : tensor<2xi32>
%3343 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3339, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%3342 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3344 = linalg.init_tensor [2] : tensor<2xi32>
%3345 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3339, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3344 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3346 = linalg.init_tensor [2] : tensor<2xi32>
%3347 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3343, %3345 : tensor<2xi32>, tensor<2xi32>) outs(%3346 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3348 = linalg.init_tensor [2] : tensor<2xi32>
%3349 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3341, %3347 : tensor<2xi32>, tensor<2xi32>) outs(%3348 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3350 = linalg.init_tensor [2] : tensor<2xi32>
%3351 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3341, %3349 : tensor<2xi32>, tensor<2xi32>) outs(%3350 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3352 = linalg.init_tensor [2] : tensor<2xi32>
%3353 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3349, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3352 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3354 = linalg.init_tensor [2] : tensor<2xi32>
%3355 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3349, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3354 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3356 = linalg.init_tensor [2] : tensor<2xi32>
%3357 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3353, %3355 : tensor<2xi32>, tensor<2xi32>) outs(%3356 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3358 = linalg.init_tensor [2] : tensor<2xi32>
%3359 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3351, %3357 : tensor<2xi32>, tensor<2xi32>) outs(%3358 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3360 = linalg.init_tensor [2] : tensor<2xi32>
%3361 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3351, %3359 : tensor<2xi32>, tensor<2xi32>) outs(%3360 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3362 = linalg.init_tensor [2] : tensor<2xi32>
%3363 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3359, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3362 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3364 = linalg.init_tensor [2] : tensor<2xi32>
%3365 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3359, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3364 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3366 = linalg.init_tensor [2] : tensor<2xi32>
%3367 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3363, %3365 : tensor<2xi32>, tensor<2xi32>) outs(%3366 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3368 = linalg.init_tensor [2] : tensor<2xi32>
%3369 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3361, %3367 : tensor<2xi32>, tensor<2xi32>) outs(%3368 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3370 = linalg.init_tensor [2] : tensor<2xi32>
%3371 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3361, %3187 : tensor<2xi32>, tensor<2xi32>) outs(%3370 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3372 = linalg.init_tensor [2] : tensor<2xi32>
%3373 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3369, %3233 : tensor<2xi32>, tensor<2xi32>) outs(%3372 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3374 = linalg.init_tensor [2] : tensor<2xi32>
%3375 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3373, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%3374 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3376 = linalg.init_tensor [2] : tensor<2xi32>
%3377 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3371, %3375 : tensor<2xi32>, tensor<2xi32>) outs(%3376 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3378 = linalg.init_tensor [2] : tensor<2xi32>
%3379 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3375, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3378 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3380 = linalg.init_tensor [2] : tensor<2xi32>
%3381 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3375, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3380 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3382 = linalg.init_tensor [2] : tensor<2xi32>
%3383 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3379, %3381 : tensor<2xi32>, tensor<2xi32>) outs(%3382 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3384 = linalg.init_tensor [2] : tensor<2xi32>
%3385 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3377, %3383 : tensor<2xi32>, tensor<2xi32>) outs(%3384 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3386 = linalg.init_tensor [2] : tensor<2xi32>
%3387 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3377, %3385 : tensor<2xi32>, tensor<2xi32>) outs(%3386 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3388 = linalg.init_tensor [2] : tensor<2xi32>
%3389 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3385, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3388 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3390 = linalg.init_tensor [2] : tensor<2xi32>
%3391 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3385, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3390 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3392 = linalg.init_tensor [2] : tensor<2xi32>
%3393 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3389, %3391 : tensor<2xi32>, tensor<2xi32>) outs(%3392 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3394 = linalg.init_tensor [2] : tensor<2xi32>
%3395 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3387, %3393 : tensor<2xi32>, tensor<2xi32>) outs(%3394 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3396 = linalg.init_tensor [2] : tensor<2xi32>
%3397 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3387, %3395 : tensor<2xi32>, tensor<2xi32>) outs(%3396 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3398 = linalg.init_tensor [2] : tensor<2xi32>
%3399 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3395, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3398 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3400 = linalg.init_tensor [2] : tensor<2xi32>
%3401 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3395, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3400 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3402 = linalg.init_tensor [2] : tensor<2xi32>
%3403 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3399, %3401 : tensor<2xi32>, tensor<2xi32>) outs(%3402 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3404 = linalg.init_tensor [2] : tensor<2xi32>
%3405 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3397, %3403 : tensor<2xi32>, tensor<2xi32>) outs(%3404 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3406 = linalg.init_tensor [2] : tensor<2xi32>
%3407 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3397, %3405 : tensor<2xi32>, tensor<2xi32>) outs(%3406 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3408 = linalg.init_tensor [2] : tensor<2xi32>
%3409 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3405, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3408 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3410 = linalg.init_tensor [2] : tensor<2xi32>
%3411 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3405, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3410 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3412 = linalg.init_tensor [2] : tensor<2xi32>
%3413 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3409, %3411 : tensor<2xi32>, tensor<2xi32>) outs(%3412 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3414 = linalg.init_tensor [2] : tensor<2xi32>
%3415 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3407, %3413 : tensor<2xi32>, tensor<2xi32>) outs(%3414 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3416 = linalg.init_tensor [2] : tensor<2xi32>
%3417 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3407, %3233 : tensor<2xi32>, tensor<2xi32>) outs(%3416 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3418 = linalg.init_tensor [2] : tensor<2xi32>
%3419 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3415, %3183 : tensor<2xi32>, tensor<2xi32>) outs(%3418 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3420 = linalg.init_tensor [2] : tensor<2xi32>
%3421 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3419, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%3420 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3422 = linalg.init_tensor [4] : tensor<4xi32>
%3423 = linalg.fill(%c0_i32, %3422) : i32, tensor<4xi32> -> tensor<4xi32>
%3424 = tensor.insert_slice %3417 into %3423[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3425 = tensor.insert_slice %3421 into %3424[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3426 = linalg.tensor_expand_shape %3425 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%3427 = tensor.extract_slice %3426[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%3428 = linalg.tensor_collapse_shape %3427 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%3429 = tensor.extract_slice %3428[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3430 = linalg.tensor_collapse_shape %3429 [] : tensor<1xi32> into tensor<i32>
%3431 = tensor.extract_slice %3428[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3432 = linalg.tensor_collapse_shape %3431 [] : tensor<1xi32> into tensor<i32>
%3433 = linalg.init_tensor [] : tensor<i32>
%3434 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3430, %3432 : tensor<i32>, tensor<i32>) outs(%3433 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3435 = linalg.init_tensor [] : tensor<i32>
%3436 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3434, %cst_241 : tensor<i32>, tensor<i32>) outs(%3435 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3437 = linalg.init_tensor [2] : tensor<2xi32>
%3438 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3430 : tensor<i32>) outs(%3437 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3439 = linalg.init_tensor [2] : tensor<2xi32>
%3440 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%6, %3438 : tensor<2xi32>, tensor<2xi32>) outs(%3439 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3441 = linalg.init_tensor [2] : tensor<2xi32>
%3442 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3432 : tensor<i32>) outs(%3441 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3443 = linalg.init_tensor [2] : tensor<2xi32>
%3444 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%7, %3442 : tensor<2xi32>, tensor<2xi32>) outs(%3443 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3445 = linalg.init_tensor [2] : tensor<2xi32>
%3446 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3440, %3444 : tensor<2xi32>, tensor<2xi32>) outs(%3445 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3447 = linalg.init_tensor [2] : tensor<2xi32>
%3448 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3444, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3447 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3449 = linalg.init_tensor [2] : tensor<2xi32>
%3450 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3444, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3449 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3451 = linalg.init_tensor [2] : tensor<2xi32>
%3452 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3448, %3450 : tensor<2xi32>, tensor<2xi32>) outs(%3451 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3453 = linalg.init_tensor [2] : tensor<2xi32>
%3454 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3446, %3452 : tensor<2xi32>, tensor<2xi32>) outs(%3453 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3455 = linalg.init_tensor [2] : tensor<2xi32>
%3456 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3446, %3454 : tensor<2xi32>, tensor<2xi32>) outs(%3455 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3457 = linalg.init_tensor [2] : tensor<2xi32>
%3458 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3454, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3457 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3459 = linalg.init_tensor [2] : tensor<2xi32>
%3460 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3454, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3459 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3461 = linalg.init_tensor [2] : tensor<2xi32>
%3462 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3458, %3460 : tensor<2xi32>, tensor<2xi32>) outs(%3461 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3463 = linalg.init_tensor [2] : tensor<2xi32>
%3464 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3456, %3462 : tensor<2xi32>, tensor<2xi32>) outs(%3463 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3465 = linalg.init_tensor [2] : tensor<2xi32>
%3466 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3456, %3464 : tensor<2xi32>, tensor<2xi32>) outs(%3465 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3467 = linalg.init_tensor [2] : tensor<2xi32>
%3468 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3464, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3467 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3469 = linalg.init_tensor [2] : tensor<2xi32>
%3470 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3464, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3469 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3471 = linalg.init_tensor [2] : tensor<2xi32>
%3472 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3468, %3470 : tensor<2xi32>, tensor<2xi32>) outs(%3471 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3473 = linalg.init_tensor [2] : tensor<2xi32>
%3474 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3466, %3472 : tensor<2xi32>, tensor<2xi32>) outs(%3473 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3475 = linalg.init_tensor [2] : tensor<2xi32>
%3476 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3466, %3474 : tensor<2xi32>, tensor<2xi32>) outs(%3475 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3477 = linalg.init_tensor [2] : tensor<2xi32>
%3478 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3474, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3477 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3479 = linalg.init_tensor [2] : tensor<2xi32>
%3480 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3474, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3479 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3481 = linalg.init_tensor [2] : tensor<2xi32>
%3482 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3478, %3480 : tensor<2xi32>, tensor<2xi32>) outs(%3481 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3483 = linalg.init_tensor [2] : tensor<2xi32>
%3484 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3476, %3482 : tensor<2xi32>, tensor<2xi32>) outs(%3483 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3485 = linalg.init_tensor [2] : tensor<2xi32>
%3486 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3476, %3442 : tensor<2xi32>, tensor<2xi32>) outs(%3485 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3487 = linalg.init_tensor [2] : tensor<2xi32>
%3488 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3436 : tensor<i32>) outs(%3487 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<2xi32>
%3489 = linalg.init_tensor [2] : tensor<2xi32>
%3490 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3484, %3488 : tensor<2xi32>, tensor<2xi32>) outs(%3489 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3491 = linalg.init_tensor [2] : tensor<2xi32>
%3492 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3490, %cst_242 : tensor<2xi32>, tensor<2xi32>) outs(%3491 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3493 = linalg.init_tensor [2] : tensor<2xi32>
%3494 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3486, %3492 : tensor<2xi32>, tensor<2xi32>) outs(%3493 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3495 = linalg.init_tensor [2] : tensor<2xi32>
%3496 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3492, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3495 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3497 = linalg.init_tensor [2] : tensor<2xi32>
%3498 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3492, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3497 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3499 = linalg.init_tensor [2] : tensor<2xi32>
%3500 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3496, %3498 : tensor<2xi32>, tensor<2xi32>) outs(%3499 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3501 = linalg.init_tensor [2] : tensor<2xi32>
%3502 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3494, %3500 : tensor<2xi32>, tensor<2xi32>) outs(%3501 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3503 = linalg.init_tensor [2] : tensor<2xi32>
%3504 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3494, %3502 : tensor<2xi32>, tensor<2xi32>) outs(%3503 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3505 = linalg.init_tensor [2] : tensor<2xi32>
%3506 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3502, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%3505 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3507 = linalg.init_tensor [2] : tensor<2xi32>
%3508 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3502, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3507 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3509 = linalg.init_tensor [2] : tensor<2xi32>
%3510 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3506, %3508 : tensor<2xi32>, tensor<2xi32>) outs(%3509 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3511 = linalg.init_tensor [2] : tensor<2xi32>
%3512 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3504, %3510 : tensor<2xi32>, tensor<2xi32>) outs(%3511 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3513 = linalg.init_tensor [2] : tensor<2xi32>
%3514 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3504, %3512 : tensor<2xi32>, tensor<2xi32>) outs(%3513 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3515 = linalg.init_tensor [2] : tensor<2xi32>
%3516 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3512, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3515 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3517 = linalg.init_tensor [2] : tensor<2xi32>
%3518 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3512, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3517 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3519 = linalg.init_tensor [2] : tensor<2xi32>
%3520 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3516, %3518 : tensor<2xi32>, tensor<2xi32>) outs(%3519 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3521 = linalg.init_tensor [2] : tensor<2xi32>
%3522 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3514, %3520 : tensor<2xi32>, tensor<2xi32>) outs(%3521 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3523 = linalg.init_tensor [2] : tensor<2xi32>
%3524 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3514, %3522 : tensor<2xi32>, tensor<2xi32>) outs(%3523 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3525 = linalg.init_tensor [2] : tensor<2xi32>
%3526 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3522, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3525 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3527 = linalg.init_tensor [2] : tensor<2xi32>
%3528 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3522, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3527 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3529 = linalg.init_tensor [2] : tensor<2xi32>
%3530 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3526, %3528 : tensor<2xi32>, tensor<2xi32>) outs(%3529 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3531 = linalg.init_tensor [2] : tensor<2xi32>
%3532 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3524, %3530 : tensor<2xi32>, tensor<2xi32>) outs(%3531 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3533 = linalg.init_tensor [2] : tensor<2xi32>
%3534 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3524, %3488 : tensor<2xi32>, tensor<2xi32>) outs(%3533 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3535 = linalg.init_tensor [2] : tensor<2xi32>
%3536 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3532, %3438 : tensor<2xi32>, tensor<2xi32>) outs(%3535 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3537 = linalg.init_tensor [2] : tensor<2xi32>
%3538 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3536, %cst_243 : tensor<2xi32>, tensor<2xi32>) outs(%3537 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3539 = linalg.init_tensor [2] : tensor<2xi32>
%3540 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3534, %3538 : tensor<2xi32>, tensor<2xi32>) outs(%3539 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3541 = linalg.init_tensor [2] : tensor<2xi32>
%3542 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3538, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3541 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3543 = linalg.init_tensor [2] : tensor<2xi32>
%3544 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3538, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3543 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3545 = linalg.init_tensor [2] : tensor<2xi32>
%3546 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3542, %3544 : tensor<2xi32>, tensor<2xi32>) outs(%3545 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3547 = linalg.init_tensor [2] : tensor<2xi32>
%3548 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3540, %3546 : tensor<2xi32>, tensor<2xi32>) outs(%3547 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3549 = linalg.init_tensor [2] : tensor<2xi32>
%3550 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3540, %3548 : tensor<2xi32>, tensor<2xi32>) outs(%3549 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3551 = linalg.init_tensor [2] : tensor<2xi32>
%3552 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3548, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3551 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3553 = linalg.init_tensor [2] : tensor<2xi32>
%3554 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3548, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3553 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3555 = linalg.init_tensor [2] : tensor<2xi32>
%3556 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3552, %3554 : tensor<2xi32>, tensor<2xi32>) outs(%3555 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3557 = linalg.init_tensor [2] : tensor<2xi32>
%3558 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3550, %3556 : tensor<2xi32>, tensor<2xi32>) outs(%3557 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3559 = linalg.init_tensor [2] : tensor<2xi32>
%3560 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3550, %3558 : tensor<2xi32>, tensor<2xi32>) outs(%3559 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3561 = linalg.init_tensor [2] : tensor<2xi32>
%3562 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3558, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3561 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3563 = linalg.init_tensor [2] : tensor<2xi32>
%3564 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3558, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3563 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3565 = linalg.init_tensor [2] : tensor<2xi32>
%3566 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3562, %3564 : tensor<2xi32>, tensor<2xi32>) outs(%3565 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3567 = linalg.init_tensor [2] : tensor<2xi32>
%3568 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3560, %3566 : tensor<2xi32>, tensor<2xi32>) outs(%3567 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3569 = linalg.init_tensor [2] : tensor<2xi32>
%3570 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3560, %3568 : tensor<2xi32>, tensor<2xi32>) outs(%3569 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3571 = linalg.init_tensor [2] : tensor<2xi32>
%3572 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3568, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3571 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3573 = linalg.init_tensor [2] : tensor<2xi32>
%3574 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3568, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3573 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3575 = linalg.init_tensor [2] : tensor<2xi32>
%3576 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3572, %3574 : tensor<2xi32>, tensor<2xi32>) outs(%3575 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3577 = linalg.init_tensor [2] : tensor<2xi32>
%3578 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3570, %3576 : tensor<2xi32>, tensor<2xi32>) outs(%3577 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3579 = linalg.init_tensor [2] : tensor<2xi32>
%3580 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3570, %3438 : tensor<2xi32>, tensor<2xi32>) outs(%3579 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3581 = linalg.init_tensor [2] : tensor<2xi32>
%3582 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3578, %3442 : tensor<2xi32>, tensor<2xi32>) outs(%3581 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3583 = linalg.init_tensor [2] : tensor<2xi32>
%3584 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3582, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3583 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3585 = linalg.init_tensor [2] : tensor<2xi32>
%3586 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3580, %3584 : tensor<2xi32>, tensor<2xi32>) outs(%3585 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3587 = linalg.init_tensor [2] : tensor<2xi32>
%3588 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3584, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3587 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3589 = linalg.init_tensor [2] : tensor<2xi32>
%3590 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3584, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3589 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3591 = linalg.init_tensor [2] : tensor<2xi32>
%3592 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3588, %3590 : tensor<2xi32>, tensor<2xi32>) outs(%3591 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3593 = linalg.init_tensor [2] : tensor<2xi32>
%3594 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3586, %3592 : tensor<2xi32>, tensor<2xi32>) outs(%3593 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3595 = linalg.init_tensor [2] : tensor<2xi32>
%3596 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3586, %3594 : tensor<2xi32>, tensor<2xi32>) outs(%3595 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3597 = linalg.init_tensor [2] : tensor<2xi32>
%3598 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3594, %cst_244 : tensor<2xi32>, tensor<2xi32>) outs(%3597 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3599 = linalg.init_tensor [2] : tensor<2xi32>
%3600 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3594, %cst_245 : tensor<2xi32>, tensor<2xi32>) outs(%3599 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3601 = linalg.init_tensor [2] : tensor<2xi32>
%3602 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3598, %3600 : tensor<2xi32>, tensor<2xi32>) outs(%3601 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3603 = linalg.init_tensor [2] : tensor<2xi32>
%3604 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3596, %3602 : tensor<2xi32>, tensor<2xi32>) outs(%3603 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3605 = linalg.init_tensor [2] : tensor<2xi32>
%3606 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3596, %3604 : tensor<2xi32>, tensor<2xi32>) outs(%3605 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3607 = linalg.init_tensor [2] : tensor<2xi32>
%3608 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3604, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3607 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3609 = linalg.init_tensor [2] : tensor<2xi32>
%3610 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3604, %cst_246 : tensor<2xi32>, tensor<2xi32>) outs(%3609 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3611 = linalg.init_tensor [2] : tensor<2xi32>
%3612 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3608, %3610 : tensor<2xi32>, tensor<2xi32>) outs(%3611 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3613 = linalg.init_tensor [2] : tensor<2xi32>
%3614 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3606, %3612 : tensor<2xi32>, tensor<2xi32>) outs(%3613 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3615 = linalg.init_tensor [2] : tensor<2xi32>
%3616 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3606, %3614 : tensor<2xi32>, tensor<2xi32>) outs(%3615 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3617 = linalg.init_tensor [2] : tensor<2xi32>
%3618 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3614, %cst_247 : tensor<2xi32>, tensor<2xi32>) outs(%3617 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3619 = linalg.init_tensor [2] : tensor<2xi32>
%3620 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3614, %cst_248 : tensor<2xi32>, tensor<2xi32>) outs(%3619 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3621 = linalg.init_tensor [2] : tensor<2xi32>
%3622 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3618, %3620 : tensor<2xi32>, tensor<2xi32>) outs(%3621 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3623 = linalg.init_tensor [2] : tensor<2xi32>
%3624 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3616, %3622 : tensor<2xi32>, tensor<2xi32>) outs(%3623 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3625 = linalg.init_tensor [2] : tensor<2xi32>
%3626 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3616, %3442 : tensor<2xi32>, tensor<2xi32>) outs(%3625 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3627 = linalg.init_tensor [2] : tensor<2xi32>
%3628 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3624, %3488 : tensor<2xi32>, tensor<2xi32>) outs(%3627 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3629 = linalg.init_tensor [2] : tensor<2xi32>
%3630 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3628, %cst_249 : tensor<2xi32>, tensor<2xi32>) outs(%3629 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3631 = linalg.init_tensor [2] : tensor<2xi32>
%3632 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3626, %3630 : tensor<2xi32>, tensor<2xi32>) outs(%3631 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3633 = linalg.init_tensor [2] : tensor<2xi32>
%3634 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3630, %cst_250 : tensor<2xi32>, tensor<2xi32>) outs(%3633 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3635 = linalg.init_tensor [2] : tensor<2xi32>
%3636 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3630, %cst_251 : tensor<2xi32>, tensor<2xi32>) outs(%3635 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3637 = linalg.init_tensor [2] : tensor<2xi32>
%3638 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3634, %3636 : tensor<2xi32>, tensor<2xi32>) outs(%3637 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3639 = linalg.init_tensor [2] : tensor<2xi32>
%3640 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3632, %3638 : tensor<2xi32>, tensor<2xi32>) outs(%3639 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3641 = linalg.init_tensor [2] : tensor<2xi32>
%3642 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3632, %3640 : tensor<2xi32>, tensor<2xi32>) outs(%3641 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3643 = linalg.init_tensor [2] : tensor<2xi32>
%3644 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3640, %cst_252 : tensor<2xi32>, tensor<2xi32>) outs(%3643 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3645 = linalg.init_tensor [2] : tensor<2xi32>
%3646 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3640, %cst_253 : tensor<2xi32>, tensor<2xi32>) outs(%3645 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3647 = linalg.init_tensor [2] : tensor<2xi32>
%3648 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3644, %3646 : tensor<2xi32>, tensor<2xi32>) outs(%3647 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3649 = linalg.init_tensor [2] : tensor<2xi32>
%3650 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3642, %3648 : tensor<2xi32>, tensor<2xi32>) outs(%3649 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3651 = linalg.init_tensor [2] : tensor<2xi32>
%3652 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3642, %3650 : tensor<2xi32>, tensor<2xi32>) outs(%3651 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3653 = linalg.init_tensor [2] : tensor<2xi32>
%3654 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3650, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3653 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3655 = linalg.init_tensor [2] : tensor<2xi32>
%3656 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3650, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3655 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3657 = linalg.init_tensor [2] : tensor<2xi32>
%3658 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3654, %3656 : tensor<2xi32>, tensor<2xi32>) outs(%3657 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3659 = linalg.init_tensor [2] : tensor<2xi32>
%3660 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3652, %3658 : tensor<2xi32>, tensor<2xi32>) outs(%3659 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3661 = linalg.init_tensor [2] : tensor<2xi32>
%3662 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3652, %3660 : tensor<2xi32>, tensor<2xi32>) outs(%3661 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3663 = linalg.init_tensor [2] : tensor<2xi32>
%3664 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3660, %cst_254 : tensor<2xi32>, tensor<2xi32>) outs(%3663 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3665 = linalg.init_tensor [2] : tensor<2xi32>
%3666 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3660, %cst_255 : tensor<2xi32>, tensor<2xi32>) outs(%3665 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3667 = linalg.init_tensor [2] : tensor<2xi32>
%3668 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3664, %3666 : tensor<2xi32>, tensor<2xi32>) outs(%3667 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3669 = linalg.init_tensor [2] : tensor<2xi32>
%3670 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3662, %3668 : tensor<2xi32>, tensor<2xi32>) outs(%3669 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3671 = linalg.init_tensor [2] : tensor<2xi32>
%3672 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3662, %3488 : tensor<2xi32>, tensor<2xi32>) outs(%3671 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3673 = linalg.init_tensor [2] : tensor<2xi32>
%3674 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3670, %3438 : tensor<2xi32>, tensor<2xi32>) outs(%3673 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3675 = linalg.init_tensor [2] : tensor<2xi32>
%3676 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3674, %cst_256 : tensor<2xi32>, tensor<2xi32>) outs(%3675 : tensor<2xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<2xi32>
%3677 = linalg.init_tensor [4] : tensor<4xi32>
%3678 = linalg.fill(%c0_i32, %3677) : i32, tensor<4xi32> -> tensor<4xi32>
%3679 = tensor.insert_slice %3672 into %3678[0] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3680 = tensor.insert_slice %3676 into %3679[2] [2] [1] : tensor<2xi32> into tensor<4xi32>
%3681 = linalg.tensor_expand_shape %3680 [[0, 1]] : tensor<4xi32> into tensor<2x2xi32>
%3682 = tensor.extract_slice %3681[0, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%3683 = linalg.tensor_collapse_shape %3682 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%3684 = tensor.extract_slice %3681[1, 0] [1, 2] [1, 1] : tensor<2x2xi32> to tensor<1x2xi32>
%3685 = linalg.tensor_collapse_shape %3684 [[0, 1]] : tensor<1x2xi32> into tensor<2xi32>
%3686 = linalg.init_tensor [10240] : tensor<10240xi32>
%3687 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%3686 : tensor<10240xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<10240xi32>
%3688 = tensor.extract_slice %3683[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3689 = linalg.tensor_collapse_shape %3688 [] : tensor<1xi32> into tensor<i32>
%3690 = tensor.extract_slice %3683[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%3691 = linalg.tensor_collapse_shape %3690 [] : tensor<1xi32> into tensor<i32>
%3692 = tensor.extract_slice %3687[0] [5120] [1] : tensor<10240xi32> to tensor<5120xi32>
%3693 = tensor.extract_slice %3687[5120] [5120] [1] : tensor<10240xi32> to tensor<5120xi32>
%3694 = linalg.init_tensor [] : tensor<i32>
%3695 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3689, %3691 : tensor<i32>, tensor<i32>) outs(%3694 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3696 = linalg.init_tensor [] : tensor<i32>
%3697 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%3695, %cst_241 : tensor<i32>, tensor<i32>) outs(%3696 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%3698 = linalg.init_tensor [5120] : tensor<5120xi32>
%3699 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3689 : tensor<i32>) outs(%3698 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5120xi32>
%3700 = linalg.init_tensor [5120] : tensor<5120xi32>
%3701 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3692, %3699 : tensor<5120xi32>, tensor<5120xi32>) outs(%3700 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3702 = linalg.init_tensor [5120] : tensor<5120xi32>
%3703 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3691 : tensor<i32>) outs(%3702 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5120xi32>
%3704 = linalg.init_tensor [5120] : tensor<5120xi32>
%3705 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3693, %3703 : tensor<5120xi32>, tensor<5120xi32>) outs(%3704 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3706 = linalg.init_tensor [5120] : tensor<5120xi32>
%3707 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3701, %3705 : tensor<5120xi32>, tensor<5120xi32>) outs(%3706 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3708 = linalg.init_tensor [5120] : tensor<5120xi32>
%3709 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3705, %cst_204 : tensor<5120xi32>, tensor<5120xi32>) outs(%3708 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3710 = linalg.init_tensor [5120] : tensor<5120xi32>
%3711 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3705, %cst_205 : tensor<5120xi32>, tensor<5120xi32>) outs(%3710 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3712 = linalg.init_tensor [5120] : tensor<5120xi32>
%3713 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3709, %3711 : tensor<5120xi32>, tensor<5120xi32>) outs(%3712 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3714 = linalg.init_tensor [5120] : tensor<5120xi32>
%3715 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3707, %3713 : tensor<5120xi32>, tensor<5120xi32>) outs(%3714 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3716 = linalg.init_tensor [5120] : tensor<5120xi32>
%3717 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3707, %3715 : tensor<5120xi32>, tensor<5120xi32>) outs(%3716 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3718 = linalg.init_tensor [5120] : tensor<5120xi32>
%3719 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3715, %cst_206 : tensor<5120xi32>, tensor<5120xi32>) outs(%3718 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3720 = linalg.init_tensor [5120] : tensor<5120xi32>
%3721 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3715, %cst_207 : tensor<5120xi32>, tensor<5120xi32>) outs(%3720 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3722 = linalg.init_tensor [5120] : tensor<5120xi32>
%3723 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3719, %3721 : tensor<5120xi32>, tensor<5120xi32>) outs(%3722 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3724 = linalg.init_tensor [5120] : tensor<5120xi32>
%3725 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3717, %3723 : tensor<5120xi32>, tensor<5120xi32>) outs(%3724 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3726 = linalg.init_tensor [5120] : tensor<5120xi32>
%3727 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3717, %3725 : tensor<5120xi32>, tensor<5120xi32>) outs(%3726 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3728 = linalg.init_tensor [5120] : tensor<5120xi32>
%3729 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3725, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3728 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3730 = linalg.init_tensor [5120] : tensor<5120xi32>
%3731 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3725, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3730 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3732 = linalg.init_tensor [5120] : tensor<5120xi32>
%3733 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3729, %3731 : tensor<5120xi32>, tensor<5120xi32>) outs(%3732 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3734 = linalg.init_tensor [5120] : tensor<5120xi32>
%3735 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3727, %3733 : tensor<5120xi32>, tensor<5120xi32>) outs(%3734 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3736 = linalg.init_tensor [5120] : tensor<5120xi32>
%3737 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3727, %3735 : tensor<5120xi32>, tensor<5120xi32>) outs(%3736 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3738 = linalg.init_tensor [5120] : tensor<5120xi32>
%3739 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3735, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3738 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3740 = linalg.init_tensor [5120] : tensor<5120xi32>
%3741 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3735, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3740 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3742 = linalg.init_tensor [5120] : tensor<5120xi32>
%3743 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3739, %3741 : tensor<5120xi32>, tensor<5120xi32>) outs(%3742 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3744 = linalg.init_tensor [5120] : tensor<5120xi32>
%3745 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3737, %3743 : tensor<5120xi32>, tensor<5120xi32>) outs(%3744 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3746 = linalg.init_tensor [5120] : tensor<5120xi32>
%3747 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3737, %3703 : tensor<5120xi32>, tensor<5120xi32>) outs(%3746 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3748 = linalg.init_tensor [5120] : tensor<5120xi32>
%3749 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%3697 : tensor<i32>) outs(%3748 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5120xi32>
%3750 = linalg.init_tensor [5120] : tensor<5120xi32>
%3751 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3745, %3749 : tensor<5120xi32>, tensor<5120xi32>) outs(%3750 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3752 = linalg.init_tensor [5120] : tensor<5120xi32>
%3753 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3751, %cst_196 : tensor<5120xi32>, tensor<5120xi32>) outs(%3752 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3754 = linalg.init_tensor [5120] : tensor<5120xi32>
%3755 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3747, %3753 : tensor<5120xi32>, tensor<5120xi32>) outs(%3754 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3756 = linalg.init_tensor [5120] : tensor<5120xi32>
%3757 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3753, %cst_207 : tensor<5120xi32>, tensor<5120xi32>) outs(%3756 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3758 = linalg.init_tensor [5120] : tensor<5120xi32>
%3759 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3753, %cst_206 : tensor<5120xi32>, tensor<5120xi32>) outs(%3758 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3760 = linalg.init_tensor [5120] : tensor<5120xi32>
%3761 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3757, %3759 : tensor<5120xi32>, tensor<5120xi32>) outs(%3760 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3762 = linalg.init_tensor [5120] : tensor<5120xi32>
%3763 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3755, %3761 : tensor<5120xi32>, tensor<5120xi32>) outs(%3762 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3764 = linalg.init_tensor [5120] : tensor<5120xi32>
%3765 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3755, %3763 : tensor<5120xi32>, tensor<5120xi32>) outs(%3764 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3766 = linalg.init_tensor [5120] : tensor<5120xi32>
%3767 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3763, %cst_198 : tensor<5120xi32>, tensor<5120xi32>) outs(%3766 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3768 = linalg.init_tensor [5120] : tensor<5120xi32>
%3769 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3763, %cst_199 : tensor<5120xi32>, tensor<5120xi32>) outs(%3768 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3770 = linalg.init_tensor [5120] : tensor<5120xi32>
%3771 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3767, %3769 : tensor<5120xi32>, tensor<5120xi32>) outs(%3770 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3772 = linalg.init_tensor [5120] : tensor<5120xi32>
%3773 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3765, %3771 : tensor<5120xi32>, tensor<5120xi32>) outs(%3772 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3774 = linalg.init_tensor [5120] : tensor<5120xi32>
%3775 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3765, %3773 : tensor<5120xi32>, tensor<5120xi32>) outs(%3774 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3776 = linalg.init_tensor [5120] : tensor<5120xi32>
%3777 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3773, %cst_200 : tensor<5120xi32>, tensor<5120xi32>) outs(%3776 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3778 = linalg.init_tensor [5120] : tensor<5120xi32>
%3779 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3773, %cst_200 : tensor<5120xi32>, tensor<5120xi32>) outs(%3778 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3780 = linalg.init_tensor [5120] : tensor<5120xi32>
%3781 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3777, %3779 : tensor<5120xi32>, tensor<5120xi32>) outs(%3780 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3782 = linalg.init_tensor [5120] : tensor<5120xi32>
%3783 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3775, %3781 : tensor<5120xi32>, tensor<5120xi32>) outs(%3782 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3784 = linalg.init_tensor [5120] : tensor<5120xi32>
%3785 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3775, %3783 : tensor<5120xi32>, tensor<5120xi32>) outs(%3784 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3786 = linalg.init_tensor [5120] : tensor<5120xi32>
%3787 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3783, %cst_201 : tensor<5120xi32>, tensor<5120xi32>) outs(%3786 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3788 = linalg.init_tensor [5120] : tensor<5120xi32>
%3789 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3783, %cst_202 : tensor<5120xi32>, tensor<5120xi32>) outs(%3788 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3790 = linalg.init_tensor [5120] : tensor<5120xi32>
%3791 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3787, %3789 : tensor<5120xi32>, tensor<5120xi32>) outs(%3790 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3792 = linalg.init_tensor [5120] : tensor<5120xi32>
%3793 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3785, %3791 : tensor<5120xi32>, tensor<5120xi32>) outs(%3792 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3794 = linalg.init_tensor [5120] : tensor<5120xi32>
%3795 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3785, %3749 : tensor<5120xi32>, tensor<5120xi32>) outs(%3794 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3796 = linalg.init_tensor [5120] : tensor<5120xi32>
%3797 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3793, %3699 : tensor<5120xi32>, tensor<5120xi32>) outs(%3796 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3798 = linalg.init_tensor [5120] : tensor<5120xi32>
%3799 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3797, %cst_197 : tensor<5120xi32>, tensor<5120xi32>) outs(%3798 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3800 = linalg.init_tensor [5120] : tensor<5120xi32>
%3801 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3795, %3799 : tensor<5120xi32>, tensor<5120xi32>) outs(%3800 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3802 = linalg.init_tensor [5120] : tensor<5120xi32>
%3803 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3799, %cst_204 : tensor<5120xi32>, tensor<5120xi32>) outs(%3802 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3804 = linalg.init_tensor [5120] : tensor<5120xi32>
%3805 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3799, %cst_205 : tensor<5120xi32>, tensor<5120xi32>) outs(%3804 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3806 = linalg.init_tensor [5120] : tensor<5120xi32>
%3807 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3803, %3805 : tensor<5120xi32>, tensor<5120xi32>) outs(%3806 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3808 = linalg.init_tensor [5120] : tensor<5120xi32>
%3809 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3801, %3807 : tensor<5120xi32>, tensor<5120xi32>) outs(%3808 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3810 = linalg.init_tensor [5120] : tensor<5120xi32>
%3811 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3801, %3809 : tensor<5120xi32>, tensor<5120xi32>) outs(%3810 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3812 = linalg.init_tensor [5120] : tensor<5120xi32>
%3813 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3809, %cst_206 : tensor<5120xi32>, tensor<5120xi32>) outs(%3812 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3814 = linalg.init_tensor [5120] : tensor<5120xi32>
%3815 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3809, %cst_207 : tensor<5120xi32>, tensor<5120xi32>) outs(%3814 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3816 = linalg.init_tensor [5120] : tensor<5120xi32>
%3817 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3813, %3815 : tensor<5120xi32>, tensor<5120xi32>) outs(%3816 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3818 = linalg.init_tensor [5120] : tensor<5120xi32>
%3819 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3811, %3817 : tensor<5120xi32>, tensor<5120xi32>) outs(%3818 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3820 = linalg.init_tensor [5120] : tensor<5120xi32>
%3821 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3811, %3819 : tensor<5120xi32>, tensor<5120xi32>) outs(%3820 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3822 = linalg.init_tensor [5120] : tensor<5120xi32>
%3823 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3819, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3822 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3824 = linalg.init_tensor [5120] : tensor<5120xi32>
%3825 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3819, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3824 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3826 = linalg.init_tensor [5120] : tensor<5120xi32>
%3827 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3823, %3825 : tensor<5120xi32>, tensor<5120xi32>) outs(%3826 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3828 = linalg.init_tensor [5120] : tensor<5120xi32>
%3829 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3821, %3827 : tensor<5120xi32>, tensor<5120xi32>) outs(%3828 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3830 = linalg.init_tensor [5120] : tensor<5120xi32>
%3831 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3821, %3829 : tensor<5120xi32>, tensor<5120xi32>) outs(%3830 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3832 = linalg.init_tensor [5120] : tensor<5120xi32>
%3833 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3829, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3832 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3834 = linalg.init_tensor [5120] : tensor<5120xi32>
%3835 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3829, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3834 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3836 = linalg.init_tensor [5120] : tensor<5120xi32>
%3837 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3833, %3835 : tensor<5120xi32>, tensor<5120xi32>) outs(%3836 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3838 = linalg.init_tensor [5120] : tensor<5120xi32>
%3839 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3831, %3837 : tensor<5120xi32>, tensor<5120xi32>) outs(%3838 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3840 = linalg.init_tensor [5120] : tensor<5120xi32>
%3841 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3831, %3699 : tensor<5120xi32>, tensor<5120xi32>) outs(%3840 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3842 = linalg.init_tensor [5120] : tensor<5120xi32>
%3843 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3839, %3703 : tensor<5120xi32>, tensor<5120xi32>) outs(%3842 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3844 = linalg.init_tensor [5120] : tensor<5120xi32>
%3845 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3843, %cst_199 : tensor<5120xi32>, tensor<5120xi32>) outs(%3844 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3846 = linalg.init_tensor [5120] : tensor<5120xi32>
%3847 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3841, %3845 : tensor<5120xi32>, tensor<5120xi32>) outs(%3846 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3848 = linalg.init_tensor [5120] : tensor<5120xi32>
%3849 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3845, %cst_207 : tensor<5120xi32>, tensor<5120xi32>) outs(%3848 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3850 = linalg.init_tensor [5120] : tensor<5120xi32>
%3851 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3845, %cst_206 : tensor<5120xi32>, tensor<5120xi32>) outs(%3850 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3852 = linalg.init_tensor [5120] : tensor<5120xi32>
%3853 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3849, %3851 : tensor<5120xi32>, tensor<5120xi32>) outs(%3852 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3854 = linalg.init_tensor [5120] : tensor<5120xi32>
%3855 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3847, %3853 : tensor<5120xi32>, tensor<5120xi32>) outs(%3854 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3856 = linalg.init_tensor [5120] : tensor<5120xi32>
%3857 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3847, %3855 : tensor<5120xi32>, tensor<5120xi32>) outs(%3856 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3858 = linalg.init_tensor [5120] : tensor<5120xi32>
%3859 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3855, %cst_198 : tensor<5120xi32>, tensor<5120xi32>) outs(%3858 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3860 = linalg.init_tensor [5120] : tensor<5120xi32>
%3861 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3855, %cst_199 : tensor<5120xi32>, tensor<5120xi32>) outs(%3860 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3862 = linalg.init_tensor [5120] : tensor<5120xi32>
%3863 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3859, %3861 : tensor<5120xi32>, tensor<5120xi32>) outs(%3862 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3864 = linalg.init_tensor [5120] : tensor<5120xi32>
%3865 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3857, %3863 : tensor<5120xi32>, tensor<5120xi32>) outs(%3864 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3866 = linalg.init_tensor [5120] : tensor<5120xi32>
%3867 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3857, %3865 : tensor<5120xi32>, tensor<5120xi32>) outs(%3866 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3868 = linalg.init_tensor [5120] : tensor<5120xi32>
%3869 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3865, %cst_200 : tensor<5120xi32>, tensor<5120xi32>) outs(%3868 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3870 = linalg.init_tensor [5120] : tensor<5120xi32>
%3871 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3865, %cst_200 : tensor<5120xi32>, tensor<5120xi32>) outs(%3870 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3872 = linalg.init_tensor [5120] : tensor<5120xi32>
%3873 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3869, %3871 : tensor<5120xi32>, tensor<5120xi32>) outs(%3872 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3874 = linalg.init_tensor [5120] : tensor<5120xi32>
%3875 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3867, %3873 : tensor<5120xi32>, tensor<5120xi32>) outs(%3874 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3876 = linalg.init_tensor [5120] : tensor<5120xi32>
%3877 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3867, %3875 : tensor<5120xi32>, tensor<5120xi32>) outs(%3876 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3878 = linalg.init_tensor [5120] : tensor<5120xi32>
%3879 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3875, %cst_201 : tensor<5120xi32>, tensor<5120xi32>) outs(%3878 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3880 = linalg.init_tensor [5120] : tensor<5120xi32>
%3881 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3875, %cst_202 : tensor<5120xi32>, tensor<5120xi32>) outs(%3880 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3882 = linalg.init_tensor [5120] : tensor<5120xi32>
%3883 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3879, %3881 : tensor<5120xi32>, tensor<5120xi32>) outs(%3882 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3884 = linalg.init_tensor [5120] : tensor<5120xi32>
%3885 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3877, %3883 : tensor<5120xi32>, tensor<5120xi32>) outs(%3884 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3886 = linalg.init_tensor [5120] : tensor<5120xi32>
%3887 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3877, %3703 : tensor<5120xi32>, tensor<5120xi32>) outs(%3886 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3888 = linalg.init_tensor [5120] : tensor<5120xi32>
%3889 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3885, %3749 : tensor<5120xi32>, tensor<5120xi32>) outs(%3888 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3890 = linalg.init_tensor [5120] : tensor<5120xi32>
%3891 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3889, %cst_203 : tensor<5120xi32>, tensor<5120xi32>) outs(%3890 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3892 = linalg.init_tensor [5120] : tensor<5120xi32>
%3893 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3887, %3891 : tensor<5120xi32>, tensor<5120xi32>) outs(%3892 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3894 = linalg.init_tensor [5120] : tensor<5120xi32>
%3895 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3891, %cst_204 : tensor<5120xi32>, tensor<5120xi32>) outs(%3894 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3896 = linalg.init_tensor [5120] : tensor<5120xi32>
%3897 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3891, %cst_205 : tensor<5120xi32>, tensor<5120xi32>) outs(%3896 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3898 = linalg.init_tensor [5120] : tensor<5120xi32>
%3899 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3895, %3897 : tensor<5120xi32>, tensor<5120xi32>) outs(%3898 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3900 = linalg.init_tensor [5120] : tensor<5120xi32>
%3901 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3893, %3899 : tensor<5120xi32>, tensor<5120xi32>) outs(%3900 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3902 = linalg.init_tensor [5120] : tensor<5120xi32>
%3903 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3893, %3901 : tensor<5120xi32>, tensor<5120xi32>) outs(%3902 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3904 = linalg.init_tensor [5120] : tensor<5120xi32>
%3905 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3901, %cst_206 : tensor<5120xi32>, tensor<5120xi32>) outs(%3904 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3906 = linalg.init_tensor [5120] : tensor<5120xi32>
%3907 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3901, %cst_207 : tensor<5120xi32>, tensor<5120xi32>) outs(%3906 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3908 = linalg.init_tensor [5120] : tensor<5120xi32>
%3909 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3905, %3907 : tensor<5120xi32>, tensor<5120xi32>) outs(%3908 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3910 = linalg.init_tensor [5120] : tensor<5120xi32>
%3911 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3903, %3909 : tensor<5120xi32>, tensor<5120xi32>) outs(%3910 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3912 = linalg.init_tensor [5120] : tensor<5120xi32>
%3913 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3903, %3911 : tensor<5120xi32>, tensor<5120xi32>) outs(%3912 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3914 = linalg.init_tensor [5120] : tensor<5120xi32>
%3915 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3911, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3914 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3916 = linalg.init_tensor [5120] : tensor<5120xi32>
%3917 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3911, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3916 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3918 = linalg.init_tensor [5120] : tensor<5120xi32>
%3919 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3915, %3917 : tensor<5120xi32>, tensor<5120xi32>) outs(%3918 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3920 = linalg.init_tensor [5120] : tensor<5120xi32>
%3921 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3913, %3919 : tensor<5120xi32>, tensor<5120xi32>) outs(%3920 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3922 = linalg.init_tensor [5120] : tensor<5120xi32>
%3923 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3913, %3921 : tensor<5120xi32>, tensor<5120xi32>) outs(%3922 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3924 = linalg.init_tensor [5120] : tensor<5120xi32>
%3925 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3921, %cst_208 : tensor<5120xi32>, tensor<5120xi32>) outs(%3924 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3926 = linalg.init_tensor [5120] : tensor<5120xi32>
%3927 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3921, %cst_209 : tensor<5120xi32>, tensor<5120xi32>) outs(%3926 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3928 = linalg.init_tensor [5120] : tensor<5120xi32>
%3929 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3925, %3927 : tensor<5120xi32>, tensor<5120xi32>) outs(%3928 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3930 = linalg.init_tensor [5120] : tensor<5120xi32>
%3931 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3923, %3929 : tensor<5120xi32>, tensor<5120xi32>) outs(%3930 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3932 = linalg.init_tensor [5120] : tensor<5120xi32>
%3933 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3923, %3749 : tensor<5120xi32>, tensor<5120xi32>) outs(%3932 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3934 = linalg.init_tensor [5120] : tensor<5120xi32>
%3935 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3931, %3699 : tensor<5120xi32>, tensor<5120xi32>) outs(%3934 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3936 = linalg.init_tensor [5120] : tensor<5120xi32>
%3937 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%3935, %cst_210 : tensor<5120xi32>, tensor<5120xi32>) outs(%3936 : tensor<5120xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5120xi32>
%3938 = linalg.init_tensor [10240] : tensor<10240xi32>
%3939 = linalg.fill(%c0_i32, %3938) : i32, tensor<10240xi32> -> tensor<10240xi32>
%3940 = tensor.insert_slice %3933 into %3939[0] [5120] [1] : tensor<5120xi32> into tensor<10240xi32>
%3941 = tensor.insert_slice %3937 into %3940[5120] [5120] [1] : tensor<5120xi32> into tensor<10240xi32>
%3942 = linalg.tensor_expand_shape %3941 [[0, 1]] : tensor<10240xi32> into tensor<1024x10xi32>
%3943 = linalg.init_tensor [1024, 10] : tensor<1024x10xi32>
%3944 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3942, %cst_211 : tensor<1024x10xi32>, tensor<1024x10xi32>) outs(%3943 : tensor<1024x10xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024x10xi32>
%3945 = linalg.init_tensor [1024, 10] : tensor<1024x10xi32>
%3946 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3944, %cst_212 : tensor<1024x10xi32>, tensor<1024x10xi32>) outs(%3945 : tensor<1024x10xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<1024x10xi32>
%3947 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3948 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3946 : tensor<1024x10xi32>) outs(%3947 : tensor<1024x10xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3949 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3950 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3948, %cst_29 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3949 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3951 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3952 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%896 : tensor<1x1xf32>) outs(%3951 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x10xf32>
%3953 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3954 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3950, %3952 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3953 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3955 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3956 = linalg.generic {indexing_maps = [#map5, #map4], iterator_types = ["parallel", "parallel"]} ins(%627 : tensor<1x1xf32>) outs(%3955 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x10xf32>
%3957 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3958 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3954, %3956 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3957 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3959 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3960 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3956, %3958 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3959 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3961 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3962 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3960 : tensor<1024x10xf32>) outs(%3961 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3963 = linalg.init_tensor [1024, 10] : tensor<1024x10xi1>
%3964 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3962, %cst_29 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3963 : tensor<1024x10xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024x10xi1>
%3965 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3966 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3960, %cst_30 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3965 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3967 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3968 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3960 : tensor<1024x10xf32>) outs(%3967 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3969 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3970 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3968, %3960 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3969 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3971 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3972 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3970, %cst_29 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3971 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3973 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3974 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3972 : tensor<1024x10xf32>) outs(%3973 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3975 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3976 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3974 : tensor<1024x10xf32>) outs(%3975 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3977 = linalg.init_tensor [1024, 10] : tensor<1024x10xi1>
%3978 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3976, %cst_31 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3977 : tensor<1024x10xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<1024x10xi1>
%3979 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3980 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_32, %cst_33 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3979 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3981 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3982 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_34, %cst_35 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3981 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3983 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3984 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_36, %cst_37 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3983 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3985 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3986 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_38, %cst_39 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3985 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3987 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3988 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_40, %cst_41 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3987 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3989 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3990 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_42, %cst_43 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3989 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3991 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3992 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_44, %cst_45 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3991 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3993 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3994 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_46, %cst_47 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3993 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3995 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3996 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %cst_48, %cst_49 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3995 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3997 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%3998 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3976, %cst_50 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%3997 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%3999 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4000 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3976 : tensor<1024x10xf32>) outs(%3999 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4001 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4002 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4000, %cst_51 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4001 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4003 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4004 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3978, %3998, %4002 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4003 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4005 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4006 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3996, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4005 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4007 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4008 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3994, %4006 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4007 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4009 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4010 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4008, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4009 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4011 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4012 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3992, %4010 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4011 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4013 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4014 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4012, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4013 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4015 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4016 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3990, %4014 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4015 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4017 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4018 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4016, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4017 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4019 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4020 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3988, %4018 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4019 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4021 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4022 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4020, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4021 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4023 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4024 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3986, %4022 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4023 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4025 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4026 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4024, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4025 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4027 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4028 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3984, %4026 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4027 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4029 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4030 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4028, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4029 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4031 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4032 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3982, %4030 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4031 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4033 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4034 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4032, %4004 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4033 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4035 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4036 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3980, %4034 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4035 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4037 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4038 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4036, %3960 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4037 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4039 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4040 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%3964, %3966, %4038 : tensor<1024x10xi1>, tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4039 : tensor<1024x10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4041 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4042 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4040, %cst_213 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4041 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4043 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4044 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1028 : tensor<f32>) outs(%4043 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x10xf32>
%4045 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4046 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4044, %4042 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4045 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4047 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4048 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel", "parallel"]} ins(%1068 : tensor<f32>) outs(%4047 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
linalg.yield %arg1 : f32
} -> tensor<1024x10xf32>
%4049 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4050 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4048, %4046 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4049 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.minf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4051 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%4052 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%4050, %cst_218 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%4051 : tensor<1024x10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<1024x10xf32>
%4053 = linalg.init_tensor [10] : tensor<10xi32>
%4054 = linalg.generic {indexing_maps = [#map0], iterator_types = ["parallel"]} outs(%4053 : tensor<10xi32>) {
^bb0(%arg1: i32): // no predecessors
%4407 = linalg.index 0 : index
%4408 = arith.index_cast %4407 : index to i32
linalg.yield %4408 : i32
} -> tensor<10xi32>
%4055 = tensor.extract_slice %3685[0] [1] [1] : tensor<2xi32> to tensor<1xi32>
%4056 = linalg.tensor_collapse_shape %4055 [] : tensor<1xi32> into tensor<i32>
%4057 = tensor.extract_slice %3685[1] [1] [1] : tensor<2xi32> to tensor<1xi32>
%4058 = linalg.tensor_collapse_shape %4057 [] : tensor<1xi32> into tensor<i32>
%4059 = tensor.extract_slice %4054[0] [5] [1] : tensor<10xi32> to tensor<5xi32>
%4060 = tensor.extract_slice %4054[5] [5] [1] : tensor<10xi32> to tensor<5xi32>
%4061 = linalg.init_tensor [] : tensor<i32>
%4062 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%4056, %4058 : tensor<i32>, tensor<i32>) outs(%4061 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%4063 = linalg.init_tensor [] : tensor<i32>
%4064 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = []} ins(%4062, %cst_241 : tensor<i32>, tensor<i32>) outs(%4063 : tensor<i32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<i32>
%4065 = linalg.init_tensor [5] : tensor<5xi32>
%4066 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%4056 : tensor<i32>) outs(%4065 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5xi32>
%4067 = linalg.init_tensor [5] : tensor<5xi32>
%4068 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4059, %4066 : tensor<5xi32>, tensor<5xi32>) outs(%4067 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4069 = linalg.init_tensor [5] : tensor<5xi32>
%4070 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%4058 : tensor<i32>) outs(%4069 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5xi32>
%4071 = linalg.init_tensor [5] : tensor<5xi32>
%4072 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4060, %4070 : tensor<5xi32>, tensor<5xi32>) outs(%4071 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4073 = linalg.init_tensor [5] : tensor<5xi32>
%4074 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4068, %4072 : tensor<5xi32>, tensor<5xi32>) outs(%4073 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4075 = linalg.init_tensor [5] : tensor<5xi32>
%4076 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4072, %cst_227 : tensor<5xi32>, tensor<5xi32>) outs(%4075 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4077 = linalg.init_tensor [5] : tensor<5xi32>
%4078 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4072, %cst_228 : tensor<5xi32>, tensor<5xi32>) outs(%4077 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4079 = linalg.init_tensor [5] : tensor<5xi32>
%4080 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4076, %4078 : tensor<5xi32>, tensor<5xi32>) outs(%4079 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4081 = linalg.init_tensor [5] : tensor<5xi32>
%4082 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4074, %4080 : tensor<5xi32>, tensor<5xi32>) outs(%4081 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4083 = linalg.init_tensor [5] : tensor<5xi32>
%4084 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4074, %4082 : tensor<5xi32>, tensor<5xi32>) outs(%4083 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4085 = linalg.init_tensor [5] : tensor<5xi32>
%4086 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4082, %cst_229 : tensor<5xi32>, tensor<5xi32>) outs(%4085 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4087 = linalg.init_tensor [5] : tensor<5xi32>
%4088 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4082, %cst_230 : tensor<5xi32>, tensor<5xi32>) outs(%4087 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4089 = linalg.init_tensor [5] : tensor<5xi32>
%4090 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4086, %4088 : tensor<5xi32>, tensor<5xi32>) outs(%4089 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4091 = linalg.init_tensor [5] : tensor<5xi32>
%4092 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4084, %4090 : tensor<5xi32>, tensor<5xi32>) outs(%4091 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4093 = linalg.init_tensor [5] : tensor<5xi32>
%4094 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4084, %4092 : tensor<5xi32>, tensor<5xi32>) outs(%4093 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4095 = linalg.init_tensor [5] : tensor<5xi32>
%4096 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4092, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4095 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4097 = linalg.init_tensor [5] : tensor<5xi32>
%4098 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4092, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4097 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4099 = linalg.init_tensor [5] : tensor<5xi32>
%4100 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4096, %4098 : tensor<5xi32>, tensor<5xi32>) outs(%4099 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4101 = linalg.init_tensor [5] : tensor<5xi32>
%4102 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4094, %4100 : tensor<5xi32>, tensor<5xi32>) outs(%4101 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4103 = linalg.init_tensor [5] : tensor<5xi32>
%4104 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4094, %4102 : tensor<5xi32>, tensor<5xi32>) outs(%4103 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4105 = linalg.init_tensor [5] : tensor<5xi32>
%4106 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4102, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4105 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4107 = linalg.init_tensor [5] : tensor<5xi32>
%4108 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4102, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4107 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4109 = linalg.init_tensor [5] : tensor<5xi32>
%4110 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4106, %4108 : tensor<5xi32>, tensor<5xi32>) outs(%4109 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4111 = linalg.init_tensor [5] : tensor<5xi32>
%4112 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4104, %4110 : tensor<5xi32>, tensor<5xi32>) outs(%4111 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4113 = linalg.init_tensor [5] : tensor<5xi32>
%4114 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4104, %4070 : tensor<5xi32>, tensor<5xi32>) outs(%4113 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4115 = linalg.init_tensor [5] : tensor<5xi32>
%4116 = linalg.generic {indexing_maps = [#map2, #map0], iterator_types = ["parallel"]} ins(%4064 : tensor<i32>) outs(%4115 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32): // no predecessors
linalg.yield %arg1 : i32
} -> tensor<5xi32>
%4117 = linalg.init_tensor [5] : tensor<5xi32>
%4118 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4112, %4116 : tensor<5xi32>, tensor<5xi32>) outs(%4117 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4119 = linalg.init_tensor [5] : tensor<5xi32>
%4120 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4118, %cst_219 : tensor<5xi32>, tensor<5xi32>) outs(%4119 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4121 = linalg.init_tensor [5] : tensor<5xi32>
%4122 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4114, %4120 : tensor<5xi32>, tensor<5xi32>) outs(%4121 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4123 = linalg.init_tensor [5] : tensor<5xi32>
%4124 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4120, %cst_230 : tensor<5xi32>, tensor<5xi32>) outs(%4123 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4125 = linalg.init_tensor [5] : tensor<5xi32>
%4126 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4120, %cst_229 : tensor<5xi32>, tensor<5xi32>) outs(%4125 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4127 = linalg.init_tensor [5] : tensor<5xi32>
%4128 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4124, %4126 : tensor<5xi32>, tensor<5xi32>) outs(%4127 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4129 = linalg.init_tensor [5] : tensor<5xi32>
%4130 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4122, %4128 : tensor<5xi32>, tensor<5xi32>) outs(%4129 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4131 = linalg.init_tensor [5] : tensor<5xi32>
%4132 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4122, %4130 : tensor<5xi32>, tensor<5xi32>) outs(%4131 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4133 = linalg.init_tensor [5] : tensor<5xi32>
%4134 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4130, %cst_221 : tensor<5xi32>, tensor<5xi32>) outs(%4133 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4135 = linalg.init_tensor [5] : tensor<5xi32>
%4136 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4130, %cst_222 : tensor<5xi32>, tensor<5xi32>) outs(%4135 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4137 = linalg.init_tensor [5] : tensor<5xi32>
%4138 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4134, %4136 : tensor<5xi32>, tensor<5xi32>) outs(%4137 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4139 = linalg.init_tensor [5] : tensor<5xi32>
%4140 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4132, %4138 : tensor<5xi32>, tensor<5xi32>) outs(%4139 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4141 = linalg.init_tensor [5] : tensor<5xi32>
%4142 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4132, %4140 : tensor<5xi32>, tensor<5xi32>) outs(%4141 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4143 = linalg.init_tensor [5] : tensor<5xi32>
%4144 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4140, %cst_223 : tensor<5xi32>, tensor<5xi32>) outs(%4143 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4145 = linalg.init_tensor [5] : tensor<5xi32>
%4146 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4140, %cst_223 : tensor<5xi32>, tensor<5xi32>) outs(%4145 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4147 = linalg.init_tensor [5] : tensor<5xi32>
%4148 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4144, %4146 : tensor<5xi32>, tensor<5xi32>) outs(%4147 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4149 = linalg.init_tensor [5] : tensor<5xi32>
%4150 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4142, %4148 : tensor<5xi32>, tensor<5xi32>) outs(%4149 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4151 = linalg.init_tensor [5] : tensor<5xi32>
%4152 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4142, %4150 : tensor<5xi32>, tensor<5xi32>) outs(%4151 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4153 = linalg.init_tensor [5] : tensor<5xi32>
%4154 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4150, %cst_224 : tensor<5xi32>, tensor<5xi32>) outs(%4153 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4155 = linalg.init_tensor [5] : tensor<5xi32>
%4156 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4150, %cst_225 : tensor<5xi32>, tensor<5xi32>) outs(%4155 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4157 = linalg.init_tensor [5] : tensor<5xi32>
%4158 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4154, %4156 : tensor<5xi32>, tensor<5xi32>) outs(%4157 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4159 = linalg.init_tensor [5] : tensor<5xi32>
%4160 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4152, %4158 : tensor<5xi32>, tensor<5xi32>) outs(%4159 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4161 = linalg.init_tensor [5] : tensor<5xi32>
%4162 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4152, %4116 : tensor<5xi32>, tensor<5xi32>) outs(%4161 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4163 = linalg.init_tensor [5] : tensor<5xi32>
%4164 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4160, %4066 : tensor<5xi32>, tensor<5xi32>) outs(%4163 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4165 = linalg.init_tensor [5] : tensor<5xi32>
%4166 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4164, %cst_220 : tensor<5xi32>, tensor<5xi32>) outs(%4165 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4167 = linalg.init_tensor [5] : tensor<5xi32>
%4168 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4162, %4166 : tensor<5xi32>, tensor<5xi32>) outs(%4167 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4169 = linalg.init_tensor [5] : tensor<5xi32>
%4170 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4166, %cst_227 : tensor<5xi32>, tensor<5xi32>) outs(%4169 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4171 = linalg.init_tensor [5] : tensor<5xi32>
%4172 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4166, %cst_228 : tensor<5xi32>, tensor<5xi32>) outs(%4171 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4173 = linalg.init_tensor [5] : tensor<5xi32>
%4174 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4170, %4172 : tensor<5xi32>, tensor<5xi32>) outs(%4173 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4175 = linalg.init_tensor [5] : tensor<5xi32>
%4176 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4168, %4174 : tensor<5xi32>, tensor<5xi32>) outs(%4175 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4177 = linalg.init_tensor [5] : tensor<5xi32>
%4178 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4168, %4176 : tensor<5xi32>, tensor<5xi32>) outs(%4177 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4179 = linalg.init_tensor [5] : tensor<5xi32>
%4180 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4176, %cst_229 : tensor<5xi32>, tensor<5xi32>) outs(%4179 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4181 = linalg.init_tensor [5] : tensor<5xi32>
%4182 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4176, %cst_230 : tensor<5xi32>, tensor<5xi32>) outs(%4181 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4183 = linalg.init_tensor [5] : tensor<5xi32>
%4184 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4180, %4182 : tensor<5xi32>, tensor<5xi32>) outs(%4183 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4185 = linalg.init_tensor [5] : tensor<5xi32>
%4186 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4178, %4184 : tensor<5xi32>, tensor<5xi32>) outs(%4185 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4187 = linalg.init_tensor [5] : tensor<5xi32>
%4188 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4178, %4186 : tensor<5xi32>, tensor<5xi32>) outs(%4187 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4189 = linalg.init_tensor [5] : tensor<5xi32>
%4190 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4186, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4189 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4191 = linalg.init_tensor [5] : tensor<5xi32>
%4192 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4186, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4191 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4193 = linalg.init_tensor [5] : tensor<5xi32>
%4194 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4190, %4192 : tensor<5xi32>, tensor<5xi32>) outs(%4193 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4195 = linalg.init_tensor [5] : tensor<5xi32>
%4196 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4188, %4194 : tensor<5xi32>, tensor<5xi32>) outs(%4195 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4197 = linalg.init_tensor [5] : tensor<5xi32>
%4198 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4188, %4196 : tensor<5xi32>, tensor<5xi32>) outs(%4197 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4199 = linalg.init_tensor [5] : tensor<5xi32>
%4200 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4196, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4199 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4201 = linalg.init_tensor [5] : tensor<5xi32>
%4202 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4196, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4201 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4203 = linalg.init_tensor [5] : tensor<5xi32>
%4204 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4200, %4202 : tensor<5xi32>, tensor<5xi32>) outs(%4203 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4205 = linalg.init_tensor [5] : tensor<5xi32>
%4206 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4198, %4204 : tensor<5xi32>, tensor<5xi32>) outs(%4205 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4207 = linalg.init_tensor [5] : tensor<5xi32>
%4208 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4198, %4066 : tensor<5xi32>, tensor<5xi32>) outs(%4207 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4209 = linalg.init_tensor [5] : tensor<5xi32>
%4210 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4206, %4070 : tensor<5xi32>, tensor<5xi32>) outs(%4209 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4211 = linalg.init_tensor [5] : tensor<5xi32>
%4212 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4210, %cst_222 : tensor<5xi32>, tensor<5xi32>) outs(%4211 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4213 = linalg.init_tensor [5] : tensor<5xi32>
%4214 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4208, %4212 : tensor<5xi32>, tensor<5xi32>) outs(%4213 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4215 = linalg.init_tensor [5] : tensor<5xi32>
%4216 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4212, %cst_230 : tensor<5xi32>, tensor<5xi32>) outs(%4215 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4217 = linalg.init_tensor [5] : tensor<5xi32>
%4218 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4212, %cst_229 : tensor<5xi32>, tensor<5xi32>) outs(%4217 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4219 = linalg.init_tensor [5] : tensor<5xi32>
%4220 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4216, %4218 : tensor<5xi32>, tensor<5xi32>) outs(%4219 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4221 = linalg.init_tensor [5] : tensor<5xi32>
%4222 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4214, %4220 : tensor<5xi32>, tensor<5xi32>) outs(%4221 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4223 = linalg.init_tensor [5] : tensor<5xi32>
%4224 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4214, %4222 : tensor<5xi32>, tensor<5xi32>) outs(%4223 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4225 = linalg.init_tensor [5] : tensor<5xi32>
%4226 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4222, %cst_221 : tensor<5xi32>, tensor<5xi32>) outs(%4225 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4227 = linalg.init_tensor [5] : tensor<5xi32>
%4228 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4222, %cst_222 : tensor<5xi32>, tensor<5xi32>) outs(%4227 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4229 = linalg.init_tensor [5] : tensor<5xi32>
%4230 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4226, %4228 : tensor<5xi32>, tensor<5xi32>) outs(%4229 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4231 = linalg.init_tensor [5] : tensor<5xi32>
%4232 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4224, %4230 : tensor<5xi32>, tensor<5xi32>) outs(%4231 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4233 = linalg.init_tensor [5] : tensor<5xi32>
%4234 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4224, %4232 : tensor<5xi32>, tensor<5xi32>) outs(%4233 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4235 = linalg.init_tensor [5] : tensor<5xi32>
%4236 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4232, %cst_223 : tensor<5xi32>, tensor<5xi32>) outs(%4235 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4237 = linalg.init_tensor [5] : tensor<5xi32>
%4238 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4232, %cst_223 : tensor<5xi32>, tensor<5xi32>) outs(%4237 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4239 = linalg.init_tensor [5] : tensor<5xi32>
%4240 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4236, %4238 : tensor<5xi32>, tensor<5xi32>) outs(%4239 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4241 = linalg.init_tensor [5] : tensor<5xi32>
%4242 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4234, %4240 : tensor<5xi32>, tensor<5xi32>) outs(%4241 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4243 = linalg.init_tensor [5] : tensor<5xi32>
%4244 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4234, %4242 : tensor<5xi32>, tensor<5xi32>) outs(%4243 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4245 = linalg.init_tensor [5] : tensor<5xi32>
%4246 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4242, %cst_224 : tensor<5xi32>, tensor<5xi32>) outs(%4245 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4247 = linalg.init_tensor [5] : tensor<5xi32>
%4248 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4242, %cst_225 : tensor<5xi32>, tensor<5xi32>) outs(%4247 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4249 = linalg.init_tensor [5] : tensor<5xi32>
%4250 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4246, %4248 : tensor<5xi32>, tensor<5xi32>) outs(%4249 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4251 = linalg.init_tensor [5] : tensor<5xi32>
%4252 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4244, %4250 : tensor<5xi32>, tensor<5xi32>) outs(%4251 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4253 = linalg.init_tensor [5] : tensor<5xi32>
%4254 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4244, %4070 : tensor<5xi32>, tensor<5xi32>) outs(%4253 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4255 = linalg.init_tensor [5] : tensor<5xi32>
%4256 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4252, %4116 : tensor<5xi32>, tensor<5xi32>) outs(%4255 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4257 = linalg.init_tensor [5] : tensor<5xi32>
%4258 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4256, %cst_226 : tensor<5xi32>, tensor<5xi32>) outs(%4257 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4259 = linalg.init_tensor [5] : tensor<5xi32>
%4260 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4254, %4258 : tensor<5xi32>, tensor<5xi32>) outs(%4259 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4261 = linalg.init_tensor [5] : tensor<5xi32>
%4262 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4258, %cst_227 : tensor<5xi32>, tensor<5xi32>) outs(%4261 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4263 = linalg.init_tensor [5] : tensor<5xi32>
%4264 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4258, %cst_228 : tensor<5xi32>, tensor<5xi32>) outs(%4263 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4265 = linalg.init_tensor [5] : tensor<5xi32>
%4266 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4262, %4264 : tensor<5xi32>, tensor<5xi32>) outs(%4265 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4267 = linalg.init_tensor [5] : tensor<5xi32>
%4268 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4260, %4266 : tensor<5xi32>, tensor<5xi32>) outs(%4267 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4269 = linalg.init_tensor [5] : tensor<5xi32>
%4270 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4260, %4268 : tensor<5xi32>, tensor<5xi32>) outs(%4269 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4271 = linalg.init_tensor [5] : tensor<5xi32>
%4272 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4268, %cst_229 : tensor<5xi32>, tensor<5xi32>) outs(%4271 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4273 = linalg.init_tensor [5] : tensor<5xi32>
%4274 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4268, %cst_230 : tensor<5xi32>, tensor<5xi32>) outs(%4273 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4275 = linalg.init_tensor [5] : tensor<5xi32>
%4276 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4272, %4274 : tensor<5xi32>, tensor<5xi32>) outs(%4275 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4277 = linalg.init_tensor [5] : tensor<5xi32>
%4278 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4270, %4276 : tensor<5xi32>, tensor<5xi32>) outs(%4277 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4279 = linalg.init_tensor [5] : tensor<5xi32>
%4280 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4270, %4278 : tensor<5xi32>, tensor<5xi32>) outs(%4279 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4281 = linalg.init_tensor [5] : tensor<5xi32>
%4282 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4278, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4281 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4283 = linalg.init_tensor [5] : tensor<5xi32>
%4284 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4278, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4283 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4285 = linalg.init_tensor [5] : tensor<5xi32>
%4286 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4282, %4284 : tensor<5xi32>, tensor<5xi32>) outs(%4285 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4287 = linalg.init_tensor [5] : tensor<5xi32>
%4288 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4280, %4286 : tensor<5xi32>, tensor<5xi32>) outs(%4287 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4289 = linalg.init_tensor [5] : tensor<5xi32>
%4290 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4280, %4288 : tensor<5xi32>, tensor<5xi32>) outs(%4289 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4291 = linalg.init_tensor [5] : tensor<5xi32>
%4292 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4288, %cst_231 : tensor<5xi32>, tensor<5xi32>) outs(%4291 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shli %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4293 = linalg.init_tensor [5] : tensor<5xi32>
%4294 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4288, %cst_232 : tensor<5xi32>, tensor<5xi32>) outs(%4293 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4295 = linalg.init_tensor [5] : tensor<5xi32>
%4296 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4292, %4294 : tensor<5xi32>, tensor<5xi32>) outs(%4295 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4297 = linalg.init_tensor [5] : tensor<5xi32>
%4298 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4290, %4296 : tensor<5xi32>, tensor<5xi32>) outs(%4297 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.xori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4299 = linalg.init_tensor [5] : tensor<5xi32>
%4300 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4290, %4116 : tensor<5xi32>, tensor<5xi32>) outs(%4299 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4301 = linalg.init_tensor [5] : tensor<5xi32>
%4302 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4298, %4066 : tensor<5xi32>, tensor<5xi32>) outs(%4301 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4303 = linalg.init_tensor [5] : tensor<5xi32>
%4304 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4302, %cst_233 : tensor<5xi32>, tensor<5xi32>) outs(%4303 : tensor<5xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.addi %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<5xi32>
%4305 = linalg.init_tensor [10] : tensor<10xi32>
%4306 = linalg.fill(%c0_i32, %4305) : i32, tensor<10xi32> -> tensor<10xi32>
%4307 = tensor.insert_slice %4300 into %4306[0] [5] [1] : tensor<5xi32> into tensor<10xi32>
%4308 = tensor.insert_slice %4304 into %4307[5] [5] [1] : tensor<5xi32> into tensor<10xi32>
%4309 = linalg.init_tensor [10] : tensor<10xi32>
%4310 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4308, %cst_234 : tensor<10xi32>, tensor<10xi32>) outs(%4309 : tensor<10xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.shrui %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<10xi32>
%4311 = linalg.init_tensor [10] : tensor<10xi32>
%4312 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4310, %cst_235 : tensor<10xi32>, tensor<10xi32>) outs(%4311 : tensor<10xi32>) {
^bb0(%arg1: i32, %arg2: i32, %arg3: i32): // no predecessors
%4407 = arith.ori %arg1, %arg2 : i32
linalg.yield %4407 : i32
} -> tensor<10xi32>
%4313 = linalg.init_tensor [10] : tensor<10xf32>
%4314 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4312 : tensor<10xi32>) outs(%4313 : tensor<10xf32>) {
^bb0(%arg1: i32, %arg2: f32): // no predecessors
%4407 = arith.bitcast %arg1 : i32 to f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4315 = linalg.init_tensor [10] : tensor<10xf32>
%4316 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4314, %cst_6 : tensor<10xf32>, tensor<10xf32>) outs(%4315 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4317 = linalg.init_tensor [10] : tensor<10xf32>
%4318 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4316, %cst_236 : tensor<10xf32>, tensor<10xf32>) outs(%4317 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4319 = linalg.init_tensor [10] : tensor<10xf32>
%4320 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4318, %cst_237 : tensor<10xf32>, tensor<10xf32>) outs(%4319 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4321 = linalg.init_tensor [10] : tensor<10xf32>
%4322 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4320, %cst_237 : tensor<10xf32>, tensor<10xf32>) outs(%4321 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.maxf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4323 = linalg.init_tensor [10] : tensor<10xf32>
%4324 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4322 : tensor<10xf32>) outs(%4323 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.abs %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4325 = linalg.init_tensor [10] : tensor<10xi1>
%4326 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4324, %cst_6 : tensor<10xf32>, tensor<10xf32>) outs(%4325 : tensor<10xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf oeq, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<10xi1>
%4327 = linalg.init_tensor [10] : tensor<10xf32>
%4328 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4322, %cst_7 : tensor<10xf32>, tensor<10xf32>) outs(%4327 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4329 = linalg.init_tensor [10] : tensor<10xf32>
%4330 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4322 : tensor<10xf32>) outs(%4329 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4331 = linalg.init_tensor [10] : tensor<10xf32>
%4332 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4330, %4322 : tensor<10xf32>, tensor<10xf32>) outs(%4331 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4333 = linalg.init_tensor [10] : tensor<10xf32>
%4334 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4332, %cst_6 : tensor<10xf32>, tensor<10xf32>) outs(%4333 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4335 = linalg.init_tensor [10] : tensor<10xf32>
%4336 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4334 : tensor<10xf32>) outs(%4335 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.log %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4337 = linalg.init_tensor [10] : tensor<10xf32>
%4338 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4336 : tensor<10xf32>) outs(%4337 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = arith.negf %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4339 = linalg.init_tensor [10] : tensor<10xi1>
%4340 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4338, %cst_8 : tensor<10xf32>, tensor<10xf32>) outs(%4339 : tensor<10xi1>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: i1): // no predecessors
%4407 = arith.cmpf olt, %arg1, %arg2 : f32
linalg.yield %4407 : i1
} -> tensor<10xi1>
%4341 = linalg.init_tensor [10] : tensor<10xf32>
%4342 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_9, %cst_10 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4341 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4343 = linalg.init_tensor [10] : tensor<10xf32>
%4344 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_11, %cst_12 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4343 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4345 = linalg.init_tensor [10] : tensor<10xf32>
%4346 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_13, %cst_14 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4345 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4347 = linalg.init_tensor [10] : tensor<10xf32>
%4348 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_15, %cst_16 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4347 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4349 = linalg.init_tensor [10] : tensor<10xf32>
%4350 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_17, %cst_18 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4349 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4351 = linalg.init_tensor [10] : tensor<10xf32>
%4352 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_19, %cst_20 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4351 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4353 = linalg.init_tensor [10] : tensor<10xf32>
%4354 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_21, %cst_22 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4353 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4355 = linalg.init_tensor [10] : tensor<10xf32>
%4356 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_23, %cst_24 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4355 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4357 = linalg.init_tensor [10] : tensor<10xf32>
%4358 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %cst_25, %cst_26 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4357 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4359 = linalg.init_tensor [10] : tensor<10xf32>
%4360 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4338, %cst_27 : tensor<10xf32>, tensor<10xf32>) outs(%4359 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4361 = linalg.init_tensor [10] : tensor<10xf32>
%4362 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = ["parallel"]} ins(%4338 : tensor<10xf32>) outs(%4361 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32): // no predecessors
%4407 = math.sqrt %arg1 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4363 = linalg.init_tensor [10] : tensor<10xf32>
%4364 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4362, %cst_28 : tensor<10xf32>, tensor<10xf32>) outs(%4363 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.subf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4365 = linalg.init_tensor [10] : tensor<10xf32>
%4366 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4340, %4360, %4364 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4365 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4367 = linalg.init_tensor [10] : tensor<10xf32>
%4368 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4358, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4367 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4369 = linalg.init_tensor [10] : tensor<10xf32>
%4370 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4356, %4368 : tensor<10xf32>, tensor<10xf32>) outs(%4369 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4371 = linalg.init_tensor [10] : tensor<10xf32>
%4372 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4370, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4371 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4373 = linalg.init_tensor [10] : tensor<10xf32>
%4374 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4354, %4372 : tensor<10xf32>, tensor<10xf32>) outs(%4373 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4375 = linalg.init_tensor [10] : tensor<10xf32>
%4376 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4374, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4375 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4377 = linalg.init_tensor [10] : tensor<10xf32>
%4378 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4352, %4376 : tensor<10xf32>, tensor<10xf32>) outs(%4377 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4379 = linalg.init_tensor [10] : tensor<10xf32>
%4380 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4378, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4379 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4381 = linalg.init_tensor [10] : tensor<10xf32>
%4382 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4350, %4380 : tensor<10xf32>, tensor<10xf32>) outs(%4381 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4383 = linalg.init_tensor [10] : tensor<10xf32>
%4384 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4382, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4383 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4385 = linalg.init_tensor [10] : tensor<10xf32>
%4386 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4348, %4384 : tensor<10xf32>, tensor<10xf32>) outs(%4385 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4387 = linalg.init_tensor [10] : tensor<10xf32>
%4388 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4386, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4387 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4389 = linalg.init_tensor [10] : tensor<10xf32>
%4390 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4346, %4388 : tensor<10xf32>, tensor<10xf32>) outs(%4389 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4391 = linalg.init_tensor [10] : tensor<10xf32>
%4392 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4390, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4391 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4393 = linalg.init_tensor [10] : tensor<10xf32>
%4394 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4344, %4392 : tensor<10xf32>, tensor<10xf32>) outs(%4393 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4395 = linalg.init_tensor [10] : tensor<10xf32>
%4396 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4394, %4366 : tensor<10xf32>, tensor<10xf32>) outs(%4395 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4397 = linalg.init_tensor [10] : tensor<10xf32>
%4398 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4342, %4396 : tensor<10xf32>, tensor<10xf32>) outs(%4397 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.addf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4399 = linalg.init_tensor [10] : tensor<10xf32>
%4400 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4398, %4322 : tensor<10xf32>, tensor<10xf32>) outs(%4399 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4401 = linalg.init_tensor [10] : tensor<10xf32>
%4402 = linalg.generic {indexing_maps = [#map0, #map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4326, %4328, %4400 : tensor<10xi1>, tensor<10xf32>, tensor<10xf32>) outs(%4401 : tensor<10xf32>) {
^bb0(%arg1: i1, %arg2: f32, %arg3: f32, %arg4: f32): // no predecessors
%4407 = select %arg1, %arg2, %arg3 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4403 = linalg.init_tensor [10] : tensor<10xf32>
%4404 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4402, %cst_239 : tensor<10xf32>, tensor<10xf32>) outs(%4403 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
%4405 = linalg.init_tensor [10] : tensor<10xf32>
%4406 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%4404, %cst_240 : tensor<10xf32>, tensor<10xf32>) outs(%4405 : tensor<10xf32>) {
^bb0(%arg1: f32, %arg2: f32, %arg3: f32): // no predecessors
%4407 = arith.mulf %arg1, %arg2 : f32
linalg.yield %4407 : f32
} -> tensor<10xf32>
return %1078, %cst_257, %1432, %cst_259, %2568, %cst_258, %2918, %cst_259, %4052, %cst_260, %4406, %cst_261 : tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>
}
func private @main_0(%arg0: tensor<128x784xf32>, %arg1: tensor<128x10xf32>, %arg2: tensor<784x1024xf32>, %arg3: tensor<784x1024xf32>, %arg4: tensor<1024xf32>, %arg5: tensor<1024xf32>, %arg6: tensor<1024x1024xf32>, %arg7: tensor<1024x1024xf32>, %arg8: tensor<1024xf32>, %arg9: tensor<1024xf32>, %arg10: tensor<1024x10xf32>, %arg11: tensor<1024x10xf32>, %arg12: tensor<10xf32>, %arg13: tensor<10xf32>) -> (tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>) {
%cst = arith.constant 0.000000e+00 : f32
%cst_0 = arith.constant 0xFF800000 : f32
%cst_1 = arith.constant dense<1.000000e-03> : tensor<10xf32>
%cst_2 = arith.constant dense<0.899999976> : tensor<10xf32>
%cst_3 = arith.constant dense<1.000000e-03> : tensor<1024x10xf32>
%cst_4 = arith.constant dense<0.899999976> : tensor<1024x10xf32>
%cst_5 = arith.constant dense<1.000000e-03> : tensor<1024xf32>
%cst_6 = arith.constant dense<0.899999976> : tensor<1024xf32>
%cst_7 = arith.constant dense<1.000000e-03> : tensor<1024x1024xf32>
%cst_8 = arith.constant dense<0.899999976> : tensor<1024x1024xf32>
%cst_9 = arith.constant dense<1.000000e-03> : tensor<784x1024xf32>
%cst_10 = arith.constant dense<0.899999976> : tensor<784x1024xf32>
%cst_11 = arith.constant dense<0.000000e+00> : tensor<128x1024xf32>
%cst_12 = arith.constant dense<-7.812500e-03> : tensor<128x10xf32>
%0 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%1 = linalg.fill(%cst, %0) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%2 = linalg.matmul ins(%arg0, %arg2 : tensor<128x784xf32>, tensor<784x1024xf32>) outs(%1 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%3 = linalg.init_tensor [1, 1024] : tensor<1x1024xf32>
%4 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg4 : tensor<1024xf32>) outs(%3 : tensor<1x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1x1024xf32>
%5 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%6 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%4 : tensor<1x1024xf32>) outs(%5 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x1024xf32>
%7 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%8 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2, %6 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%7 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%9 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%10 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%8, %cst_11 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%9 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.maxf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%11 = linalg.init_tensor [128, 1024] : tensor<128x1024xi1>
%12 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%8, %cst_11 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%11 : tensor<128x1024xi1>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: i1): // no predecessors
%174 = arith.cmpf ogt, %arg14, %arg15 : f32
linalg.yield %174 : i1
} -> tensor<128x1024xi1>
%13 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%14 = linalg.fill(%cst, %13) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%15 = linalg.matmul ins(%10, %arg6 : tensor<128x1024xf32>, tensor<1024x1024xf32>) outs(%14 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%16 = linalg.init_tensor [1, 1024] : tensor<1x1024xf32>
%17 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg8 : tensor<1024xf32>) outs(%16 : tensor<1x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1x1024xf32>
%18 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%19 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%17 : tensor<1x1024xf32>) outs(%18 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x1024xf32>
%20 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%21 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%15, %19 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%20 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%22 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%23 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%21, %cst_11 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%22 : tensor<128x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.maxf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%24 = linalg.init_tensor [128, 1024] : tensor<128x1024xi1>
%25 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%21, %cst_11 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%24 : tensor<128x1024xi1>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: i1): // no predecessors
%174 = arith.cmpf ogt, %arg14, %arg15 : f32
linalg.yield %174 : i1
} -> tensor<128x1024xi1>
%26 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%27 = linalg.fill(%cst, %26) : f32, tensor<128x10xf32> -> tensor<128x10xf32>
%28 = linalg.matmul ins(%23, %arg10 : tensor<128x1024xf32>, tensor<1024x10xf32>) outs(%27 : tensor<128x10xf32>) -> tensor<128x10xf32>
%29 = linalg.init_tensor [1, 10] : tensor<1x10xf32>
%30 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg12 : tensor<10xf32>) outs(%29 : tensor<1x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1x10xf32>
%31 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%32 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%30 : tensor<1x10xf32>) outs(%31 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x10xf32>
%33 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%34 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%28, %32 : tensor<128x10xf32>, tensor<128x10xf32>) outs(%33 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%35 = linalg.init_tensor [128] : tensor<128xf32>
%36 = linalg.fill(%cst_0, %35) : f32, tensor<128xf32> -> tensor<128xf32>
%37 = linalg.generic {indexing_maps = [#map4, #map8], iterator_types = ["parallel", "reduction"]} ins(%34 : tensor<128x10xf32>) outs(%36 : tensor<128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.maxf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128xf32>
%38 = linalg.init_tensor [128, 1] : tensor<128x1xf32>
%39 = linalg.generic {indexing_maps = [#map8, #map4], iterator_types = ["parallel", "parallel"]} ins(%37 : tensor<128xf32>) outs(%38 : tensor<128x1xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x1xf32>
%40 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%41 = linalg.generic {indexing_maps = [#map9, #map4], iterator_types = ["parallel", "parallel"]} ins(%39 : tensor<128x1xf32>) outs(%40 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x10xf32>
%42 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%43 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%34, %41 : tensor<128x10xf32>, tensor<128x10xf32>) outs(%42 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%44 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%45 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%43 : tensor<128x10xf32>) outs(%44 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = math.exp %arg14 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%46 = linalg.init_tensor [128] : tensor<128xf32>
%47 = linalg.fill(%cst, %46) : f32, tensor<128xf32> -> tensor<128xf32>
%48 = linalg.generic {indexing_maps = [#map4, #map8], iterator_types = ["parallel", "reduction"]} ins(%45 : tensor<128x10xf32>) outs(%47 : tensor<128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128xf32>
%49 = linalg.init_tensor [128, 1] : tensor<128x1xf32>
%50 = linalg.generic {indexing_maps = [#map8, #map4], iterator_types = ["parallel", "parallel"]} ins(%48 : tensor<128xf32>) outs(%49 : tensor<128x1xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x1xf32>
%51 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%52 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg1, %cst_12 : tensor<128x10xf32>, tensor<128x10xf32>) outs(%51 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%53 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%54 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%52 : tensor<128x10xf32>) outs(%53 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.negf %arg14 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%55 = linalg.init_tensor [128] : tensor<128xf32>
%56 = linalg.fill(%cst, %55) : f32, tensor<128xf32> -> tensor<128xf32>
%57 = linalg.generic {indexing_maps = [#map4, #map8], iterator_types = ["parallel", "reduction"]} ins(%54 : tensor<128x10xf32>) outs(%56 : tensor<128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128xf32>
%58 = linalg.tensor_expand_shape %57 [[0, 1]] : tensor<128xf32> into tensor<128x1xf32>
%59 = linalg.init_tensor [128, 1] : tensor<128x1xf32>
%60 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%58, %50 : tensor<128x1xf32>, tensor<128x1xf32>) outs(%59 : tensor<128x1xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.divf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x1xf32>
%61 = linalg.init_tensor [128] : tensor<128xf32>
%62 = linalg.fill(%cst, %61) : f32, tensor<128xf32> -> tensor<128xf32>
%63 = linalg.generic {indexing_maps = [#map4, #map8], iterator_types = ["parallel", "reduction"]} ins(%60 : tensor<128x1xf32>) outs(%62 : tensor<128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128xf32>
%64 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%65 = linalg.generic {indexing_maps = [#map8, #map4], iterator_types = ["parallel", "parallel"]} ins(%63 : tensor<128xf32>) outs(%64 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<128x10xf32>
%66 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%67 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%65, %45 : tensor<128x10xf32>, tensor<128x10xf32>) outs(%66 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%68 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%69 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%52, %67 : tensor<128x10xf32>, tensor<128x10xf32>) outs(%68 : tensor<128x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<128x10xf32>
%70 = linalg.init_tensor [10] : tensor<10xf32>
%71 = linalg.fill(%cst, %70) : f32, tensor<10xf32> -> tensor<10xf32>
%72 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%69 : tensor<128x10xf32>) outs(%71 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
%73 = linalg.tensor_expand_shape %72 [[0, 1]] : tensor<10xf32> into tensor<1x10xf32>
%74 = linalg.init_tensor [10] : tensor<10xf32>
%75 = linalg.fill(%cst, %74) : f32, tensor<10xf32> -> tensor<10xf32>
%76 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%73 : tensor<1x10xf32>) outs(%75 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
%77 = linalg.init_tensor [10, 128] : tensor<10x128xf32>
%78 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%69 : tensor<128x10xf32>) outs(%77 : tensor<10x128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<10x128xf32>
%79 = linalg.init_tensor [10, 1024] : tensor<10x1024xf32>
%80 = linalg.fill(%cst, %79) : f32, tensor<10x1024xf32> -> tensor<10x1024xf32>
%81 = linalg.matmul ins(%78, %23 : tensor<10x128xf32>, tensor<128x1024xf32>) outs(%80 : tensor<10x1024xf32>) -> tensor<10x1024xf32>
%82 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%83 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%81 : tensor<10x1024xf32>) outs(%82 : tensor<1024x10xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1024x10xf32>
%84 = linalg.init_tensor [10, 1024] : tensor<10x1024xf32>
%85 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg10 : tensor<1024x10xf32>) outs(%84 : tensor<10x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<10x1024xf32>
%86 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%87 = linalg.fill(%cst, %86) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%88 = linalg.matmul ins(%69, %85 : tensor<128x10xf32>, tensor<10x1024xf32>) outs(%87 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%89 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%90 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%25, %88, %cst_11 : tensor<128x1024xi1>, tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%89 : tensor<128x1024xf32>) {
^bb0(%arg14: i1, %arg15: f32, %arg16: f32, %arg17: f32): // no predecessors
%174 = select %arg14, %arg15, %arg16 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%91 = linalg.init_tensor [1024] : tensor<1024xf32>
%92 = linalg.fill(%cst, %91) : f32, tensor<1024xf32> -> tensor<1024xf32>
%93 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%90 : tensor<128x1024xf32>) outs(%92 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%94 = linalg.tensor_expand_shape %93 [[0, 1]] : tensor<1024xf32> into tensor<1x1024xf32>
%95 = linalg.init_tensor [1024] : tensor<1024xf32>
%96 = linalg.fill(%cst, %95) : f32, tensor<1024xf32> -> tensor<1024xf32>
%97 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%94 : tensor<1x1024xf32>) outs(%96 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%98 = linalg.init_tensor [1024, 128] : tensor<1024x128xf32>
%99 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%90 : tensor<128x1024xf32>) outs(%98 : tensor<1024x128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1024x128xf32>
%100 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%101 = linalg.fill(%cst, %100) : f32, tensor<1024x1024xf32> -> tensor<1024x1024xf32>
%102 = linalg.matmul ins(%99, %10 : tensor<1024x128xf32>, tensor<128x1024xf32>) outs(%101 : tensor<1024x1024xf32>) -> tensor<1024x1024xf32>
%103 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%104 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%102 : tensor<1024x1024xf32>) outs(%103 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1024x1024xf32>
%105 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%106 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg6 : tensor<1024x1024xf32>) outs(%105 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1024x1024xf32>
%107 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%108 = linalg.fill(%cst, %107) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%109 = linalg.matmul ins(%90, %106 : tensor<128x1024xf32>, tensor<1024x1024xf32>) outs(%108 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%110 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%111 = linalg.generic {indexing_maps = [#map4, #map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%12, %109, %cst_11 : tensor<128x1024xi1>, tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%110 : tensor<128x1024xf32>) {
^bb0(%arg14: i1, %arg15: f32, %arg16: f32, %arg17: f32): // no predecessors
%174 = select %arg14, %arg15, %arg16 : f32
linalg.yield %174 : f32
} -> tensor<128x1024xf32>
%112 = linalg.init_tensor [1024] : tensor<1024xf32>
%113 = linalg.fill(%cst, %112) : f32, tensor<1024xf32> -> tensor<1024xf32>
%114 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%111 : tensor<128x1024xf32>) outs(%113 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%115 = linalg.tensor_expand_shape %114 [[0, 1]] : tensor<1024xf32> into tensor<1x1024xf32>
%116 = linalg.init_tensor [1024] : tensor<1024xf32>
%117 = linalg.fill(%cst, %116) : f32, tensor<1024xf32> -> tensor<1024xf32>
%118 = linalg.generic {indexing_maps = [#map10, #map8], iterator_types = ["parallel", "reduction"]} ins(%115 : tensor<1x1024xf32>) outs(%117 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%119 = linalg.init_tensor [1024, 128] : tensor<1024x128xf32>
%120 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%111 : tensor<128x1024xf32>) outs(%119 : tensor<1024x128xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<1024x128xf32>
%121 = linalg.init_tensor [1024, 784] : tensor<1024x784xf32>
%122 = linalg.fill(%cst, %121) : f32, tensor<1024x784xf32> -> tensor<1024x784xf32>
%123 = linalg.matmul ins(%120, %arg0 : tensor<1024x128xf32>, tensor<128x784xf32>) outs(%122 : tensor<1024x784xf32>) -> tensor<1024x784xf32>
%124 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%125 = linalg.generic {indexing_maps = [#map10, #map4], iterator_types = ["parallel", "parallel"]} ins(%123 : tensor<1024x784xf32>) outs(%124 : tensor<784x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32): // no predecessors
linalg.yield %arg14 : f32
} -> tensor<784x1024xf32>
%126 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%127 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg3, %cst_10 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%126 : tensor<784x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<784x1024xf32>
%128 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%129 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%127, %125 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%128 : tensor<784x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<784x1024xf32>
%130 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%131 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%129, %cst_9 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%130 : tensor<784x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<784x1024xf32>
%132 = linalg.init_tensor [784, 1024] : tensor<784x1024xf32>
%133 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg2, %131 : tensor<784x1024xf32>, tensor<784x1024xf32>) outs(%132 : tensor<784x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<784x1024xf32>
%134 = linalg.init_tensor [1024] : tensor<1024xf32>
%135 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg5, %cst_6 : tensor<1024xf32>, tensor<1024xf32>) outs(%134 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%136 = linalg.init_tensor [1024] : tensor<1024xf32>
%137 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%135, %118 : tensor<1024xf32>, tensor<1024xf32>) outs(%136 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%138 = linalg.init_tensor [1024] : tensor<1024xf32>
%139 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%137, %cst_5 : tensor<1024xf32>, tensor<1024xf32>) outs(%138 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%140 = linalg.init_tensor [1024] : tensor<1024xf32>
%141 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg4, %139 : tensor<1024xf32>, tensor<1024xf32>) outs(%140 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%142 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%143 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg7, %cst_8 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%142 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x1024xf32>
%144 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%145 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%143, %104 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%144 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x1024xf32>
%146 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%147 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%145, %cst_7 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%146 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x1024xf32>
%148 = linalg.init_tensor [1024, 1024] : tensor<1024x1024xf32>
%149 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg6, %147 : tensor<1024x1024xf32>, tensor<1024x1024xf32>) outs(%148 : tensor<1024x1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x1024xf32>
%150 = linalg.init_tensor [1024] : tensor<1024xf32>
%151 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg9, %cst_6 : tensor<1024xf32>, tensor<1024xf32>) outs(%150 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%152 = linalg.init_tensor [1024] : tensor<1024xf32>
%153 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%151, %97 : tensor<1024xf32>, tensor<1024xf32>) outs(%152 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%154 = linalg.init_tensor [1024] : tensor<1024xf32>
%155 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%153, %cst_5 : tensor<1024xf32>, tensor<1024xf32>) outs(%154 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%156 = linalg.init_tensor [1024] : tensor<1024xf32>
%157 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg8, %155 : tensor<1024xf32>, tensor<1024xf32>) outs(%156 : tensor<1024xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024xf32>
%158 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%159 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg11, %cst_4 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%158 : tensor<1024x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x10xf32>
%160 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%161 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%159, %83 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%160 : tensor<1024x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x10xf32>
%162 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%163 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%161, %cst_3 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%162 : tensor<1024x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x10xf32>
%164 = linalg.init_tensor [1024, 10] : tensor<1024x10xf32>
%165 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg10, %163 : tensor<1024x10xf32>, tensor<1024x10xf32>) outs(%164 : tensor<1024x10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<1024x10xf32>
%166 = linalg.init_tensor [10] : tensor<10xf32>
%167 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg13, %cst_2 : tensor<10xf32>, tensor<10xf32>) outs(%166 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
%168 = linalg.init_tensor [10] : tensor<10xf32>
%169 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%167, %76 : tensor<10xf32>, tensor<10xf32>) outs(%168 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.addf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
%170 = linalg.init_tensor [10] : tensor<10xf32>
%171 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%169, %cst_1 : tensor<10xf32>, tensor<10xf32>) outs(%170 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.mulf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
%172 = linalg.init_tensor [10] : tensor<10xf32>
%173 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = ["parallel"]} ins(%arg12, %171 : tensor<10xf32>, tensor<10xf32>) outs(%172 : tensor<10xf32>) {
^bb0(%arg14: f32, %arg15: f32, %arg16: f32): // no predecessors
%174 = arith.subf %arg14, %arg15 : f32
linalg.yield %174 : f32
} -> tensor<10xf32>
return %133, %129, %141, %137, %149, %145, %157, %153, %165, %161, %173, %169 : tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>
}
func @update(%arg0: tensor<128x784xf32>, %arg1: tensor<128x10xf32>) {
%0 = iree_input.global.load @opt_state$0 : tensor<784x1024xf32>
%1 = iree_input.global.load @opt_state$1 : tensor<784x1024xf32>
%2 = iree_input.global.load @opt_state$2 : tensor<1024xf32>
%3 = iree_input.global.load @opt_state$3 : tensor<1024xf32>
%4 = iree_input.global.load @opt_state$4 : tensor<1024x1024xf32>
%5 = iree_input.global.load @opt_state$5 : tensor<1024x1024xf32>
%6 = iree_input.global.load @opt_state$6 : tensor<1024xf32>
%7 = iree_input.global.load @opt_state$7 : tensor<1024xf32>
%8 = iree_input.global.load @opt_state$8 : tensor<1024x10xf32>
%9 = iree_input.global.load @opt_state$9 : tensor<1024x10xf32>
%10 = iree_input.global.load @opt_state$10 : tensor<10xf32>
%11 = iree_input.global.load @opt_state$11 : tensor<10xf32>
%12:12 = call @main_0(%arg0, %arg1, %0, %1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11) : (tensor<128x784xf32>, tensor<128x10xf32>, tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>) -> (tensor<784x1024xf32>, tensor<784x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x1024xf32>, tensor<1024x1024xf32>, tensor<1024xf32>, tensor<1024xf32>, tensor<1024x10xf32>, tensor<1024x10xf32>, tensor<10xf32>, tensor<10xf32>)
iree_input.global.store %12#0, @opt_state$0 : tensor<784x1024xf32>
iree_input.global.store %12#1, @opt_state$1 : tensor<784x1024xf32>
iree_input.global.store %12#2, @opt_state$2 : tensor<1024xf32>
iree_input.global.store %12#3, @opt_state$3 : tensor<1024xf32>
iree_input.global.store %12#4, @opt_state$4 : tensor<1024x1024xf32>
iree_input.global.store %12#5, @opt_state$5 : tensor<1024x1024xf32>
iree_input.global.store %12#6, @opt_state$6 : tensor<1024xf32>
iree_input.global.store %12#7, @opt_state$7 : tensor<1024xf32>
iree_input.global.store %12#8, @opt_state$8 : tensor<1024x10xf32>
iree_input.global.store %12#9, @opt_state$9 : tensor<1024x10xf32>
iree_input.global.store %12#10, @opt_state$10 : tensor<10xf32>
iree_input.global.store %12#11, @opt_state$11 : tensor<10xf32>
return
}
func private @main_1(%arg0: tensor<784x1024xf32>, %arg1: tensor<1024xf32>, %arg2: tensor<1024x1024xf32>, %arg3: tensor<1024xf32>, %arg4: tensor<1024x10xf32>, %arg5: tensor<10xf32>, %arg6: tensor<128x784xf32>) -> tensor<128x10xf32> {
%cst = arith.constant 0.000000e+00 : f32
%cst_0 = arith.constant 0xFF800000 : f32
%cst_1 = arith.constant dense<0.000000e+00> : tensor<128x1024xf32>
%0 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%1 = linalg.fill(%cst, %0) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%2 = linalg.matmul ins(%arg6, %arg0 : tensor<128x784xf32>, tensor<784x1024xf32>) outs(%1 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%3 = linalg.init_tensor [1, 1024] : tensor<1x1024xf32>
%4 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg1 : tensor<1024xf32>) outs(%3 : tensor<1x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32): // no predecessors
linalg.yield %arg7 : f32
} -> tensor<1x1024xf32>
%5 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%6 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%4 : tensor<1x1024xf32>) outs(%5 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32): // no predecessors
linalg.yield %arg7 : f32
} -> tensor<128x1024xf32>
%7 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%8 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%2, %6 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%7 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32, %arg9: f32): // no predecessors
%53 = arith.addf %arg7, %arg8 : f32
linalg.yield %53 : f32
} -> tensor<128x1024xf32>
%9 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%10 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%8, %cst_1 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%9 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32, %arg9: f32): // no predecessors
%53 = arith.maxf %arg7, %arg8 : f32
linalg.yield %53 : f32
} -> tensor<128x1024xf32>
%11 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%12 = linalg.fill(%cst, %11) : f32, tensor<128x1024xf32> -> tensor<128x1024xf32>
%13 = linalg.matmul ins(%10, %arg2 : tensor<128x1024xf32>, tensor<1024x1024xf32>) outs(%12 : tensor<128x1024xf32>) -> tensor<128x1024xf32>
%14 = linalg.init_tensor [1, 1024] : tensor<1x1024xf32>
%15 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg3 : tensor<1024xf32>) outs(%14 : tensor<1x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32): // no predecessors
linalg.yield %arg7 : f32
} -> tensor<1x1024xf32>
%16 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%17 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%15 : tensor<1x1024xf32>) outs(%16 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32): // no predecessors
linalg.yield %arg7 : f32
} -> tensor<128x1024xf32>
%18 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%19 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%13, %17 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%18 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32, %arg9: f32): // no predecessors
%53 = arith.addf %arg7, %arg8 : f32
linalg.yield %53 : f32
} -> tensor<128x1024xf32>
%20 = linalg.init_tensor [128, 1024] : tensor<128x1024xf32>
%21 = linalg.generic {indexing_maps = [#map4, #map4, #map4], iterator_types = ["parallel", "parallel"]} ins(%19, %cst_1 : tensor<128x1024xf32>, tensor<128x1024xf32>) outs(%20 : tensor<128x1024xf32>) {
^bb0(%arg7: f32, %arg8: f32, %arg9: f32): // no predecessors
%53 = arith.maxf %arg7, %arg8 : f32
linalg.yield %53 : f32
} -> tensor<128x1024xf32>
%22 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%23 = linalg.fill(%cst, %22) : f32, tensor<128x10xf32> -> tensor<128x10xf32>
%24 = linalg.matmul ins(%21, %arg4 : tensor<128x1024xf32>, tensor<1024x10xf32>) outs(%23 : tensor<128x10xf32>) -> tensor<128x10xf32>
%25 = linalg.init_tensor [1, 10] : tensor<1x10xf32>
%26 = linalg.generic {indexing_maps = [#map6, #map4], iterator_types = ["parallel", "parallel"]} ins(%arg5 : tensor<10xf32>) outs(%25 : tensor<1x10xf32>) {
^bb0(%arg7: f32, %arg8: f32): // no predecessors
linalg.yield %arg7 : f32
} -> tensor<1x10xf32>
%27 = linalg.init_tensor [128, 10] : tensor<128x10xf32>
%28 = linalg.generic {indexing_maps = [#map7, #map4], iterator_types = ["parallel", "parallel"]} ins(%26 : tensor<1x10xf32>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment