Skip to content

Instantly share code, notes, and snippets.

@pashu123

pashu123/xyz.mlir

Created October 20, 2022 13:50
Show Gist options
  • Save pashu123/86e342a4ee786a22a9b3f8bd650e1b54 to your computer and use it in GitHub Desktop.
Save pashu123/86e342a4ee786a22a9b3f8bd650e1b54 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
xyz.mlir
This file has been truncated, but you can view the full file.
#map0 = affine_map<() -> ()>
#map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
#map2 = affine_map<(d0, d1, d2, d3) -> ()>
#map3 = affine_map<(d0) -> (0)>
#map4 = affine_map<(d0) -> (d0)>
#map5 = affine_map<(d0) -> ()>
#map6 = affine_map<(d0, d1) -> ()>
#map7 = affine_map<(d0, d1) -> (d0, d1)>
#map8 = affine_map<(d0, d1) -> (d0, 0)>
#map9 = affine_map<(d0, d1) -> (0, d1)>
#map10 = affine_map<(d0, d1) -> (d1, d0)>
#map11 = affine_map<(d0, d1) -> (d1)>
#map12 = affine_map<(d0, d1, d2, d3) -> (d1)>
#map13 = affine_map<(d0, d1, d2, d3) -> (d0, d1, 0, 0)>
#map14 = affine_map<(d0, d1, d2, d3) -> (d1, 0, 0)>
#map15 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d3, d1)>
#map16 = affine_map<(d0, d1, d2) -> (d0, d1, d2)>
#map17 = affine_map<(d0, d1, d2) -> (d0, d1, 0)>
#map18 = affine_map<(d0, d1, d2) -> (d2)>
#map19 = affine_map<(d0, d1, d2, d3) -> (d0, d2, d1, d3)>
#map20 = affine_map<(d0, d1, d2) -> (d0, d2, d1)>
#map21 = affine_map<(d0, d1, d2) -> ()>
#map22 = affine_map<(d0, d1, d2, d3) -> (d0, d3, d1, d2)>
#map23 = affine_map<(d0, d1, d2, d3) -> (0, d1, d2, d3)>
module attributes {torch.debug_module_name = "_lambda"} {
func.func @forward(%arg0: tensor<1x4x64x64xf16>, %arg1: tensor<1xf16>, %arg2: tensor<2x77x768xf16>, %arg3: tensor<f32>) -> tensor<1x4x64x64xf16> {
%cst = arith.constant dense<7.500000e+00> : tensor<f64>
%cst_0 = arith.constant dense<0.079056941504209485> : tensor<f64>
%cst_1 = arith.constant dense<0.11180339887498948> : tensor<f64>
%cst_2 = arith.constant dense<0.15811388300841897> : tensor<f64>
%cst_3 = arith.constant dense<9.9999999999999995E-7> : tensor<f64>
%cst_4 = arith.constant dense<1.000000e+00> : tensor<f64>
%cst_5 = arith.constant dense<1.000000e-05> : tensor<f64>
%cst_6 = arith.constant dense<160> : tensor<i64>
%cst_7 = arith.constant dense<-9.2103403719761836> : tensor<f64>
%cst_8 = arith.constant dense<1> : tensor<i64>
%cst_9 = arith.constant dense_resource<__elided__> : tensor<1280x320xf16>
%cst_10 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_11 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_12 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_13 = arith.constant dense_resource<__elided__> : tensor<320x4x3x3xf16>
%cst_14 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_15 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_16 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_17 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_18 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_19 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_20 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_21 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_22 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_23 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_24 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_25 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_26 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_27 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_28 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_29 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_30 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_31 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_32 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_33 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_34 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_35 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_36 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_37 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_38 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_39 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_40 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_41 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_42 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_43 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_44 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_45 = arith.constant dense_resource<__elided__> : tensor<2560x320xf16>
%cst_46 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_47 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_48 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_49 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_50 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_51 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_52 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_53 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_54 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_55 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_56 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_57 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_58 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_59 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_60 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_61 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_62 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_63 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_64 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_65 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_66 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_67 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_68 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_69 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_70 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_71 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_72 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_73 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_74 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_75 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_76 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_77 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_78 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_79 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_80 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_81 = arith.constant dense_resource<__elided__> : tensor<2560x320xf16>
%cst_82 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_83 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_84 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_85 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_86 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_87 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_88 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_89 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_90 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_91 = arith.constant dense_resource<__elided__> : tensor<640x320x3x3xf16>
%cst_92 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_93 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_94 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_95 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_96 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_97 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_98 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_99 = arith.constant dense_resource<__elided__> : tensor<640x320x1x1xf16>
%cst_100 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_101 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_102 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_103 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_104 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_105 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_106 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_107 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_108 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_109 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_110 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_111 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_112 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_113 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_114 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_115 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_116 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_117 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_118 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_119 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_120 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_121 = arith.constant dense_resource<__elided__> : tensor<5120x640xf16>
%cst_122 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_123 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_124 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_125 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_126 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_127 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_128 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_129 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_130 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_131 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_132 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_133 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_134 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_135 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_136 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_137 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_138 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_139 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_140 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_141 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_142 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_143 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_144 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_145 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_146 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_147 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_148 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_149 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_150 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_151 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_152 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_153 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_154 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_155 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_156 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_157 = arith.constant dense_resource<__elided__> : tensor<5120x640xf16>
%cst_158 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_159 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_160 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_161 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_162 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_163 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_164 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_165 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_166 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_167 = arith.constant dense_resource<__elided__> : tensor<1280x640x3x3xf16>
%cst_168 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_169 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_170 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_171 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_172 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_173 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_174 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_175 = arith.constant dense_resource<__elided__> : tensor<1280x640x1x1xf16>
%cst_176 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_177 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_178 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_179 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_180 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_181 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_182 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_183 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_184 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_185 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_186 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_187 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_188 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_189 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_190 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_191 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_192 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_193 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_194 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_195 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_196 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_197 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_198 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_199 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_200 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_201 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_202 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_203 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_204 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_205 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_206 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_207 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_208 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_209 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_210 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_211 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_212 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_213 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_214 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_215 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_216 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_217 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_218 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_219 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_220 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_221 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_222 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_223 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_224 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_225 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_226 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_227 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_228 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_229 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_230 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_231 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_232 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_233 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_234 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_235 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_236 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_237 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_238 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_239 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_240 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_241 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_242 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_243 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_244 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_245 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_246 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_247 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_248 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_249 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_250 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_251 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_252 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_253 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_254 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_255 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_256 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_257 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_258 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_259 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_260 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_261 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_262 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_263 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_264 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_265 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_266 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_267 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_268 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_269 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_270 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_271 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_272 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_273 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_274 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_275 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_276 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_277 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_278 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_279 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_280 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_281 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_282 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_283 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_284 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_285 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_286 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_287 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_288 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_289 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_290 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_291 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_292 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_293 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_294 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_295 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_296 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_297 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_298 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_299 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_300 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_301 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_302 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_303 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_304 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_305 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_306 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_307 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_308 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_309 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_310 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_311 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_312 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_313 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_314 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_315 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_316 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_317 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_318 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_319 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_320 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_321 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_322 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_323 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_324 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_325 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_326 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_327 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_328 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_329 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_330 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_331 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_332 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_333 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_334 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_335 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_336 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_337 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_338 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_339 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_340 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_341 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_342 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_343 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_344 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_345 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_346 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_347 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_348 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_349 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_350 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_351 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_352 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_353 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_354 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_355 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_356 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_357 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_358 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_359 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_360 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_361 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_362 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_363 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_364 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_365 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_366 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_367 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_368 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_369 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_370 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_371 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_372 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_373 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_374 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_375 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_376 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_377 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_378 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_379 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_380 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_381 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_382 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_383 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_384 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_385 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_386 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_387 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_388 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_389 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_390 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_391 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_392 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_393 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_394 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_395 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_396 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_397 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_398 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_399 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_400 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_401 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_402 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_403 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_404 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_405 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_406 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_407 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_408 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_409 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_410 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_411 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_412 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_413 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_414 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_415 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_416 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_417 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_418 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_419 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_420 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_421 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_422 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_423 = arith.constant dense_resource<__elided__> : tensor<1280x1920x3x3xf16>
%cst_424 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_425 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_426 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_427 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_428 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_429 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_430 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_431 = arith.constant dense_resource<__elided__> : tensor<1280x1920x1x1xf16>
%cst_432 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_433 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_434 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_435 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_436 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_437 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_438 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_439 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_440 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_441 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_442 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_443 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_444 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_445 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_446 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_447 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_448 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_449 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_450 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_451 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_452 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_453 = arith.constant dense_resource<__elided__> : tensor<10240x1280xf16>
%cst_454 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_455 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_456 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_457 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_458 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_459 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_460 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_461 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_462 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_463 = arith.constant dense_resource<__elided__> : tensor<640x1920x3x3xf16>
%cst_464 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_465 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_466 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_467 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_468 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_469 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_470 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_471 = arith.constant dense_resource<__elided__> : tensor<640x1920x1x1xf16>
%cst_472 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_473 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_474 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_475 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_476 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_477 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_478 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_479 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_480 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_481 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_482 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_483 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_484 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_485 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_486 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_487 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_488 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_489 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_490 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_491 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_492 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_493 = arith.constant dense_resource<__elided__> : tensor<5120x640xf16>
%cst_494 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_495 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_496 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_497 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_498 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_499 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_500 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_501 = arith.constant dense_resource<__elided__> : tensor<640x1280x3x3xf16>
%cst_502 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_503 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_504 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_505 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_506 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_507 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_508 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_509 = arith.constant dense_resource<__elided__> : tensor<640x1280x1x1xf16>
%cst_510 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_511 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_512 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_513 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_514 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_515 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_516 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_517 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_518 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_519 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_520 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_521 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_522 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_523 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_524 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_525 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_526 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_527 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_528 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_529 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_530 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_531 = arith.constant dense_resource<__elided__> : tensor<5120x640xf16>
%cst_532 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_533 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_534 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_535 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_536 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_537 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_538 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_539 = arith.constant dense_resource<__elided__> : tensor<640x960x3x3xf16>
%cst_540 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_541 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_542 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_543 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_544 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_545 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_546 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_547 = arith.constant dense_resource<__elided__> : tensor<640x960x1x1xf16>
%cst_548 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_549 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_550 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_551 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_552 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_553 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_554 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_555 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_556 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_557 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_558 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_559 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_560 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_561 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_562 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_563 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_564 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_565 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_566 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_567 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_568 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_569 = arith.constant dense_resource<__elided__> : tensor<5120x640xf16>
%cst_570 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_571 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_572 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_573 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_574 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_575 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_576 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_577 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_578 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_579 = arith.constant dense_resource<__elided__> : tensor<320x960x3x3xf16>
%cst_580 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_581 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_582 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_583 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_584 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_585 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_586 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_587 = arith.constant dense_resource<__elided__> : tensor<320x960x1x1xf16>
%cst_588 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_589 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_590 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_591 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_592 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_593 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_594 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_595 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_596 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_597 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_598 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_599 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_600 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_601 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_602 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_603 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_604 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_605 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_606 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_607 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_608 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_609 = arith.constant dense_resource<__elided__> : tensor<2560x320xf16>
%cst_610 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_611 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_612 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_613 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_614 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_615 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_616 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_617 = arith.constant dense_resource<__elided__> : tensor<320x640x3x3xf16>
%cst_618 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_619 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_620 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_621 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_622 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_623 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_624 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_625 = arith.constant dense_resource<__elided__> : tensor<320x640x1x1xf16>
%cst_626 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_627 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_628 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_629 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_630 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_631 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_632 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_633 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_634 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_635 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_636 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_637 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_638 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_639 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_640 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_641 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_642 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_643 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_644 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_645 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_646 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_647 = arith.constant dense_resource<__elided__> : tensor<2560x320xf16>
%cst_648 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_649 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_650 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_651 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_652 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_653 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_654 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_655 = arith.constant dense_resource<__elided__> : tensor<320x640x3x3xf16>
%cst_656 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_657 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_658 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_659 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_660 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_661 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_662 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_663 = arith.constant dense_resource<__elided__> : tensor<320x640x1x1xf16>
%cst_664 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_665 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_666 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_667 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_668 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_669 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_670 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_671 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_672 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_673 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_674 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_675 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_676 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_677 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_678 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_679 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_680 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_681 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_682 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_683 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_684 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_685 = arith.constant dense_resource<__elided__> : tensor<2560x320xf16>
%cst_686 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_687 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_688 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_689 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_690 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_691 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_692 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_693 = arith.constant dense_resource<__elided__> : tensor<4x320x3x3xf16>
%cst_694 = arith.constant dense<[-1.393320e-03, -1.588820e-03, -2.624990e-04, -2.531050e-03]> : tensor<4xf16>
%cst_695 = arith.constant 0.000000e+00 : f16
%cst_696 = arith.constant 1.000000e+00 : f16
%cst_697 = arith.constant -6.550400e+04 : f16
%cst_698 = arith.constant 2.000000e+00 : f16
%cst_699 = arith.constant 5.000000e-01 : f16
%cst_700 = arith.constant 0.000000e+00 : f64
%cst_701 = arith.constant 1.000000e-05 : f64
%cst_702 = arith.constant 2.000000e+00 : f32
%cst_703 = arith.constant 5.000000e-01 : f32
%cst_704 = arith.constant 0.000000e+00 : f32
%cst_705 = arith.constant 4.096000e+04 : f64
%cst_706 = arith.constant 4.096000e+04 : f32
%cst_707 = arith.constant 3.200000e+02 : f16
%cst_708 = arith.constant 1.024000e+04 : f64
%cst_709 = arith.constant 1.024000e+04 : f32
%cst_710 = arith.constant 2.048000e+04 : f64
%cst_711 = arith.constant 2.048000e+04 : f32
%cst_712 = arith.constant 6.400000e+02 : f16
%cst_713 = arith.constant 5.120000e+03 : f64
%cst_714 = arith.constant 5.120000e+03 : f32
%cst_715 = arith.constant 1.280000e+03 : f16
%cst_716 = arith.constant 2.560000e+03 : f64
%cst_717 = arith.constant 2.560000e+03 : f32
%cst_718 = arith.constant 1.536000e+04 : f64
%cst_719 = arith.constant 1.536000e+04 : f32
%cst_720 = arith.constant 6.144000e+04 : f64
%cst_721 = arith.constant 6.144000e+04 : f32
%cst_722 = arith.constant 3.072000e+04 : f64
%cst_723 = arith.constant 3.072000e+04 : f32
%cst_724 = arith.constant 1.228800e+05 : f64
%cst_725 = arith.constant 1.228800e+05 : f32
%cst_726 = arith.constant 8.192000e+04 : f64
%cst_727 = arith.constant 8.192000e+04 : f32
%c2 = arith.constant 2 : index
%0 = tensor.empty() : tensor<2x4x64x64xf16>
%inserted_slice = tensor.insert_slice %arg0 into %0[0, 0, 0, 0] [1, 4, 64, 64] [1, 1, 1, 1] : tensor<1x4x64x64xf16> into tensor<2x4x64x64xf16>
%inserted_slice_728 = tensor.insert_slice %arg0 into %inserted_slice[1, 0, 0, 0] [1, 4, 64, 64] [1, 1, 1, 1] : tensor<1x4x64x64xf16> into tensor<2x4x64x64xf16>
%1 = tensor.empty() : tensor<f32>
%2 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%arg3 : tensor<f32>) outs(%1 : tensor<f32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.powf %in, %cst_702 : f32
linalg.yield %4252 : f32
} -> tensor<f32>
%3 = linalg.generic {indexing_maps = [#map0, #map0, #map0], iterator_types = []} ins(%2, %cst_8 : tensor<f32>, tensor<i64>) outs(%1 : tensor<f32>) {
^bb0(%in: f32, %in_1647: i64, %out: f32):
%4252 = arith.sitofp %in_1647 : i64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<f32>
%4 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%3 : tensor<f32>) outs(%1 : tensor<f32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.powf %in, %cst_703 : f32
linalg.yield %4252 : f32
} -> tensor<f32>
%5 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%inserted_slice_728, %4 : tensor<2x4x64x64xf16>, tensor<f32>) outs(%0 : tensor<2x4x64x64xf16>) {
^bb0(%in: f16, %in_1647: f32, %out: f16):
%4252 = arith.truncf %in_1647 : f32 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4x64x64xf16>
%6 = tensor.empty() : tensor<2xf16>
%7 = linalg.generic {indexing_maps = [#map3, #map4], iterator_types = ["parallel"]} ins(%arg1 : tensor<1xf16>) outs(%6 : tensor<2xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2xf16>
%8 = tensor.empty() : tensor<160xf32>
%9 = linalg.generic {indexing_maps = [#map4], iterator_types = ["parallel"]} outs(%8 : tensor<160xf32>) {
^bb0(%out: f32):
%4252 = linalg.index 0 : index
%4253 = arith.index_cast %4252 : index to i64
%4254 = arith.sitofp %4253 : i64 to f32
%4255 = arith.addf %4254, %cst_704 : f32
linalg.yield %4255 : f32
} -> tensor<160xf32>
%10 = linalg.generic {indexing_maps = [#map4, #map5, #map4], iterator_types = ["parallel"]} ins(%9, %cst_7 : tensor<160xf32>, tensor<f64>) outs(%8 : tensor<160xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<160xf32>
%11 = linalg.generic {indexing_maps = [#map4, #map5, #map4], iterator_types = ["parallel"]} ins(%10, %cst_6 : tensor<160xf32>, tensor<i64>) outs(%8 : tensor<160xf32>) {
^bb0(%in: f32, %in_1647: i64, %out: f32):
%4252 = arith.sitofp %in_1647 : i64 to f32
%4253 = arith.divf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<160xf32>
%12 = linalg.generic {indexing_maps = [#map4, #map4], iterator_types = ["parallel"]} ins(%11 : tensor<160xf32>) outs(%8 : tensor<160xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.exp %in : f32
linalg.yield %4252 : f32
} -> tensor<160xf32>
%expanded = tensor.expand_shape %7 [[0, 1]] : tensor<2xf16> into tensor<2x1xf16>
%13 = tensor.empty() : tensor<f64>
%14 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%15 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%14 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%16 = tensor.empty() : tensor<2x1xf32>
%17 = linalg.generic {indexing_maps = [#map6, #map7], iterator_types = ["parallel", "parallel"]} ins(%15 : tensor<f32>) outs(%16 : tensor<2x1xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x1xf32>
%18 = tensor.empty() : tensor<2x1xf16>
%19 = linalg.generic {indexing_maps = [#map8, #map7], iterator_types = ["parallel", "parallel"]} ins(%expanded : tensor<2x1xf16>) outs(%18 : tensor<2x1xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1xf16>
%20 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%19 : tensor<2x1xf16>) outs(%17 : tensor<2x1xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x1xf32>
%expanded_729 = tensor.expand_shape %12 [[0, 1]] : tensor<160xf32> into tensor<1x160xf32>
%21 = tensor.empty() : tensor<2x160xf32>
%22 = linalg.generic {indexing_maps = [#map8, #map9, #map7], iterator_types = ["parallel", "parallel"]} ins(%20, %expanded_729 : tensor<2x1xf32>, tensor<1x160xf32>) outs(%21 : tensor<2x160xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x160xf32>
%23 = linalg.generic {indexing_maps = [#map7, #map6, #map7], iterator_types = ["parallel", "parallel"]} ins(%22, %cst_8 : tensor<2x160xf32>, tensor<i64>) outs(%21 : tensor<2x160xf32>) {
^bb0(%in: f32, %in_1647: i64, %out: f32):
%4252 = arith.sitofp %in_1647 : i64 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x160xf32>
%24 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%23 : tensor<2x160xf32>) outs(%21 : tensor<2x160xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.sin %in : f32
linalg.yield %4252 : f32
} -> tensor<2x160xf32>
%25 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%23 : tensor<2x160xf32>) outs(%21 : tensor<2x160xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.cos %in : f32
linalg.yield %4252 : f32
} -> tensor<2x160xf32>
%26 = tensor.empty() : tensor<2x320xf32>
%inserted_slice_730 = tensor.insert_slice %24 into %26[0, 0] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%inserted_slice_731 = tensor.insert_slice %25 into %inserted_slice_730[0, 160] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%extracted_slice = tensor.extract_slice %inserted_slice_731[0, 0] [2, 160] [1, 1] : tensor<2x320xf32> to tensor<2x160xf32>
%inserted_slice_732 = tensor.insert_slice %25 into %26[0, 0] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%inserted_slice_733 = tensor.insert_slice %extracted_slice into %inserted_slice_732[0, 160] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%27 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%28 = tensor.empty() : tensor<f16>
%29 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%27 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%30 = tensor.empty() : tensor<2x320xf16>
%31 = linalg.generic {indexing_maps = [#map6, #map7], iterator_types = ["parallel", "parallel"]} ins(%29 : tensor<f16>) outs(%30 : tensor<2x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320xf16>
%32 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%inserted_slice_733 : tensor<2x320xf32>) outs(%31 : tensor<2x320xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320xf16>
%33 = tensor.empty() : tensor<320x1280xf16>
%34 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_9 : tensor<1280x320xf16>) outs(%33 : tensor<320x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x1280xf16>
%35 = tensor.empty() : tensor<2x1280xf16>
%36 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%37 = linalg.matmul ins(%32, %34 : tensor<2x320xf16>, tensor<320x1280xf16>) outs(%36 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%38 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_10, %37 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%39 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%38 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%40 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%39, %38 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%41 = tensor.empty() : tensor<1280x1280xf16>
%42 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_11 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%43 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%44 = linalg.matmul ins(%40, %42 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%43 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%45 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_12, %44 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%padded = tensor.pad %5 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x4x64x64xf16> to tensor<2x4x66x66xf16>
%46 = tensor.empty() : tensor<2x320x64x64xf16>
%47 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_14 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%48 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded, %cst_13 : tensor<2x4x66x66xf16>, tensor<320x4x3x3xf16>) outs(%47 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%collapsed = tensor.collapse_shape %48 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_734 = tensor.expand_shape %collapsed [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%49 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%50 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%49 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%51 = tensor.empty() : tensor<2x32x10x4096xf32>
%52 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%50 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%53 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_734 : tensor<2x32x10x4096xf16>) outs(%52 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%54 = tensor.empty() : tensor<2x32x10x4096xf64>
%55 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%53 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%56 = tensor.empty() : tensor<2x32x1x1xf64>
%57 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%58 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%55 : tensor<2x32x10x4096xf64>) outs(%57 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%59 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%58 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%60 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%55, %59 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%61 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%60 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%62 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%63 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%61 : tensor<2x32x10x4096xf64>) outs(%62 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%64 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%63 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%65 = tensor.empty() : tensor<2x32x1x1xf32>
%66 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%64 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%67 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%68 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%53 : tensor<2x32x10x4096xf32>) outs(%67 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%69 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%68 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%70 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%66, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%71 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%70 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%72 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_734, %69 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%73 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%72, %71 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_735 = tensor.collapse_shape %73 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_736 = tensor.expand_shape %collapsed_735 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_737 = tensor.expand_shape %cst_15 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%74 = tensor.empty() : tensor<2x320x64x64xf32>
%75 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_736, %expanded_737 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_738 = tensor.expand_shape %cst_16 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%76 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%75, %expanded_738 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%77 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%78 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%77 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%79 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%78 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%80 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%76 : tensor<2x320x64x64xf32>) outs(%79 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%81 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%80 : tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x320x64x64xf16>
%82 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%81, %80 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%padded_739 = tensor.pad %82 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%83 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_18 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%84 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_739, %cst_17 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%83 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%85 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%86 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%85, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%87 = tensor.empty() : tensor<1280x320xf16>
%88 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_19 : tensor<320x1280xf16>) outs(%87 : tensor<1280x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x320xf16>
%89 = linalg.fill ins(%cst_695 : f16) outs(%30 : tensor<2x320xf16>) -> tensor<2x320xf16>
%90 = linalg.matmul ins(%86, %88 : tensor<2x1280xf16>, tensor<1280x320xf16>) outs(%89 : tensor<2x320xf16>) -> tensor<2x320xf16>
%91 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_20, %90 : tensor<320xf16>, tensor<2x320xf16>) outs(%30 : tensor<2x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320xf16>
%expanded_740 = tensor.expand_shape %91 [[0], [1, 2, 3]] : tensor<2x320xf16> into tensor<2x320x1x1xf16>
%92 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%84, %expanded_740 : tensor<2x320x64x64xf16>, tensor<2x320x1x1xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%collapsed_741 = tensor.collapse_shape %92 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_742 = tensor.expand_shape %collapsed_741 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%93 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%94 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%93 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%95 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%94 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%96 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_742 : tensor<2x32x10x4096xf16>) outs(%95 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%97 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%96 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%98 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%99 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%97 : tensor<2x32x10x4096xf64>) outs(%98 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%100 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%99 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%101 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%97, %100 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%102 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%101 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%103 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%104 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%102 : tensor<2x32x10x4096xf64>) outs(%103 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%105 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%104 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%106 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%105 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%107 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%108 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%96 : tensor<2x32x10x4096xf32>) outs(%107 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%109 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%108 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%110 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%106, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%111 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%110 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%112 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_742, %109 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%113 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%112, %111 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_743 = tensor.collapse_shape %113 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_744 = tensor.expand_shape %collapsed_743 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_745 = tensor.expand_shape %cst_21 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%114 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_744, %expanded_745 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_746 = tensor.expand_shape %cst_22 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%115 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%114, %expanded_746 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%116 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%117 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%116 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%118 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%117 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%119 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%115 : tensor<2x320x64x64xf32>) outs(%118 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%120 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%119 : tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x320x64x64xf16>
%121 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%120, %119 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%padded_747 = tensor.pad %121 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%122 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_24 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%123 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_747, %cst_23 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%122 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%124 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%48, %123 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%125 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%124, %cst_4 : tensor<2x320x64x64xf16>, tensor<f64>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x320x64x64xf16>
%collapsed_748 = tensor.collapse_shape %125 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_749 = tensor.expand_shape %collapsed_748 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%126 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%127 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%126 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%128 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%127 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%129 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_749 : tensor<2x32x10x4096xf16>) outs(%128 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%130 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%129 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%131 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%132 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%130 : tensor<2x32x10x4096xf64>) outs(%131 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%133 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%132 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%134 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%130, %133 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%135 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%134 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%136 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%137 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%135 : tensor<2x32x10x4096xf64>) outs(%136 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%138 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%137 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%139 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%138 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%140 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%141 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%129 : tensor<2x32x10x4096xf32>) outs(%140 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%142 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%141 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%143 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%139, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%144 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%143 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%145 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_749, %142 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%146 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%145, %144 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_750 = tensor.collapse_shape %146 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_751 = tensor.expand_shape %collapsed_750 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_752 = tensor.expand_shape %cst_25 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%147 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_751, %expanded_752 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_753 = tensor.expand_shape %cst_26 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%148 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%147, %expanded_753 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%149 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%150 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%149 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%151 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%150 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%152 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%148 : tensor<2x320x64x64xf32>) outs(%151 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%153 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_28 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%154 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%152, %cst_27 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%153 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%155 = tensor.empty() : tensor<2x64x64x320xf16>
%156 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%154 : tensor<2x320x64x64xf16>) outs(%155 : tensor<2x64x64x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x64x320xf16>
%collapsed_754 = tensor.collapse_shape %156 [[0], [1, 2], [3]] : tensor<2x64x64x320xf16> into tensor<2x4096x320xf16>
%157 = tensor.empty() : tensor<2x4096x1xf16>
%158 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%159 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_754 : tensor<2x4096x320xf16>) outs(%158 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%160 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%159 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%161 = tensor.empty() : tensor<2x4096x320xf16>
%162 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%160 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%163 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_754, %162 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%164 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%163 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%165 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%166 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%164 : tensor<2x4096x320xf16>) outs(%165 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%167 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%166 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%168 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%167 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%169 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%168 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%170 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%169 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%171 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%163, %170 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%172 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%171, %cst_29 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%173 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%172, %cst_30 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%174 = tensor.empty() : tensor<320x320xf16>
%175 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_31 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_755 = tensor.collapse_shape %173 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%176 = tensor.empty() : tensor<8192x320xf16>
%177 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%178 = linalg.matmul ins(%collapsed_755, %175 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%177 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%179 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_32 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%180 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%181 = linalg.matmul ins(%collapsed_755, %179 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%180 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%182 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_33 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%183 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%184 = linalg.matmul ins(%collapsed_755, %182 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%183 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%expanded_756 = tensor.expand_shape %178 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%185 = tensor.empty() : tensor<2x8x4096x40xf16>
%186 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_756 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_757 = tensor.collapse_shape %186 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_758 = tensor.expand_shape %181 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%187 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_758 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_759 = tensor.collapse_shape %187 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_760 = tensor.expand_shape %184 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%188 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_760 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_761 = tensor.collapse_shape %188 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%189 = tensor.empty() : tensor<16x40x4096xf16>
%190 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_759 : tensor<16x4096x40xf16>) outs(%189 : tensor<16x40x4096xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x40x4096xf16>
%191 = tensor.empty() : tensor<16x4096x4096xf16>
%192 = linalg.fill ins(%cst_695 : f16) outs(%191 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%193 = linalg.batch_matmul ins(%collapsed_757, %190 : tensor<16x4096x40xf16>, tensor<16x40x4096xf16>) outs(%192 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%194 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193, %cst_2 : tensor<16x4096x4096xf16>, tensor<f64>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x4096x4096xf16>
%195 = tensor.empty() : tensor<16x4096x1xf16>
%196 = linalg.fill ins(%cst_697 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%197 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%194 : tensor<16x4096x4096xf16>) outs(%196 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%198 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%194, %197 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%199 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%198 : tensor<16x4096x4096xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%200 = linalg.fill ins(%cst_695 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%201 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%199 : tensor<16x4096x4096xf16>) outs(%200 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%202 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%199, %201 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%203 = tensor.empty() : tensor<16x4096x40xf16>
%204 = linalg.fill ins(%cst_695 : f16) outs(%203 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%205 = linalg.batch_matmul ins(%202, %collapsed_761 : tensor<16x4096x4096xf16>, tensor<16x4096x40xf16>) outs(%204 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%expanded_762 = tensor.expand_shape %205 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%206 = tensor.empty() : tensor<2x4096x8x40xf16>
%207 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_762 : tensor<2x8x4096x40xf16>) outs(%206 : tensor<2x4096x8x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x8x40xf16>
%208 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_34 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_763 = tensor.collapse_shape %207 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%209 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%210 = linalg.matmul ins(%collapsed_763, %208 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%209 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%211 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_35, %210 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_764 = tensor.expand_shape %211 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%212 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_764, %collapsed_754 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%213 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%214 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%212 : tensor<2x4096x320xf16>) outs(%213 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%215 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%214 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%216 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%215 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%217 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%212, %216 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%218 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%217 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%219 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%220 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%218 : tensor<2x4096x320xf16>) outs(%219 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%221 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%220 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%222 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%221 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%223 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%222 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%224 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%223 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%225 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%217, %224 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%226 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%225, %cst_36 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%227 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%226, %cst_37 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%228 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_38 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_765 = tensor.collapse_shape %227 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%229 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%230 = linalg.matmul ins(%collapsed_765, %228 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%229 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%231 = tensor.empty() : tensor<768x320xf16>
%232 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_39 : tensor<320x768xf16>) outs(%231 : tensor<768x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x320xf16>
%collapsed_766 = tensor.collapse_shape %arg2 [[0, 1], [2]] : tensor<2x77x768xf16> into tensor<154x768xf16>
%233 = tensor.empty() : tensor<154x320xf16>
%234 = linalg.fill ins(%cst_695 : f16) outs(%233 : tensor<154x320xf16>) -> tensor<154x320xf16>
%235 = linalg.matmul ins(%collapsed_766, %232 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%234 : tensor<154x320xf16>) -> tensor<154x320xf16>
%236 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_40 : tensor<320x768xf16>) outs(%231 : tensor<768x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x320xf16>
%237 = linalg.fill ins(%cst_695 : f16) outs(%233 : tensor<154x320xf16>) -> tensor<154x320xf16>
%238 = linalg.matmul ins(%collapsed_766, %236 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%237 : tensor<154x320xf16>) -> tensor<154x320xf16>
%expanded_767 = tensor.expand_shape %230 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%239 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_767 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_768 = tensor.collapse_shape %239 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_769 = tensor.expand_shape %235 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%240 = tensor.empty() : tensor<2x8x77x40xf16>
%241 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_769 : tensor<2x77x8x40xf16>) outs(%240 : tensor<2x8x77x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x40xf16>
%collapsed_770 = tensor.collapse_shape %241 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%expanded_771 = tensor.expand_shape %238 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%242 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_771 : tensor<2x77x8x40xf16>) outs(%240 : tensor<2x8x77x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x40xf16>
%collapsed_772 = tensor.collapse_shape %242 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%243 = tensor.empty() : tensor<16x40x77xf16>
%244 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_770 : tensor<16x77x40xf16>) outs(%243 : tensor<16x40x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x40x77xf16>
%245 = tensor.empty() : tensor<16x4096x77xf16>
%246 = linalg.fill ins(%cst_695 : f16) outs(%245 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%247 = linalg.batch_matmul ins(%collapsed_768, %244 : tensor<16x4096x40xf16>, tensor<16x40x77xf16>) outs(%246 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%248 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%247, %cst_2 : tensor<16x4096x77xf16>, tensor<f64>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x4096x77xf16>
%249 = linalg.fill ins(%cst_697 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%250 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%248 : tensor<16x4096x77xf16>) outs(%249 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%251 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%248, %250 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%252 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%251 : tensor<16x4096x77xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%253 = linalg.fill ins(%cst_695 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%254 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%252 : tensor<16x4096x77xf16>) outs(%253 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%255 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%252, %254 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%256 = linalg.fill ins(%cst_695 : f16) outs(%203 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%257 = linalg.batch_matmul ins(%255, %collapsed_772 : tensor<16x4096x77xf16>, tensor<16x77x40xf16>) outs(%256 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%expanded_773 = tensor.expand_shape %257 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%258 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_773 : tensor<2x8x4096x40xf16>) outs(%206 : tensor<2x4096x8x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x8x40xf16>
%259 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_41 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_774 = tensor.collapse_shape %258 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%260 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%261 = linalg.matmul ins(%collapsed_774, %259 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%260 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%262 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_42, %261 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_775 = tensor.expand_shape %262 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%263 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_775, %212 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%264 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%265 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%263 : tensor<2x4096x320xf16>) outs(%264 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%266 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%265 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%267 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%266 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%268 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%263, %267 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%269 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%268 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%270 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%271 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%269 : tensor<2x4096x320xf16>) outs(%270 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%272 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%271 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%273 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%272 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%274 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%273 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%275 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%274 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%276 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%268, %275 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%277 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%276, %cst_43 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%278 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%277, %cst_44 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%279 = tensor.empty() : tensor<320x2560xf16>
%280 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_45 : tensor<2560x320xf16>) outs(%279 : tensor<320x2560xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x2560xf16>
%collapsed_776 = tensor.collapse_shape %278 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%281 = tensor.empty() : tensor<8192x2560xf16>
%282 = linalg.fill ins(%cst_695 : f16) outs(%281 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%283 = linalg.matmul ins(%collapsed_776, %280 : tensor<8192x320xf16>, tensor<320x2560xf16>) outs(%282 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%284 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_46, %283 : tensor<2560xf16>, tensor<8192x2560xf16>) outs(%281 : tensor<8192x2560xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x2560xf16>
%expanded_777 = tensor.expand_shape %284 [[0, 1], [2]] : tensor<8192x2560xf16> into tensor<2x4096x2560xf16>
%extracted_slice_778 = tensor.extract_slice %expanded_777[0, 0, 0] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%extracted_slice_779 = tensor.extract_slice %expanded_777[0, 0, 1280] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%285 = tensor.empty() : tensor<2x4096x1280xf16>
%286 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_779 : tensor<2x4096x1280xf16>) outs(%285 : tensor<2x4096x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x4096x1280xf16>
%287 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_778, %286 : tensor<2x4096x1280xf16>, tensor<2x4096x1280xf16>) outs(%285 : tensor<2x4096x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1280xf16>
%288 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_47 : tensor<320x1280xf16>) outs(%87 : tensor<1280x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x320xf16>
%collapsed_780 = tensor.collapse_shape %287 [[0, 1], [2]] : tensor<2x4096x1280xf16> into tensor<8192x1280xf16>
%289 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%290 = linalg.matmul ins(%collapsed_780, %288 : tensor<8192x1280xf16>, tensor<1280x320xf16>) outs(%289 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%291 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_48, %290 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_781 = tensor.expand_shape %291 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%292 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_781, %263 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%expanded_782 = tensor.expand_shape %292 [[0], [1, 2], [3]] : tensor<2x4096x320xf16> into tensor<2x64x64x320xf16>
%293 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_782 : tensor<2x64x64x320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%294 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_50 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%295 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%293, %cst_49 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%294 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%296 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%295, %125 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%collapsed_783 = tensor.collapse_shape %296 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_784 = tensor.expand_shape %collapsed_783 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%297 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%298 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%297 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%299 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%298 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%300 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_784 : tensor<2x32x10x4096xf16>) outs(%299 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%301 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%300 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%302 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%303 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%301 : tensor<2x32x10x4096xf64>) outs(%302 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%304 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%303 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%305 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%301, %304 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%306 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%305 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%307 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%308 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%306 : tensor<2x32x10x4096xf64>) outs(%307 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%309 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%308 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%310 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%309 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%311 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%312 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%300 : tensor<2x32x10x4096xf32>) outs(%311 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%313 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%312 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%314 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%310, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%315 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%314 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%316 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_784, %313 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%317 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%316, %315 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_785 = tensor.collapse_shape %317 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_786 = tensor.expand_shape %collapsed_785 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_787 = tensor.expand_shape %cst_51 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%318 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_786, %expanded_787 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_788 = tensor.expand_shape %cst_52 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%319 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%318, %expanded_788 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%320 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%321 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%320 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%322 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%321 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%323 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%319 : tensor<2x320x64x64xf32>) outs(%322 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%324 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%323 : tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x320x64x64xf16>
%325 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%324, %323 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%padded_789 = tensor.pad %325 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%326 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_54 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%327 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_789, %cst_53 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%326 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%328 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%329 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%328, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%330 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_55 : tensor<320x1280xf16>) outs(%87 : tensor<1280x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x320xf16>
%331 = linalg.fill ins(%cst_695 : f16) outs(%30 : tensor<2x320xf16>) -> tensor<2x320xf16>
%332 = linalg.matmul ins(%329, %330 : tensor<2x1280xf16>, tensor<1280x320xf16>) outs(%331 : tensor<2x320xf16>) -> tensor<2x320xf16>
%333 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_56, %332 : tensor<320xf16>, tensor<2x320xf16>) outs(%30 : tensor<2x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320xf16>
%expanded_790 = tensor.expand_shape %333 [[0], [1, 2, 3]] : tensor<2x320xf16> into tensor<2x320x1x1xf16>
%334 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%327, %expanded_790 : tensor<2x320x64x64xf16>, tensor<2x320x1x1xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%collapsed_791 = tensor.collapse_shape %334 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_792 = tensor.expand_shape %collapsed_791 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%335 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%336 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%335 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%337 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%336 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%338 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_792 : tensor<2x32x10x4096xf16>) outs(%337 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%339 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%338 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%340 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%341 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%339 : tensor<2x32x10x4096xf64>) outs(%340 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%342 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%341 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%343 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%339, %342 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%344 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%343 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%345 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%346 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%344 : tensor<2x32x10x4096xf64>) outs(%345 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%347 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%346 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%348 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%347 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%349 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%350 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%338 : tensor<2x32x10x4096xf32>) outs(%349 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%351 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%350 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%352 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%348, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%353 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%352 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%354 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_792, %351 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%355 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%354, %353 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_793 = tensor.collapse_shape %355 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_794 = tensor.expand_shape %collapsed_793 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_795 = tensor.expand_shape %cst_57 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%356 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_794, %expanded_795 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_796 = tensor.expand_shape %cst_58 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%357 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%356, %expanded_796 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%358 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%359 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%358 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%360 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%359 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%361 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%357 : tensor<2x320x64x64xf32>) outs(%360 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%362 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%361 : tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x320x64x64xf16>
%363 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%362, %361 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%padded_797 = tensor.pad %363 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%364 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_60 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%365 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_797, %cst_59 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%364 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%366 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%296, %365 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%367 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%366, %cst_4 : tensor<2x320x64x64xf16>, tensor<f64>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x320x64x64xf16>
%collapsed_798 = tensor.collapse_shape %367 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%expanded_799 = tensor.expand_shape %collapsed_798 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%368 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%369 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%368 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%370 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%369 : tensor<f32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x4096xf32>
%371 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_799 : tensor<2x32x10x4096xf16>) outs(%370 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%372 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%371 : tensor<2x32x10x4096xf32>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%373 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%374 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%372 : tensor<2x32x10x4096xf64>) outs(%373 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%375 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%374 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%376 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%372, %375 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%377 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%376 : tensor<2x32x10x4096xf64>) outs(%54 : tensor<2x32x10x4096xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x4096xf64>
%378 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%379 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%377 : tensor<2x32x10x4096xf64>) outs(%378 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%380 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%379 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_705 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%381 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%380 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%382 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%383 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%371 : tensor<2x32x10x4096xf32>) outs(%382 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%384 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%383 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_706 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%385 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%381, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%386 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%385 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%387 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_799, %384 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x4096xf32>
%388 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%387, %386 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%51 : tensor<2x32x10x4096xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x4096xf32>
%collapsed_800 = tensor.collapse_shape %388 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%expanded_801 = tensor.expand_shape %collapsed_800 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%expanded_802 = tensor.expand_shape %cst_61 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%389 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_801, %expanded_802 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%expanded_803 = tensor.expand_shape %cst_62 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%390 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%389, %expanded_803 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%74 : tensor<2x320x64x64xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x64x64xf32>
%391 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%392 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%391 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%393 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%392 : tensor<f16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%394 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%390 : tensor<2x320x64x64xf32>) outs(%393 : tensor<2x320x64x64xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%395 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_64 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%396 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%394, %cst_63 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%395 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%397 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%396 : tensor<2x320x64x64xf16>) outs(%155 : tensor<2x64x64x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x64x320xf16>
%collapsed_804 = tensor.collapse_shape %397 [[0], [1, 2], [3]] : tensor<2x64x64x320xf16> into tensor<2x4096x320xf16>
%398 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%399 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_804 : tensor<2x4096x320xf16>) outs(%398 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%400 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%399 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%401 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%400 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%402 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_804, %401 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%403 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%402 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%404 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%405 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%403 : tensor<2x4096x320xf16>) outs(%404 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%406 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%405 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%407 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%406 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%408 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%407 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%409 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%408 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%410 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%402, %409 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%411 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%410, %cst_65 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%412 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%411, %cst_66 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%413 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_67 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_805 = tensor.collapse_shape %412 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%414 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%415 = linalg.matmul ins(%collapsed_805, %413 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%414 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%416 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_68 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%417 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%418 = linalg.matmul ins(%collapsed_805, %416 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%417 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%419 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_69 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%420 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%421 = linalg.matmul ins(%collapsed_805, %419 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%420 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%expanded_806 = tensor.expand_shape %415 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%422 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_806 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_807 = tensor.collapse_shape %422 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_808 = tensor.expand_shape %418 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%423 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_808 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_809 = tensor.collapse_shape %423 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_810 = tensor.expand_shape %421 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%424 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_810 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_811 = tensor.collapse_shape %424 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%425 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_809 : tensor<16x4096x40xf16>) outs(%189 : tensor<16x40x4096xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x40x4096xf16>
%426 = linalg.fill ins(%cst_695 : f16) outs(%191 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%427 = linalg.batch_matmul ins(%collapsed_807, %425 : tensor<16x4096x40xf16>, tensor<16x40x4096xf16>) outs(%426 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%428 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%427, %cst_2 : tensor<16x4096x4096xf16>, tensor<f64>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x4096x4096xf16>
%429 = linalg.fill ins(%cst_697 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%430 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%428 : tensor<16x4096x4096xf16>) outs(%429 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%431 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%428, %430 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%432 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%431 : tensor<16x4096x4096xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%433 = linalg.fill ins(%cst_695 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%434 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%432 : tensor<16x4096x4096xf16>) outs(%433 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%435 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%432, %434 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%191 : tensor<16x4096x4096xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x4096xf16>
%436 = linalg.fill ins(%cst_695 : f16) outs(%203 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%437 = linalg.batch_matmul ins(%435, %collapsed_811 : tensor<16x4096x4096xf16>, tensor<16x4096x40xf16>) outs(%436 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%expanded_812 = tensor.expand_shape %437 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%438 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_812 : tensor<2x8x4096x40xf16>) outs(%206 : tensor<2x4096x8x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x8x40xf16>
%439 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_70 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_813 = tensor.collapse_shape %438 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%440 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%441 = linalg.matmul ins(%collapsed_813, %439 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%440 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%442 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_71, %441 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_814 = tensor.expand_shape %442 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%443 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_814, %collapsed_804 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%444 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%445 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%443 : tensor<2x4096x320xf16>) outs(%444 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%446 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%445 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%447 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%446 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%448 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%443, %447 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%449 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%448 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%450 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%451 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%449 : tensor<2x4096x320xf16>) outs(%450 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%452 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%451 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%453 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%452 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%454 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%453 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%455 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%454 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%456 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%448, %455 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%457 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%456, %cst_72 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%458 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%457, %cst_73 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%459 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_74 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_815 = tensor.collapse_shape %458 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%460 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%461 = linalg.matmul ins(%collapsed_815, %459 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%460 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%462 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_75 : tensor<320x768xf16>) outs(%231 : tensor<768x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x320xf16>
%463 = linalg.fill ins(%cst_695 : f16) outs(%233 : tensor<154x320xf16>) -> tensor<154x320xf16>
%464 = linalg.matmul ins(%collapsed_766, %462 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%463 : tensor<154x320xf16>) -> tensor<154x320xf16>
%465 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_76 : tensor<320x768xf16>) outs(%231 : tensor<768x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x320xf16>
%466 = linalg.fill ins(%cst_695 : f16) outs(%233 : tensor<154x320xf16>) -> tensor<154x320xf16>
%467 = linalg.matmul ins(%collapsed_766, %465 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%466 : tensor<154x320xf16>) -> tensor<154x320xf16>
%expanded_816 = tensor.expand_shape %461 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%468 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_816 : tensor<2x4096x8x40xf16>) outs(%185 : tensor<2x8x4096x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x4096x40xf16>
%collapsed_817 = tensor.collapse_shape %468 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%expanded_818 = tensor.expand_shape %464 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%469 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_818 : tensor<2x77x8x40xf16>) outs(%240 : tensor<2x8x77x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x40xf16>
%collapsed_819 = tensor.collapse_shape %469 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%expanded_820 = tensor.expand_shape %467 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%470 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_820 : tensor<2x77x8x40xf16>) outs(%240 : tensor<2x8x77x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x40xf16>
%collapsed_821 = tensor.collapse_shape %470 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%471 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_819 : tensor<16x77x40xf16>) outs(%243 : tensor<16x40x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x40x77xf16>
%472 = linalg.fill ins(%cst_695 : f16) outs(%245 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%473 = linalg.batch_matmul ins(%collapsed_817, %471 : tensor<16x4096x40xf16>, tensor<16x40x77xf16>) outs(%472 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%474 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%473, %cst_2 : tensor<16x4096x77xf16>, tensor<f64>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x4096x77xf16>
%475 = linalg.fill ins(%cst_697 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%476 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%474 : tensor<16x4096x77xf16>) outs(%475 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%477 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%474, %476 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%478 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477 : tensor<16x4096x77xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%479 = linalg.fill ins(%cst_695 : f16) outs(%195 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%480 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%478 : tensor<16x4096x77xf16>) outs(%479 : tensor<16x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x1xf16>
%481 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%478, %480 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%245 : tensor<16x4096x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x4096x77xf16>
%482 = linalg.fill ins(%cst_695 : f16) outs(%203 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%483 = linalg.batch_matmul ins(%481, %collapsed_821 : tensor<16x4096x77xf16>, tensor<16x77x40xf16>) outs(%482 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%expanded_822 = tensor.expand_shape %483 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%484 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_822 : tensor<2x8x4096x40xf16>) outs(%206 : tensor<2x4096x8x40xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x8x40xf16>
%485 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_77 : tensor<320x320xf16>) outs(%174 : tensor<320x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x320xf16>
%collapsed_823 = tensor.collapse_shape %484 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%486 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%487 = linalg.matmul ins(%collapsed_823, %485 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%486 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%488 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_78, %487 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_824 = tensor.expand_shape %488 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%489 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_824, %443 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%490 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%491 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%489 : tensor<2x4096x320xf16>) outs(%490 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%492 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%491 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%493 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%492 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%494 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%489, %493 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%495 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%494 : tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%496 = linalg.fill ins(%cst_695 : f16) outs(%157 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%497 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%495 : tensor<2x4096x320xf16>) outs(%496 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%498 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%497 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_707 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%499 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%498 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x4096x1xf16>
%500 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%499 : tensor<2x4096x1xf16>) outs(%157 : tensor<2x4096x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1xf16>
%501 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%500 : tensor<2x4096x1xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x4096x320xf16>
%502 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%494, %501 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%503 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%502, %cst_79 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%504 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%503, %cst_80 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%505 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_81 : tensor<2560x320xf16>) outs(%279 : tensor<320x2560xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<320x2560xf16>
%collapsed_825 = tensor.collapse_shape %504 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%506 = linalg.fill ins(%cst_695 : f16) outs(%281 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%507 = linalg.matmul ins(%collapsed_825, %505 : tensor<8192x320xf16>, tensor<320x2560xf16>) outs(%506 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%508 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_82, %507 : tensor<2560xf16>, tensor<8192x2560xf16>) outs(%281 : tensor<8192x2560xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x2560xf16>
%expanded_826 = tensor.expand_shape %508 [[0, 1], [2]] : tensor<8192x2560xf16> into tensor<2x4096x2560xf16>
%extracted_slice_827 = tensor.extract_slice %expanded_826[0, 0, 0] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%extracted_slice_828 = tensor.extract_slice %expanded_826[0, 0, 1280] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%509 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_828 : tensor<2x4096x1280xf16>) outs(%285 : tensor<2x4096x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x4096x1280xf16>
%510 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_827, %509 : tensor<2x4096x1280xf16>, tensor<2x4096x1280xf16>) outs(%285 : tensor<2x4096x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x1280xf16>
%511 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_83 : tensor<320x1280xf16>) outs(%87 : tensor<1280x320xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x320xf16>
%collapsed_829 = tensor.collapse_shape %510 [[0, 1], [2]] : tensor<2x4096x1280xf16> into tensor<8192x1280xf16>
%512 = linalg.fill ins(%cst_695 : f16) outs(%176 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%513 = linalg.matmul ins(%collapsed_829, %511 : tensor<8192x1280xf16>, tensor<1280x320xf16>) outs(%512 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%514 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_84, %513 : tensor<320xf16>, tensor<8192x320xf16>) outs(%176 : tensor<8192x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<8192x320xf16>
%expanded_830 = tensor.expand_shape %514 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%515 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_830, %489 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%161 : tensor<2x4096x320xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x4096x320xf16>
%expanded_831 = tensor.expand_shape %515 [[0], [1, 2], [3]] : tensor<2x4096x320xf16> into tensor<2x64x64x320xf16>
%516 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_831 : tensor<2x64x64x320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%517 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_86 : tensor<320xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x64x64xf16>
%518 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%516, %cst_85 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%517 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%519 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%518, %367 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%46 : tensor<2x320x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x64x64xf16>
%padded_832 = tensor.pad %519 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%520 = tensor.empty() : tensor<2x320x32x32xf16>
%521 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_88 : tensor<320xf16>) outs(%520 : tensor<2x320x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x32x32xf16>
%522 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%padded_832, %cst_87 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%521 : tensor<2x320x32x32xf16>) -> tensor<2x320x32x32xf16>
%collapsed_833 = tensor.collapse_shape %522 [[0], [1], [2, 3]] : tensor<2x320x32x32xf16> into tensor<2x320x1024xf16>
%expanded_834 = tensor.expand_shape %collapsed_833 [[0], [1, 2], [3]] : tensor<2x320x1024xf16> into tensor<2x32x10x1024xf16>
%523 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%524 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%523 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%525 = tensor.empty() : tensor<2x32x10x1024xf32>
%526 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%524 : tensor<f32>) outs(%525 : tensor<2x32x10x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x10x1024xf32>
%527 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_834 : tensor<2x32x10x1024xf16>) outs(%526 : tensor<2x32x10x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x1024xf32>
%528 = tensor.empty() : tensor<2x32x10x1024xf64>
%529 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%527 : tensor<2x32x10x1024xf32>) outs(%528 : tensor<2x32x10x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x1024xf64>
%530 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%531 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%529 : tensor<2x32x10x1024xf64>) outs(%530 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%532 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%531 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%533 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%529, %532 : tensor<2x32x10x1024xf64>, tensor<2x32x1x1xf64>) outs(%528 : tensor<2x32x10x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x1024xf64>
%534 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%533 : tensor<2x32x10x1024xf64>) outs(%528 : tensor<2x32x10x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x10x1024xf64>
%535 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%536 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%534 : tensor<2x32x10x1024xf64>) outs(%535 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%537 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%536 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%538 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%537 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%539 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%540 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%527 : tensor<2x32x10x1024xf32>) outs(%539 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%541 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%540 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%542 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%538, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%543 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%542 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%544 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_834, %541 : tensor<2x32x10x1024xf16>, tensor<2x32x1x1xf32>) outs(%525 : tensor<2x32x10x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x10x1024xf32>
%545 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%544, %543 : tensor<2x32x10x1024xf32>, tensor<2x32x1x1xf32>) outs(%525 : tensor<2x32x10x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x10x1024xf32>
%collapsed_835 = tensor.collapse_shape %545 [[0], [1, 2], [3]] : tensor<2x32x10x1024xf32> into tensor<2x320x1024xf32>
%expanded_836 = tensor.expand_shape %collapsed_835 [[0], [1], [2, 3]] : tensor<2x320x1024xf32> into tensor<2x320x32x32xf32>
%expanded_837 = tensor.expand_shape %cst_89 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%546 = tensor.empty() : tensor<2x320x32x32xf32>
%547 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_836, %expanded_837 : tensor<2x320x32x32xf32>, tensor<320x1x1xf16>) outs(%546 : tensor<2x320x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x32x32xf32>
%expanded_838 = tensor.expand_shape %cst_90 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%548 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%547, %expanded_838 : tensor<2x320x32x32xf32>, tensor<320x1x1xf16>) outs(%546 : tensor<2x320x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x320x32x32xf32>
%549 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%550 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%549 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%551 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%550 : tensor<f16>) outs(%520 : tensor<2x320x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x320x32x32xf16>
%552 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%548 : tensor<2x320x32x32xf32>) outs(%551 : tensor<2x320x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x320x32x32xf16>
%553 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%552 : tensor<2x320x32x32xf16>) outs(%520 : tensor<2x320x32x32xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x320x32x32xf16>
%554 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%553, %552 : tensor<2x320x32x32xf16>, tensor<2x320x32x32xf16>) outs(%520 : tensor<2x320x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x320x32x32xf16>
%padded_839 = tensor.pad %554 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x320x32x32xf16> to tensor<2x320x34x34xf16>
%555 = tensor.empty() : tensor<2x640x32x32xf16>
%556 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_92 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%557 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_839, %cst_91 : tensor<2x320x34x34xf16>, tensor<640x320x3x3xf16>) outs(%556 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%558 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%559 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%558, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%560 = tensor.empty() : tensor<1280x640xf16>
%561 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_93 : tensor<640x1280xf16>) outs(%560 : tensor<1280x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x640xf16>
%562 = tensor.empty() : tensor<2x640xf16>
%563 = linalg.fill ins(%cst_695 : f16) outs(%562 : tensor<2x640xf16>) -> tensor<2x640xf16>
%564 = linalg.matmul ins(%559, %561 : tensor<2x1280xf16>, tensor<1280x640xf16>) outs(%563 : tensor<2x640xf16>) -> tensor<2x640xf16>
%565 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_94, %564 : tensor<640xf16>, tensor<2x640xf16>) outs(%562 : tensor<2x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640xf16>
%expanded_840 = tensor.expand_shape %565 [[0], [1, 2, 3]] : tensor<2x640xf16> into tensor<2x640x1x1xf16>
%566 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%557, %expanded_840 : tensor<2x640x32x32xf16>, tensor<2x640x1x1xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%collapsed_841 = tensor.collapse_shape %566 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%expanded_842 = tensor.expand_shape %collapsed_841 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%567 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%568 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%567 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%569 = tensor.empty() : tensor<2x32x20x1024xf32>
%570 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%568 : tensor<f32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x1024xf32>
%571 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_842 : tensor<2x32x20x1024xf16>) outs(%570 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%572 = tensor.empty() : tensor<2x32x20x1024xf64>
%573 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%571 : tensor<2x32x20x1024xf32>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%574 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%575 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%573 : tensor<2x32x20x1024xf64>) outs(%574 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%576 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%575 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%577 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%573, %576 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%578 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%577 : tensor<2x32x20x1024xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%579 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%580 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%578 : tensor<2x32x20x1024xf64>) outs(%579 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%581 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%580 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%582 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%581 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%583 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%584 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%571 : tensor<2x32x20x1024xf32>) outs(%583 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%585 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%584 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%586 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%582, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%587 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%586 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%588 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_842, %585 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x1024xf32>
%589 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%588, %587 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%collapsed_843 = tensor.collapse_shape %589 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%expanded_844 = tensor.expand_shape %collapsed_843 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%expanded_845 = tensor.expand_shape %cst_95 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%590 = tensor.empty() : tensor<2x640x32x32xf32>
%591 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_844, %expanded_845 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%expanded_846 = tensor.expand_shape %cst_96 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%592 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%591, %expanded_846 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%593 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%594 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%593 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%595 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%594 : tensor<f16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%596 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%592 : tensor<2x640x32x32xf32>) outs(%595 : tensor<2x640x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%597 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%596 : tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x640x32x32xf16>
%598 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%597, %596 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%padded_847 = tensor.pad %598 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%599 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_98 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%600 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_847, %cst_97 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%599 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%601 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_100 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%602 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%522, %cst_99 : tensor<2x320x32x32xf16>, tensor<640x320x1x1xf16>) outs(%601 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%603 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%602, %600 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%604 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%603, %cst_4 : tensor<2x640x32x32xf16>, tensor<f64>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x640x32x32xf16>
%collapsed_848 = tensor.collapse_shape %604 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%expanded_849 = tensor.expand_shape %collapsed_848 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%605 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%606 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%605 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%607 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%606 : tensor<f32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x1024xf32>
%608 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_849 : tensor<2x32x20x1024xf16>) outs(%607 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%609 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%608 : tensor<2x32x20x1024xf32>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%610 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%611 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%609 : tensor<2x32x20x1024xf64>) outs(%610 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%612 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%611 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%613 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%609, %612 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%614 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%613 : tensor<2x32x20x1024xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%615 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%616 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%614 : tensor<2x32x20x1024xf64>) outs(%615 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%617 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%616 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%618 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%617 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%619 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%620 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%608 : tensor<2x32x20x1024xf32>) outs(%619 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%621 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%620 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%622 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%618, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%623 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%622 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%624 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_849, %621 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x1024xf32>
%625 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%624, %623 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%collapsed_850 = tensor.collapse_shape %625 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%expanded_851 = tensor.expand_shape %collapsed_850 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%expanded_852 = tensor.expand_shape %cst_101 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%626 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_851, %expanded_852 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%expanded_853 = tensor.expand_shape %cst_102 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%627 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%626, %expanded_853 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%628 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%629 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%628 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%630 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%629 : tensor<f16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%631 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%627 : tensor<2x640x32x32xf32>) outs(%630 : tensor<2x640x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%632 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_104 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%633 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%631, %cst_103 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%632 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%634 = tensor.empty() : tensor<2x32x32x640xf16>
%635 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%633 : tensor<2x640x32x32xf16>) outs(%634 : tensor<2x32x32x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x32x32x640xf16>
%collapsed_854 = tensor.collapse_shape %635 [[0], [1, 2], [3]] : tensor<2x32x32x640xf16> into tensor<2x1024x640xf16>
%636 = tensor.empty() : tensor<2x1024x1xf16>
%637 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%638 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_854 : tensor<2x1024x640xf16>) outs(%637 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%639 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%638 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%640 = tensor.empty() : tensor<2x1024x640xf16>
%641 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%639 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%642 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_854, %641 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%643 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%642 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%644 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%645 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%643 : tensor<2x1024x640xf16>) outs(%644 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%646 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%645 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%647 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%646 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%648 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%647 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%649 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%648 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%650 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%642, %649 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%651 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%650, %cst_105 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%652 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%651, %cst_106 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%653 = tensor.empty() : tensor<640x640xf16>
%654 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_107 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_855 = tensor.collapse_shape %652 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%655 = tensor.empty() : tensor<2048x640xf16>
%656 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%657 = linalg.matmul ins(%collapsed_855, %654 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%656 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%658 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_108 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%659 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%660 = linalg.matmul ins(%collapsed_855, %658 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%659 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%661 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_109 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%662 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%663 = linalg.matmul ins(%collapsed_855, %661 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%662 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%expanded_856 = tensor.expand_shape %657 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%664 = tensor.empty() : tensor<2x8x1024x80xf16>
%665 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_856 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_857 = tensor.collapse_shape %665 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_858 = tensor.expand_shape %660 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%666 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_858 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_859 = tensor.collapse_shape %666 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_860 = tensor.expand_shape %663 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%667 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_860 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_861 = tensor.collapse_shape %667 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%668 = tensor.empty() : tensor<16x80x1024xf16>
%669 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_859 : tensor<16x1024x80xf16>) outs(%668 : tensor<16x80x1024xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x80x1024xf16>
%670 = tensor.empty() : tensor<16x1024x1024xf16>
%671 = linalg.fill ins(%cst_695 : f16) outs(%670 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%672 = linalg.batch_matmul ins(%collapsed_857, %669 : tensor<16x1024x80xf16>, tensor<16x80x1024xf16>) outs(%671 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%673 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%672, %cst_1 : tensor<16x1024x1024xf16>, tensor<f64>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x1024x1024xf16>
%674 = tensor.empty() : tensor<16x1024x1xf16>
%675 = linalg.fill ins(%cst_697 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%676 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%673 : tensor<16x1024x1024xf16>) outs(%675 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%677 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%673, %676 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%678 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%677 : tensor<16x1024x1024xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%679 = linalg.fill ins(%cst_695 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%680 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%678 : tensor<16x1024x1024xf16>) outs(%679 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%681 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%678, %680 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%682 = tensor.empty() : tensor<16x1024x80xf16>
%683 = linalg.fill ins(%cst_695 : f16) outs(%682 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%684 = linalg.batch_matmul ins(%681, %collapsed_861 : tensor<16x1024x1024xf16>, tensor<16x1024x80xf16>) outs(%683 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%expanded_862 = tensor.expand_shape %684 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%685 = tensor.empty() : tensor<2x1024x8x80xf16>
%686 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_862 : tensor<2x8x1024x80xf16>) outs(%685 : tensor<2x1024x8x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x8x80xf16>
%687 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_110 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_863 = tensor.collapse_shape %686 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%688 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%689 = linalg.matmul ins(%collapsed_863, %687 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%688 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%690 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_111, %689 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_864 = tensor.expand_shape %690 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%691 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_864, %collapsed_854 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%692 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%693 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%691 : tensor<2x1024x640xf16>) outs(%692 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%694 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%693 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%695 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%694 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%696 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%691, %695 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%697 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%696 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%698 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%699 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%697 : tensor<2x1024x640xf16>) outs(%698 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%700 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%699 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%701 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%700 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%702 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%701 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%703 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%702 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%704 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%696, %703 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%705 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%704, %cst_112 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%706 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%705, %cst_113 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%707 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_114 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_865 = tensor.collapse_shape %706 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%708 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%709 = linalg.matmul ins(%collapsed_865, %707 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%708 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%710 = tensor.empty() : tensor<768x640xf16>
%711 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_115 : tensor<640x768xf16>) outs(%710 : tensor<768x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x640xf16>
%712 = tensor.empty() : tensor<154x640xf16>
%713 = linalg.fill ins(%cst_695 : f16) outs(%712 : tensor<154x640xf16>) -> tensor<154x640xf16>
%714 = linalg.matmul ins(%collapsed_766, %711 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%713 : tensor<154x640xf16>) -> tensor<154x640xf16>
%715 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_116 : tensor<640x768xf16>) outs(%710 : tensor<768x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x640xf16>
%716 = linalg.fill ins(%cst_695 : f16) outs(%712 : tensor<154x640xf16>) -> tensor<154x640xf16>
%717 = linalg.matmul ins(%collapsed_766, %715 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%716 : tensor<154x640xf16>) -> tensor<154x640xf16>
%expanded_866 = tensor.expand_shape %709 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%718 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_866 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_867 = tensor.collapse_shape %718 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_868 = tensor.expand_shape %714 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%719 = tensor.empty() : tensor<2x8x77x80xf16>
%720 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_868 : tensor<2x77x8x80xf16>) outs(%719 : tensor<2x8x77x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x80xf16>
%collapsed_869 = tensor.collapse_shape %720 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%expanded_870 = tensor.expand_shape %717 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%721 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_870 : tensor<2x77x8x80xf16>) outs(%719 : tensor<2x8x77x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x80xf16>
%collapsed_871 = tensor.collapse_shape %721 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%722 = tensor.empty() : tensor<16x80x77xf16>
%723 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_869 : tensor<16x77x80xf16>) outs(%722 : tensor<16x80x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x80x77xf16>
%724 = tensor.empty() : tensor<16x1024x77xf16>
%725 = linalg.fill ins(%cst_695 : f16) outs(%724 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%726 = linalg.batch_matmul ins(%collapsed_867, %723 : tensor<16x1024x80xf16>, tensor<16x80x77xf16>) outs(%725 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%727 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%726, %cst_1 : tensor<16x1024x77xf16>, tensor<f64>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x1024x77xf16>
%728 = linalg.fill ins(%cst_697 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%729 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%727 : tensor<16x1024x77xf16>) outs(%728 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%730 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%727, %729 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%731 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%730 : tensor<16x1024x77xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%732 = linalg.fill ins(%cst_695 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%733 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%731 : tensor<16x1024x77xf16>) outs(%732 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%734 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%731, %733 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%735 = linalg.fill ins(%cst_695 : f16) outs(%682 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%736 = linalg.batch_matmul ins(%734, %collapsed_871 : tensor<16x1024x77xf16>, tensor<16x77x80xf16>) outs(%735 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%expanded_872 = tensor.expand_shape %736 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%737 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_872 : tensor<2x8x1024x80xf16>) outs(%685 : tensor<2x1024x8x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x8x80xf16>
%738 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_117 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_873 = tensor.collapse_shape %737 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%739 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%740 = linalg.matmul ins(%collapsed_873, %738 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%739 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%741 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_118, %740 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_874 = tensor.expand_shape %741 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%742 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_874, %691 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%743 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%744 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%742 : tensor<2x1024x640xf16>) outs(%743 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%745 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%744 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%746 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%745 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%747 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%742, %746 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%748 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%747 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%749 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%750 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%748 : tensor<2x1024x640xf16>) outs(%749 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%751 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%750 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%752 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%751 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%753 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%752 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%754 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%753 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%755 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%747, %754 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%756 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%755, %cst_119 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%757 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%756, %cst_120 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%758 = tensor.empty() : tensor<640x5120xf16>
%759 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_121 : tensor<5120x640xf16>) outs(%758 : tensor<640x5120xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x5120xf16>
%collapsed_875 = tensor.collapse_shape %757 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%760 = tensor.empty() : tensor<2048x5120xf16>
%761 = linalg.fill ins(%cst_695 : f16) outs(%760 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%762 = linalg.matmul ins(%collapsed_875, %759 : tensor<2048x640xf16>, tensor<640x5120xf16>) outs(%761 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%763 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_122, %762 : tensor<5120xf16>, tensor<2048x5120xf16>) outs(%760 : tensor<2048x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x5120xf16>
%expanded_876 = tensor.expand_shape %763 [[0, 1], [2]] : tensor<2048x5120xf16> into tensor<2x1024x5120xf16>
%extracted_slice_877 = tensor.extract_slice %expanded_876[0, 0, 0] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%extracted_slice_878 = tensor.extract_slice %expanded_876[0, 0, 2560] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%764 = tensor.empty() : tensor<2x1024x2560xf16>
%765 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_878 : tensor<2x1024x2560xf16>) outs(%764 : tensor<2x1024x2560xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x1024x2560xf16>
%766 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_877, %765 : tensor<2x1024x2560xf16>, tensor<2x1024x2560xf16>) outs(%764 : tensor<2x1024x2560xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x2560xf16>
%767 = tensor.empty() : tensor<2560x640xf16>
%768 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_123 : tensor<640x2560xf16>) outs(%767 : tensor<2560x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2560x640xf16>
%collapsed_879 = tensor.collapse_shape %766 [[0, 1], [2]] : tensor<2x1024x2560xf16> into tensor<2048x2560xf16>
%769 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%770 = linalg.matmul ins(%collapsed_879, %768 : tensor<2048x2560xf16>, tensor<2560x640xf16>) outs(%769 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%771 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_124, %770 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_880 = tensor.expand_shape %771 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%772 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_880, %742 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%expanded_881 = tensor.expand_shape %772 [[0], [1, 2], [3]] : tensor<2x1024x640xf16> into tensor<2x32x32x640xf16>
%773 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_881 : tensor<2x32x32x640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%774 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_126 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%775 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%773, %cst_125 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%774 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%776 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%775, %604 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%collapsed_882 = tensor.collapse_shape %776 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%expanded_883 = tensor.expand_shape %collapsed_882 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%777 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%778 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%777 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%779 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%778 : tensor<f32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x1024xf32>
%780 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_883 : tensor<2x32x20x1024xf16>) outs(%779 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%781 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%780 : tensor<2x32x20x1024xf32>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%782 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%783 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%781 : tensor<2x32x20x1024xf64>) outs(%782 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%784 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%783 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%785 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%781, %784 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%786 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%785 : tensor<2x32x20x1024xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%787 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%788 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%786 : tensor<2x32x20x1024xf64>) outs(%787 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%789 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%788 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%790 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%789 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%791 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%792 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%780 : tensor<2x32x20x1024xf32>) outs(%791 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%793 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%792 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%794 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%790, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%795 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%794 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%796 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_883, %793 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x1024xf32>
%797 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%796, %795 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%collapsed_884 = tensor.collapse_shape %797 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%expanded_885 = tensor.expand_shape %collapsed_884 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%expanded_886 = tensor.expand_shape %cst_127 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%798 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_885, %expanded_886 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%expanded_887 = tensor.expand_shape %cst_128 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%799 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%798, %expanded_887 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%800 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%801 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%800 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%802 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%801 : tensor<f16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%803 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%799 : tensor<2x640x32x32xf32>) outs(%802 : tensor<2x640x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%804 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%803 : tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x640x32x32xf16>
%805 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%804, %803 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%padded_888 = tensor.pad %805 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%806 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_130 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%807 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_888, %cst_129 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%806 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%808 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%809 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%808, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%810 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_131 : tensor<640x1280xf16>) outs(%560 : tensor<1280x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x640xf16>
%811 = linalg.fill ins(%cst_695 : f16) outs(%562 : tensor<2x640xf16>) -> tensor<2x640xf16>
%812 = linalg.matmul ins(%809, %810 : tensor<2x1280xf16>, tensor<1280x640xf16>) outs(%811 : tensor<2x640xf16>) -> tensor<2x640xf16>
%813 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_132, %812 : tensor<640xf16>, tensor<2x640xf16>) outs(%562 : tensor<2x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640xf16>
%expanded_889 = tensor.expand_shape %813 [[0], [1, 2, 3]] : tensor<2x640xf16> into tensor<2x640x1x1xf16>
%814 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%807, %expanded_889 : tensor<2x640x32x32xf16>, tensor<2x640x1x1xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%collapsed_890 = tensor.collapse_shape %814 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%expanded_891 = tensor.expand_shape %collapsed_890 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%815 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%816 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%815 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%817 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%816 : tensor<f32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x1024xf32>
%818 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_891 : tensor<2x32x20x1024xf16>) outs(%817 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%819 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%818 : tensor<2x32x20x1024xf32>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%820 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%821 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%819 : tensor<2x32x20x1024xf64>) outs(%820 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%822 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%821 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%823 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%819, %822 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%824 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%823 : tensor<2x32x20x1024xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%825 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%826 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%824 : tensor<2x32x20x1024xf64>) outs(%825 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%827 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%826 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%828 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%827 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%829 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%830 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%818 : tensor<2x32x20x1024xf32>) outs(%829 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%831 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%830 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%832 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%828, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%833 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%832 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%834 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_891, %831 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x1024xf32>
%835 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%834, %833 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%collapsed_892 = tensor.collapse_shape %835 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%expanded_893 = tensor.expand_shape %collapsed_892 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%expanded_894 = tensor.expand_shape %cst_133 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%836 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_893, %expanded_894 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%expanded_895 = tensor.expand_shape %cst_134 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%837 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%836, %expanded_895 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%838 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%839 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%838 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%840 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%839 : tensor<f16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%841 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%837 : tensor<2x640x32x32xf32>) outs(%840 : tensor<2x640x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%842 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%841 : tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x640x32x32xf16>
%843 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%842, %841 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%padded_896 = tensor.pad %843 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%844 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_136 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%845 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_896, %cst_135 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%844 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%846 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%776, %845 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%847 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%846, %cst_4 : tensor<2x640x32x32xf16>, tensor<f64>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x640x32x32xf16>
%collapsed_897 = tensor.collapse_shape %847 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%expanded_898 = tensor.expand_shape %collapsed_897 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%848 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%849 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%848 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%850 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%849 : tensor<f32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x1024xf32>
%851 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_898 : tensor<2x32x20x1024xf16>) outs(%850 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%852 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%851 : tensor<2x32x20x1024xf32>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%853 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%854 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%852 : tensor<2x32x20x1024xf64>) outs(%853 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%855 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%854 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%856 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%852, %855 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%857 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%856 : tensor<2x32x20x1024xf64>) outs(%572 : tensor<2x32x20x1024xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x1024xf64>
%858 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%859 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%857 : tensor<2x32x20x1024xf64>) outs(%858 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%860 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%859 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%861 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%860 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%862 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%863 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%851 : tensor<2x32x20x1024xf32>) outs(%862 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%864 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%863 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%865 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%861, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%866 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%865 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%867 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_898, %864 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x1024xf32>
%868 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%867, %866 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%569 : tensor<2x32x20x1024xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x1024xf32>
%collapsed_899 = tensor.collapse_shape %868 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%expanded_900 = tensor.expand_shape %collapsed_899 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%expanded_901 = tensor.expand_shape %cst_137 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%869 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_900, %expanded_901 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%expanded_902 = tensor.expand_shape %cst_138 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%870 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%869, %expanded_902 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%590 : tensor<2x640x32x32xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x32x32xf32>
%871 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%872 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%871 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%873 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%872 : tensor<f16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%874 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%870 : tensor<2x640x32x32xf32>) outs(%873 : tensor<2x640x32x32xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%875 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_140 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%876 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%874, %cst_139 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%875 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%877 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%876 : tensor<2x640x32x32xf16>) outs(%634 : tensor<2x32x32x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x32x32x640xf16>
%collapsed_903 = tensor.collapse_shape %877 [[0], [1, 2], [3]] : tensor<2x32x32x640xf16> into tensor<2x1024x640xf16>
%878 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%879 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_903 : tensor<2x1024x640xf16>) outs(%878 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%880 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%879 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%881 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%880 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%882 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_903, %881 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%883 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%882 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%884 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%885 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%883 : tensor<2x1024x640xf16>) outs(%884 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%886 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%885 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%887 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%886 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%888 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%887 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%889 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%888 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%890 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%882, %889 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%891 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%890, %cst_141 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%892 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%891, %cst_142 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%893 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_143 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_904 = tensor.collapse_shape %892 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%894 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%895 = linalg.matmul ins(%collapsed_904, %893 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%894 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%896 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_144 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%897 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%898 = linalg.matmul ins(%collapsed_904, %896 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%897 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%899 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_145 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%900 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%901 = linalg.matmul ins(%collapsed_904, %899 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%900 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%expanded_905 = tensor.expand_shape %895 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%902 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_905 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_906 = tensor.collapse_shape %902 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_907 = tensor.expand_shape %898 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%903 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_907 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_908 = tensor.collapse_shape %903 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_909 = tensor.expand_shape %901 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%904 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_909 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_910 = tensor.collapse_shape %904 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%905 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_908 : tensor<16x1024x80xf16>) outs(%668 : tensor<16x80x1024xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x80x1024xf16>
%906 = linalg.fill ins(%cst_695 : f16) outs(%670 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%907 = linalg.batch_matmul ins(%collapsed_906, %905 : tensor<16x1024x80xf16>, tensor<16x80x1024xf16>) outs(%906 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%908 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%907, %cst_1 : tensor<16x1024x1024xf16>, tensor<f64>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x1024x1024xf16>
%909 = linalg.fill ins(%cst_697 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%910 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%908 : tensor<16x1024x1024xf16>) outs(%909 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%911 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%908, %910 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%912 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%911 : tensor<16x1024x1024xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%913 = linalg.fill ins(%cst_695 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%914 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%912 : tensor<16x1024x1024xf16>) outs(%913 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%915 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%912, %914 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%670 : tensor<16x1024x1024xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1024xf16>
%916 = linalg.fill ins(%cst_695 : f16) outs(%682 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%917 = linalg.batch_matmul ins(%915, %collapsed_910 : tensor<16x1024x1024xf16>, tensor<16x1024x80xf16>) outs(%916 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%expanded_911 = tensor.expand_shape %917 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%918 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_911 : tensor<2x8x1024x80xf16>) outs(%685 : tensor<2x1024x8x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x8x80xf16>
%919 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_146 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_912 = tensor.collapse_shape %918 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%920 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%921 = linalg.matmul ins(%collapsed_912, %919 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%920 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%922 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_147, %921 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_913 = tensor.expand_shape %922 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%923 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_913, %collapsed_903 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%924 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%925 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%923 : tensor<2x1024x640xf16>) outs(%924 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%926 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%925 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%927 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%926 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%928 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%923, %927 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%929 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%928 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%930 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%931 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%929 : tensor<2x1024x640xf16>) outs(%930 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%932 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%931 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%933 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%932 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%934 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%933 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%935 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%934 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%936 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%928, %935 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%937 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%936, %cst_148 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%938 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%937, %cst_149 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%939 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_150 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_914 = tensor.collapse_shape %938 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%940 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%941 = linalg.matmul ins(%collapsed_914, %939 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%940 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%942 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_151 : tensor<640x768xf16>) outs(%710 : tensor<768x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x640xf16>
%943 = linalg.fill ins(%cst_695 : f16) outs(%712 : tensor<154x640xf16>) -> tensor<154x640xf16>
%944 = linalg.matmul ins(%collapsed_766, %942 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%943 : tensor<154x640xf16>) -> tensor<154x640xf16>
%945 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_152 : tensor<640x768xf16>) outs(%710 : tensor<768x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x640xf16>
%946 = linalg.fill ins(%cst_695 : f16) outs(%712 : tensor<154x640xf16>) -> tensor<154x640xf16>
%947 = linalg.matmul ins(%collapsed_766, %945 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%946 : tensor<154x640xf16>) -> tensor<154x640xf16>
%expanded_915 = tensor.expand_shape %941 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%948 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_915 : tensor<2x1024x8x80xf16>) outs(%664 : tensor<2x8x1024x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x1024x80xf16>
%collapsed_916 = tensor.collapse_shape %948 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%expanded_917 = tensor.expand_shape %944 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%949 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_917 : tensor<2x77x8x80xf16>) outs(%719 : tensor<2x8x77x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x80xf16>
%collapsed_918 = tensor.collapse_shape %949 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%expanded_919 = tensor.expand_shape %947 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%950 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_919 : tensor<2x77x8x80xf16>) outs(%719 : tensor<2x8x77x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x80xf16>
%collapsed_920 = tensor.collapse_shape %950 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%951 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_918 : tensor<16x77x80xf16>) outs(%722 : tensor<16x80x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x80x77xf16>
%952 = linalg.fill ins(%cst_695 : f16) outs(%724 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%953 = linalg.batch_matmul ins(%collapsed_916, %951 : tensor<16x1024x80xf16>, tensor<16x80x77xf16>) outs(%952 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%954 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%953, %cst_1 : tensor<16x1024x77xf16>, tensor<f64>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x1024x77xf16>
%955 = linalg.fill ins(%cst_697 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%956 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%954 : tensor<16x1024x77xf16>) outs(%955 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%957 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%954, %956 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%958 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%957 : tensor<16x1024x77xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%959 = linalg.fill ins(%cst_695 : f16) outs(%674 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%960 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%958 : tensor<16x1024x77xf16>) outs(%959 : tensor<16x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x1xf16>
%961 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%958, %960 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%724 : tensor<16x1024x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x1024x77xf16>
%962 = linalg.fill ins(%cst_695 : f16) outs(%682 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%963 = linalg.batch_matmul ins(%961, %collapsed_920 : tensor<16x1024x77xf16>, tensor<16x77x80xf16>) outs(%962 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%expanded_921 = tensor.expand_shape %963 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%964 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_921 : tensor<2x8x1024x80xf16>) outs(%685 : tensor<2x1024x8x80xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x8x80xf16>
%965 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_153 : tensor<640x640xf16>) outs(%653 : tensor<640x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x640xf16>
%collapsed_922 = tensor.collapse_shape %964 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%966 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%967 = linalg.matmul ins(%collapsed_922, %965 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%966 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%968 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_154, %967 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_923 = tensor.expand_shape %968 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%969 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_923, %923 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%970 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%971 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%969 : tensor<2x1024x640xf16>) outs(%970 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%972 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%971 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%973 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%972 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%974 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%969, %973 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%975 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%974 : tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%976 = linalg.fill ins(%cst_695 : f16) outs(%636 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%977 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%975 : tensor<2x1024x640xf16>) outs(%976 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%978 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%977 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_712 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%979 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%978 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1024x1xf16>
%980 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%979 : tensor<2x1024x1xf16>) outs(%636 : tensor<2x1024x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x1xf16>
%981 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%980 : tensor<2x1024x1xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1024x640xf16>
%982 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%974, %981 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%983 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%982, %cst_155 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%984 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%983, %cst_156 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%985 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_157 : tensor<5120x640xf16>) outs(%758 : tensor<640x5120xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<640x5120xf16>
%collapsed_924 = tensor.collapse_shape %984 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%986 = linalg.fill ins(%cst_695 : f16) outs(%760 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%987 = linalg.matmul ins(%collapsed_924, %985 : tensor<2048x640xf16>, tensor<640x5120xf16>) outs(%986 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%988 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_158, %987 : tensor<5120xf16>, tensor<2048x5120xf16>) outs(%760 : tensor<2048x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x5120xf16>
%expanded_925 = tensor.expand_shape %988 [[0, 1], [2]] : tensor<2048x5120xf16> into tensor<2x1024x5120xf16>
%extracted_slice_926 = tensor.extract_slice %expanded_925[0, 0, 0] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%extracted_slice_927 = tensor.extract_slice %expanded_925[0, 0, 2560] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%989 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_927 : tensor<2x1024x2560xf16>) outs(%764 : tensor<2x1024x2560xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x1024x2560xf16>
%990 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_926, %989 : tensor<2x1024x2560xf16>, tensor<2x1024x2560xf16>) outs(%764 : tensor<2x1024x2560xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x2560xf16>
%991 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_159 : tensor<640x2560xf16>) outs(%767 : tensor<2560x640xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2560x640xf16>
%collapsed_928 = tensor.collapse_shape %990 [[0, 1], [2]] : tensor<2x1024x2560xf16> into tensor<2048x2560xf16>
%992 = linalg.fill ins(%cst_695 : f16) outs(%655 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%993 = linalg.matmul ins(%collapsed_928, %991 : tensor<2048x2560xf16>, tensor<2560x640xf16>) outs(%992 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%994 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_160, %993 : tensor<640xf16>, tensor<2048x640xf16>) outs(%655 : tensor<2048x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2048x640xf16>
%expanded_929 = tensor.expand_shape %994 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%995 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_929, %969 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%640 : tensor<2x1024x640xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1024x640xf16>
%expanded_930 = tensor.expand_shape %995 [[0], [1, 2], [3]] : tensor<2x1024x640xf16> into tensor<2x32x32x640xf16>
%996 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_930 : tensor<2x32x32x640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%997 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_162 : tensor<640xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x32x32xf16>
%998 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%996, %cst_161 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%997 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%999 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%998, %847 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%555 : tensor<2x640x32x32xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x32x32xf16>
%padded_931 = tensor.pad %999 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%1000 = tensor.empty() : tensor<2x640x16x16xf16>
%1001 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_164 : tensor<640xf16>) outs(%1000 : tensor<2x640x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x16x16xf16>
%1002 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%padded_931, %cst_163 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%1001 : tensor<2x640x16x16xf16>) -> tensor<2x640x16x16xf16>
%collapsed_932 = tensor.collapse_shape %1002 [[0], [1], [2, 3]] : tensor<2x640x16x16xf16> into tensor<2x640x256xf16>
%expanded_933 = tensor.expand_shape %collapsed_932 [[0], [1, 2], [3]] : tensor<2x640x256xf16> into tensor<2x32x20x256xf16>
%1003 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1004 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1003 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1005 = tensor.empty() : tensor<2x32x20x256xf32>
%1006 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1004 : tensor<f32>) outs(%1005 : tensor<2x32x20x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x20x256xf32>
%1007 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_933 : tensor<2x32x20x256xf16>) outs(%1006 : tensor<2x32x20x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x256xf32>
%1008 = tensor.empty() : tensor<2x32x20x256xf64>
%1009 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1007 : tensor<2x32x20x256xf32>) outs(%1008 : tensor<2x32x20x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x256xf64>
%1010 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1011 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1009 : tensor<2x32x20x256xf64>) outs(%1010 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1012 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1011 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1013 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1009, %1012 : tensor<2x32x20x256xf64>, tensor<2x32x1x1xf64>) outs(%1008 : tensor<2x32x20x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x256xf64>
%1014 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1013 : tensor<2x32x20x256xf64>) outs(%1008 : tensor<2x32x20x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x20x256xf64>
%1015 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1016 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1014 : tensor<2x32x20x256xf64>) outs(%1015 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1017 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1016 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1018 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1017 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1019 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1020 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1007 : tensor<2x32x20x256xf32>) outs(%1019 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1021 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1020 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_714 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1022 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1018, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1023 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1022 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1024 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_933, %1021 : tensor<2x32x20x256xf16>, tensor<2x32x1x1xf32>) outs(%1005 : tensor<2x32x20x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x20x256xf32>
%1025 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1024, %1023 : tensor<2x32x20x256xf32>, tensor<2x32x1x1xf32>) outs(%1005 : tensor<2x32x20x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x20x256xf32>
%collapsed_934 = tensor.collapse_shape %1025 [[0], [1, 2], [3]] : tensor<2x32x20x256xf32> into tensor<2x640x256xf32>
%expanded_935 = tensor.expand_shape %collapsed_934 [[0], [1], [2, 3]] : tensor<2x640x256xf32> into tensor<2x640x16x16xf32>
%expanded_936 = tensor.expand_shape %cst_165 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1026 = tensor.empty() : tensor<2x640x16x16xf32>
%1027 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_935, %expanded_936 : tensor<2x640x16x16xf32>, tensor<640x1x1xf16>) outs(%1026 : tensor<2x640x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x16x16xf32>
%expanded_937 = tensor.expand_shape %cst_166 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1028 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1027, %expanded_937 : tensor<2x640x16x16xf32>, tensor<640x1x1xf16>) outs(%1026 : tensor<2x640x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x640x16x16xf32>
%1029 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1030 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1029 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1031 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1030 : tensor<f16>) outs(%1000 : tensor<2x640x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x640x16x16xf16>
%1032 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1028 : tensor<2x640x16x16xf32>) outs(%1031 : tensor<2x640x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x640x16x16xf16>
%1033 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1032 : tensor<2x640x16x16xf16>) outs(%1000 : tensor<2x640x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x640x16x16xf16>
%1034 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1033, %1032 : tensor<2x640x16x16xf16>, tensor<2x640x16x16xf16>) outs(%1000 : tensor<2x640x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x640x16x16xf16>
%padded_938 = tensor.pad %1034 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x640x16x16xf16> to tensor<2x640x18x18xf16>
%1035 = tensor.empty() : tensor<2x1280x16x16xf16>
%1036 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_168 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1037 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_938, %cst_167 : tensor<2x640x18x18xf16>, tensor<1280x640x3x3xf16>) outs(%1036 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1038 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1039 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1038, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1040 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_169 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1041 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1042 = linalg.matmul ins(%1039, %1040 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1041 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1043 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_170, %1042 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_939 = tensor.expand_shape %1043 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1044 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1037, %expanded_939 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_940 = tensor.collapse_shape %1044 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_941 = tensor.expand_shape %collapsed_940 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1045 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1046 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1045 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1047 = tensor.empty() : tensor<2x32x40x256xf32>
%1048 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1046 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%1049 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_941 : tensor<2x32x40x256xf16>) outs(%1048 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%1050 = tensor.empty() : tensor<2x32x40x256xf64>
%1051 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1049 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1052 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1053 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1051 : tensor<2x32x40x256xf64>) outs(%1052 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1054 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1053 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1055 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1051, %1054 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1056 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1055 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1057 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1058 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1056 : tensor<2x32x40x256xf64>) outs(%1057 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1059 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1058 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1060 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1059 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1061 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1062 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1049 : tensor<2x32x40x256xf32>) outs(%1061 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1063 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1062 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1064 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1060, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1065 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1064 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1066 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_941, %1063 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%1067 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1066, %1065 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_942 = tensor.collapse_shape %1067 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_943 = tensor.expand_shape %collapsed_942 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_944 = tensor.expand_shape %cst_171 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1068 = tensor.empty() : tensor<2x1280x16x16xf32>
%1069 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_943, %expanded_944 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_945 = tensor.expand_shape %cst_172 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1070 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1069, %expanded_945 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%1071 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1072 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1071 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1073 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1072 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1074 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1070 : tensor<2x1280x16x16xf32>) outs(%1073 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1075 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1074 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%1076 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1075, %1074 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_946 = tensor.pad %1076 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1077 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_174 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1078 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_946, %cst_173 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1077 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1079 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_176 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1080 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1002, %cst_175 : tensor<2x640x16x16xf16>, tensor<1280x640x1x1xf16>) outs(%1079 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1081 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1080, %1078 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1082 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1081, %cst_4 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_947 = tensor.collapse_shape %1082 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_948 = tensor.expand_shape %collapsed_947 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1083 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1084 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1083 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1085 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1084 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%1086 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_948 : tensor<2x32x40x256xf16>) outs(%1085 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%1087 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1086 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1088 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1089 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1087 : tensor<2x32x40x256xf64>) outs(%1088 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1090 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1089 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1091 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1087, %1090 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1092 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1091 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1093 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1094 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1092 : tensor<2x32x40x256xf64>) outs(%1093 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1095 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1094 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1096 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1095 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1097 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1098 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1086 : tensor<2x32x40x256xf32>) outs(%1097 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1099 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1098 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1100 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1096, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1101 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1100 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1102 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_948, %1099 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%1103 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1102, %1101 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_949 = tensor.collapse_shape %1103 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_950 = tensor.expand_shape %collapsed_949 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_951 = tensor.expand_shape %cst_177 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1104 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_950, %expanded_951 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_952 = tensor.expand_shape %cst_178 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1105 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1104, %expanded_952 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%1106 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1107 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1106 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1108 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1107 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1109 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1105 : tensor<2x1280x16x16xf32>) outs(%1108 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1110 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_180 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1111 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1109, %cst_179 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1110 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1112 = tensor.empty() : tensor<2x16x16x1280xf16>
%1113 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1111 : tensor<2x1280x16x16xf16>) outs(%1112 : tensor<2x16x16x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x16x16x1280xf16>
%collapsed_953 = tensor.collapse_shape %1113 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%1114 = tensor.empty() : tensor<2x256x1xf16>
%1115 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1116 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_953 : tensor<2x256x1280xf16>) outs(%1115 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1117 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1116 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1118 = tensor.empty() : tensor<2x256x1280xf16>
%1119 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1117 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1120 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_953, %1119 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1121 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1120 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1122 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1123 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1121 : tensor<2x256x1280xf16>) outs(%1122 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1124 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1123 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1125 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1124 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1126 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1125 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1127 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1126 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1128 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1120, %1127 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1129 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1128, %cst_181 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1130 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1129, %cst_182 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1131 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_183 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_954 = tensor.collapse_shape %1130 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1132 = tensor.empty() : tensor<512x1280xf16>
%1133 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1134 = linalg.matmul ins(%collapsed_954, %1131 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1133 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1135 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_184 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1136 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1137 = linalg.matmul ins(%collapsed_954, %1135 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1136 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1138 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_185 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1139 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1140 = linalg.matmul ins(%collapsed_954, %1138 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1139 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%expanded_955 = tensor.expand_shape %1134 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1141 = tensor.empty() : tensor<2x8x256x160xf16>
%1142 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_955 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_956 = tensor.collapse_shape %1142 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_957 = tensor.expand_shape %1137 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1143 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_957 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_958 = tensor.collapse_shape %1143 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_959 = tensor.expand_shape %1140 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1144 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_959 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_960 = tensor.collapse_shape %1144 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1145 = tensor.empty() : tensor<16x160x256xf16>
%1146 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_958 : tensor<16x256x160xf16>) outs(%1145 : tensor<16x160x256xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x256xf16>
%1147 = tensor.empty() : tensor<16x256x256xf16>
%1148 = linalg.fill ins(%cst_695 : f16) outs(%1147 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1149 = linalg.batch_matmul ins(%collapsed_956, %1146 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%1148 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1150 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1149, %cst_0 : tensor<16x256x256xf16>, tensor<f64>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x256xf16>
%1151 = tensor.empty() : tensor<16x256x1xf16>
%1152 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1153 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1150 : tensor<16x256x256xf16>) outs(%1152 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1154 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1150, %1153 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1155 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1154 : tensor<16x256x256xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1156 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1157 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1155 : tensor<16x256x256xf16>) outs(%1156 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1158 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1155, %1157 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1159 = tensor.empty() : tensor<16x256x160xf16>
%1160 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1161 = linalg.batch_matmul ins(%1158, %collapsed_960 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%1160 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_961 = tensor.expand_shape %1161 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1162 = tensor.empty() : tensor<2x256x8x160xf16>
%1163 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_961 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%1164 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_186 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_962 = tensor.collapse_shape %1163 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1165 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1166 = linalg.matmul ins(%collapsed_962, %1164 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1165 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1167 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_187, %1166 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_963 = tensor.expand_shape %1167 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1168 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_963, %collapsed_953 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1169 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1170 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1168 : tensor<2x256x1280xf16>) outs(%1169 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1171 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1170 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1172 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1171 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1173 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1168, %1172 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1174 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1173 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1175 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1176 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1174 : tensor<2x256x1280xf16>) outs(%1175 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1177 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1176 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1178 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1177 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1179 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1178 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1180 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1179 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1181 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1173, %1180 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1182 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1181, %cst_188 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1183 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1182, %cst_189 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1184 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_190 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_964 = tensor.collapse_shape %1183 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1185 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1186 = linalg.matmul ins(%collapsed_964, %1184 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1185 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1187 = tensor.empty() : tensor<768x1280xf16>
%1188 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_191 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1189 = tensor.empty() : tensor<154x1280xf16>
%1190 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1191 = linalg.matmul ins(%collapsed_766, %1188 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1190 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1192 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_192 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1193 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1194 = linalg.matmul ins(%collapsed_766, %1192 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1193 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_965 = tensor.expand_shape %1186 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1195 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_965 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_966 = tensor.collapse_shape %1195 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_967 = tensor.expand_shape %1191 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1196 = tensor.empty() : tensor<2x8x77x160xf16>
%1197 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_967 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_968 = tensor.collapse_shape %1197 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_969 = tensor.expand_shape %1194 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1198 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_969 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_970 = tensor.collapse_shape %1198 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1199 = tensor.empty() : tensor<16x160x77xf16>
%1200 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_968 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%1201 = tensor.empty() : tensor<16x256x77xf16>
%1202 = linalg.fill ins(%cst_695 : f16) outs(%1201 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1203 = linalg.batch_matmul ins(%collapsed_966, %1200 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%1202 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1204 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1203, %cst_0 : tensor<16x256x77xf16>, tensor<f64>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x77xf16>
%1205 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1206 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1204 : tensor<16x256x77xf16>) outs(%1205 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1207 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1204, %1206 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1208 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1207 : tensor<16x256x77xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1209 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1210 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1208 : tensor<16x256x77xf16>) outs(%1209 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1211 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1208, %1210 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1212 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1213 = linalg.batch_matmul ins(%1211, %collapsed_970 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%1212 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_971 = tensor.expand_shape %1213 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1214 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_971 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%1215 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_193 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_972 = tensor.collapse_shape %1214 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1216 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1217 = linalg.matmul ins(%collapsed_972, %1215 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1216 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1218 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_194, %1217 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_973 = tensor.expand_shape %1218 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1219 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_973, %1168 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1220 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1221 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1219 : tensor<2x256x1280xf16>) outs(%1220 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1222 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1221 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1223 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1222 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1224 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1219, %1223 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1225 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1224 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1226 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1227 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1225 : tensor<2x256x1280xf16>) outs(%1226 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1228 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1227 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1229 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1228 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1230 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1229 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1231 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1230 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1232 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1224, %1231 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1233 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1232, %cst_195 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1234 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1233, %cst_196 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1235 = tensor.empty() : tensor<1280x10240xf16>
%1236 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_197 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_974 = tensor.collapse_shape %1234 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1237 = tensor.empty() : tensor<512x10240xf16>
%1238 = linalg.fill ins(%cst_695 : f16) outs(%1237 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1239 = linalg.matmul ins(%collapsed_974, %1236 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%1238 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1240 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_198, %1239 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1237 : tensor<512x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x10240xf16>
%expanded_975 = tensor.expand_shape %1240 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%extracted_slice_976 = tensor.extract_slice %expanded_975[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%extracted_slice_977 = tensor.extract_slice %expanded_975[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1241 = tensor.empty() : tensor<2x256x5120xf16>
%1242 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_977 : tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x256x5120xf16>
%1243 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_976, %1242 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x5120xf16>
%1244 = tensor.empty() : tensor<5120x1280xf16>
%1245 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_199 : tensor<1280x5120xf16>) outs(%1244 : tensor<5120x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<5120x1280xf16>
%collapsed_978 = tensor.collapse_shape %1243 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%1246 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1247 = linalg.matmul ins(%collapsed_978, %1245 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%1246 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1248 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_200, %1247 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_979 = tensor.expand_shape %1248 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1249 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_979, %1219 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%expanded_980 = tensor.expand_shape %1249 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%1250 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_980 : tensor<2x16x16x1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1251 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_202 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1252 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1250, %cst_201 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1251 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1253 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1252, %1082 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_981 = tensor.collapse_shape %1253 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_982 = tensor.expand_shape %collapsed_981 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1254 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1255 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1254 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1256 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1255 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%1257 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_982 : tensor<2x32x40x256xf16>) outs(%1256 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%1258 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1257 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1259 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1260 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1258 : tensor<2x32x40x256xf64>) outs(%1259 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1261 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1260 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1262 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1258, %1261 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1263 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1262 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1264 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1265 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1263 : tensor<2x32x40x256xf64>) outs(%1264 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1266 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1265 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1267 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1266 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1268 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1269 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1257 : tensor<2x32x40x256xf32>) outs(%1268 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1270 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1269 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1271 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1267, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1272 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1271 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1273 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_982, %1270 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%1274 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1273, %1272 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_983 = tensor.collapse_shape %1274 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_984 = tensor.expand_shape %collapsed_983 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_985 = tensor.expand_shape %cst_203 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1275 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_984, %expanded_985 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_986 = tensor.expand_shape %cst_204 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1276 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1275, %expanded_986 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%1277 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1278 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1277 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1279 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1278 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1280 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1276 : tensor<2x1280x16x16xf32>) outs(%1279 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1281 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1280 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%1282 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1281, %1280 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_987 = tensor.pad %1282 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1283 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_206 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1284 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_987, %cst_205 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1283 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1285 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1286 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1285, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1287 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_207 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1288 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1289 = linalg.matmul ins(%1286, %1287 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1288 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1290 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_208, %1289 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_988 = tensor.expand_shape %1290 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1291 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1284, %expanded_988 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_989 = tensor.collapse_shape %1291 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_990 = tensor.expand_shape %collapsed_989 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1292 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1293 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1292 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1294 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1293 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%1295 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_990 : tensor<2x32x40x256xf16>) outs(%1294 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%1296 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1295 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1297 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1298 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1296 : tensor<2x32x40x256xf64>) outs(%1297 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1299 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1298 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1300 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1296, %1299 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1301 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1300 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1302 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1303 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1301 : tensor<2x32x40x256xf64>) outs(%1302 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1304 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1303 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1305 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1304 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1306 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1307 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1295 : tensor<2x32x40x256xf32>) outs(%1306 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1308 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1307 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1309 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1305, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1310 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1309 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1311 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_990, %1308 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%1312 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1311, %1310 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_991 = tensor.collapse_shape %1312 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_992 = tensor.expand_shape %collapsed_991 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_993 = tensor.expand_shape %cst_209 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1313 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_992, %expanded_993 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_994 = tensor.expand_shape %cst_210 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1314 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1313, %expanded_994 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%1315 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1316 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1315 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1317 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1316 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1318 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1314 : tensor<2x1280x16x16xf32>) outs(%1317 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1319 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1318 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%1320 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1319, %1318 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_995 = tensor.pad %1320 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1321 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_212 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1322 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_995, %cst_211 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1321 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1323 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1253, %1322 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1324 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1323, %cst_4 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_996 = tensor.collapse_shape %1324 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_997 = tensor.expand_shape %collapsed_996 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1325 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1326 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1325 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1327 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1326 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%1328 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_997 : tensor<2x32x40x256xf16>) outs(%1327 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%1329 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1328 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1330 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1331 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1329 : tensor<2x32x40x256xf64>) outs(%1330 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1332 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1331 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1333 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1329, %1332 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1334 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1333 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%1335 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1336 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1334 : tensor<2x32x40x256xf64>) outs(%1335 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1337 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1336 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1338 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1337 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1339 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1340 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1328 : tensor<2x32x40x256xf32>) outs(%1339 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1341 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1340 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1342 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1338, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1343 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1342 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1344 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_997, %1341 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%1345 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1344, %1343 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_998 = tensor.collapse_shape %1345 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_999 = tensor.expand_shape %collapsed_998 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1000 = tensor.expand_shape %cst_213 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1346 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_999, %expanded_1000 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1001 = tensor.expand_shape %cst_214 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1347 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1346, %expanded_1001 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%1348 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1349 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1348 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1350 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1349 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1351 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1347 : tensor<2x1280x16x16xf32>) outs(%1350 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%1352 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_216 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1353 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1351, %cst_215 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1352 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1354 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1353 : tensor<2x1280x16x16xf16>) outs(%1112 : tensor<2x16x16x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x16x16x1280xf16>
%collapsed_1002 = tensor.collapse_shape %1354 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%1355 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1356 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_1002 : tensor<2x256x1280xf16>) outs(%1355 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1357 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1356 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1358 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1357 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1359 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1002, %1358 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1360 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1359 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1361 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1362 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1360 : tensor<2x256x1280xf16>) outs(%1361 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1363 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1362 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1364 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1363 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1365 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1364 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1366 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1365 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1367 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1359, %1366 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1368 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1367, %cst_217 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1369 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1368, %cst_218 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1370 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_219 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1003 = tensor.collapse_shape %1369 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1371 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1372 = linalg.matmul ins(%collapsed_1003, %1370 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1371 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1373 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_220 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1374 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1375 = linalg.matmul ins(%collapsed_1003, %1373 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1374 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1376 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_221 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1377 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1378 = linalg.matmul ins(%collapsed_1003, %1376 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1377 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%expanded_1004 = tensor.expand_shape %1372 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1379 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1004 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1005 = tensor.collapse_shape %1379 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1006 = tensor.expand_shape %1375 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1380 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1006 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1007 = tensor.collapse_shape %1380 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1008 = tensor.expand_shape %1378 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1381 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1008 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1009 = tensor.collapse_shape %1381 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1382 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1007 : tensor<16x256x160xf16>) outs(%1145 : tensor<16x160x256xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x256xf16>
%1383 = linalg.fill ins(%cst_695 : f16) outs(%1147 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1384 = linalg.batch_matmul ins(%collapsed_1005, %1382 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%1383 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1385 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1384, %cst_0 : tensor<16x256x256xf16>, tensor<f64>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x256xf16>
%1386 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1387 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1385 : tensor<16x256x256xf16>) outs(%1386 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1388 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1385, %1387 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1389 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1388 : tensor<16x256x256xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1390 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1391 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1389 : tensor<16x256x256xf16>) outs(%1390 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1392 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1389, %1391 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%1393 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1394 = linalg.batch_matmul ins(%1392, %collapsed_1009 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%1393 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1010 = tensor.expand_shape %1394 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1395 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1010 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%1396 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_222 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1011 = tensor.collapse_shape %1395 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1397 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1398 = linalg.matmul ins(%collapsed_1011, %1396 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1397 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1399 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_223, %1398 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1012 = tensor.expand_shape %1399 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1400 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1012, %collapsed_1002 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1401 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1402 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1400 : tensor<2x256x1280xf16>) outs(%1401 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1403 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1402 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1404 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1403 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1405 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1400, %1404 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1406 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1405 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1407 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1408 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1406 : tensor<2x256x1280xf16>) outs(%1407 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1409 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1408 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1410 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1409 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1411 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1410 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1412 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1411 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1413 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1405, %1412 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1414 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1413, %cst_224 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1415 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1414, %cst_225 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1416 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_226 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1013 = tensor.collapse_shape %1415 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1417 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1418 = linalg.matmul ins(%collapsed_1013, %1416 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1417 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1419 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_227 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1420 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1421 = linalg.matmul ins(%collapsed_766, %1419 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1420 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1422 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_228 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1423 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1424 = linalg.matmul ins(%collapsed_766, %1422 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1423 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_1014 = tensor.expand_shape %1418 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1425 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1014 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1015 = tensor.collapse_shape %1425 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1016 = tensor.expand_shape %1421 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1426 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1016 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1017 = tensor.collapse_shape %1426 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_1018 = tensor.expand_shape %1424 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1427 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1018 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1019 = tensor.collapse_shape %1427 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1428 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1017 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%1429 = linalg.fill ins(%cst_695 : f16) outs(%1201 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1430 = linalg.batch_matmul ins(%collapsed_1015, %1428 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%1429 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1431 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1430, %cst_0 : tensor<16x256x77xf16>, tensor<f64>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x77xf16>
%1432 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1433 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1431 : tensor<16x256x77xf16>) outs(%1432 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1434 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1431, %1433 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1435 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1434 : tensor<16x256x77xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1436 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1437 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1435 : tensor<16x256x77xf16>) outs(%1436 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%1438 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1435, %1437 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%1439 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1440 = linalg.batch_matmul ins(%1438, %collapsed_1019 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%1439 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1020 = tensor.expand_shape %1440 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1441 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1020 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%1442 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_229 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1021 = tensor.collapse_shape %1441 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1443 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1444 = linalg.matmul ins(%collapsed_1021, %1442 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1443 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1445 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_230, %1444 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1022 = tensor.expand_shape %1445 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1446 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1022, %1400 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1447 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1448 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1446 : tensor<2x256x1280xf16>) outs(%1447 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1449 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1448 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1450 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1449 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1451 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1446, %1450 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1452 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1451 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1453 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1454 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1452 : tensor<2x256x1280xf16>) outs(%1453 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1455 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1454 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1456 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1455 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%1457 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1456 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%1458 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1457 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%1459 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1451, %1458 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1460 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1459, %cst_231 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1461 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1460, %cst_232 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%1462 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_233 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_1023 = tensor.collapse_shape %1461 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1463 = linalg.fill ins(%cst_695 : f16) outs(%1237 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1464 = linalg.matmul ins(%collapsed_1023, %1462 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%1463 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1465 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_234, %1464 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1237 : tensor<512x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x10240xf16>
%expanded_1024 = tensor.expand_shape %1465 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%extracted_slice_1025 = tensor.extract_slice %expanded_1024[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%extracted_slice_1026 = tensor.extract_slice %expanded_1024[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1466 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1026 : tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x256x5120xf16>
%1467 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1025, %1466 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x5120xf16>
%1468 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_235 : tensor<1280x5120xf16>) outs(%1244 : tensor<5120x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<5120x1280xf16>
%collapsed_1027 = tensor.collapse_shape %1467 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%1469 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1470 = linalg.matmul ins(%collapsed_1027, %1468 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%1469 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1471 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_236, %1470 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1028 = tensor.expand_shape %1471 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1472 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1028, %1446 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%expanded_1029 = tensor.expand_shape %1472 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%1473 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1029 : tensor<2x16x16x1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1474 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_238 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%1475 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1473, %cst_237 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1474 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1476 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1475, %1324 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_1030 = tensor.pad %1476 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1477 = tensor.empty() : tensor<2x1280x8x8xf16>
%1478 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_240 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1479 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%padded_1030, %cst_239 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1478 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%collapsed_1031 = tensor.collapse_shape %1479 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1032 = tensor.expand_shape %collapsed_1031 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1480 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1481 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1480 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1482 = tensor.empty() : tensor<2x32x40x64xf32>
%1483 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1481 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1484 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1032 : tensor<2x32x40x64xf16>) outs(%1483 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1485 = tensor.empty() : tensor<2x32x40x64xf64>
%1486 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1484 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1487 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1488 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1486 : tensor<2x32x40x64xf64>) outs(%1487 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1489 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1488 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1490 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1486, %1489 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1491 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1490 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1492 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1493 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1491 : tensor<2x32x40x64xf64>) outs(%1492 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1494 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1493 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1495 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1494 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1496 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1497 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1484 : tensor<2x32x40x64xf32>) outs(%1496 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1498 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1497 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1499 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1495, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1500 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1499 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1501 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1032, %1498 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1502 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1501, %1500 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1033 = tensor.collapse_shape %1502 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1034 = tensor.expand_shape %collapsed_1033 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1035 = tensor.expand_shape %cst_241 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1503 = tensor.empty() : tensor<2x1280x8x8xf32>
%1504 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1034, %expanded_1035 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1036 = tensor.expand_shape %cst_242 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1505 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1504, %expanded_1036 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1506 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1507 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1506 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1508 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1507 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1509 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1505 : tensor<2x1280x8x8xf32>) outs(%1508 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1510 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1509 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1511 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1510, %1509 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1037 = tensor.pad %1511 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1512 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_244 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1513 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1037, %cst_243 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1512 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1514 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1515 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1514, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1516 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_245 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1517 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1518 = linalg.matmul ins(%1515, %1516 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1517 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1519 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_246, %1518 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1038 = tensor.expand_shape %1519 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1520 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1513, %expanded_1038 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1039 = tensor.collapse_shape %1520 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1040 = tensor.expand_shape %collapsed_1039 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1521 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1522 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1521 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1523 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1522 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1524 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1040 : tensor<2x32x40x64xf16>) outs(%1523 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1525 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1524 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1526 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1527 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1525 : tensor<2x32x40x64xf64>) outs(%1526 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1528 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1527 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1529 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1525, %1528 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1530 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1529 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1531 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1532 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1530 : tensor<2x32x40x64xf64>) outs(%1531 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1533 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1532 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1534 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1533 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1535 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1536 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1524 : tensor<2x32x40x64xf32>) outs(%1535 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1537 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1536 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1538 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1534, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1539 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1538 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1540 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1040, %1537 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1541 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1540, %1539 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1041 = tensor.collapse_shape %1541 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1042 = tensor.expand_shape %collapsed_1041 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1043 = tensor.expand_shape %cst_247 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1542 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1042, %expanded_1043 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1044 = tensor.expand_shape %cst_248 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1543 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1542, %expanded_1044 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1544 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1545 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1544 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1546 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1545 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1547 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1543 : tensor<2x1280x8x8xf32>) outs(%1546 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1548 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1547 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1549 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1548, %1547 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1045 = tensor.pad %1549 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1550 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_250 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1551 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1045, %cst_249 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1550 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1552 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1479, %1551 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1553 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1552, %cst_4 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1046 = tensor.collapse_shape %1553 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1047 = tensor.expand_shape %collapsed_1046 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1554 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1555 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1554 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1556 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1555 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1557 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1047 : tensor<2x32x40x64xf16>) outs(%1556 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1558 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1557 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1559 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1560 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1558 : tensor<2x32x40x64xf64>) outs(%1559 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1561 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1560 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1562 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1558, %1561 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1563 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1562 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1564 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1565 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1563 : tensor<2x32x40x64xf64>) outs(%1564 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1566 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1565 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1567 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1566 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1568 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1569 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1557 : tensor<2x32x40x64xf32>) outs(%1568 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1570 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1569 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1571 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1567, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1572 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1571 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1573 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1047, %1570 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1574 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1573, %1572 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1048 = tensor.collapse_shape %1574 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1049 = tensor.expand_shape %collapsed_1048 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1050 = tensor.expand_shape %cst_251 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1575 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1049, %expanded_1050 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1051 = tensor.expand_shape %cst_252 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1576 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1575, %expanded_1051 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1577 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1578 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1577 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1579 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1578 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1580 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1576 : tensor<2x1280x8x8xf32>) outs(%1579 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1581 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1580 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1582 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1581, %1580 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1052 = tensor.pad %1582 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1583 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_254 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1584 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1052, %cst_253 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1583 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1585 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1586 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1585, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1587 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_255 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1588 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1589 = linalg.matmul ins(%1586, %1587 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1588 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1590 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_256, %1589 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1053 = tensor.expand_shape %1590 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1591 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1584, %expanded_1053 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1054 = tensor.collapse_shape %1591 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1055 = tensor.expand_shape %collapsed_1054 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1592 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1593 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1592 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1594 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1593 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1595 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1055 : tensor<2x32x40x64xf16>) outs(%1594 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1596 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1595 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1597 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1598 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1596 : tensor<2x32x40x64xf64>) outs(%1597 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1599 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1598 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1600 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1596, %1599 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1601 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1600 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1602 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1603 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1601 : tensor<2x32x40x64xf64>) outs(%1602 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1604 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1603 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1605 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1604 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1606 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1607 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1595 : tensor<2x32x40x64xf32>) outs(%1606 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1608 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1607 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1609 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1605, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1610 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1609 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1611 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1055, %1608 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1612 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1611, %1610 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1056 = tensor.collapse_shape %1612 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1057 = tensor.expand_shape %collapsed_1056 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1058 = tensor.expand_shape %cst_257 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1613 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1057, %expanded_1058 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1059 = tensor.expand_shape %cst_258 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1614 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1613, %expanded_1059 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1615 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1616 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1615 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1617 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1616 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1618 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1614 : tensor<2x1280x8x8xf32>) outs(%1617 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1619 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1618 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1620 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1619, %1618 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1060 = tensor.pad %1620 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1621 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_260 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1622 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1060, %cst_259 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1621 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1623 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1553, %1622 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1624 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1623, %cst_4 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1061 = tensor.collapse_shape %1624 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1062 = tensor.expand_shape %collapsed_1061 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1625 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1626 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1625 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1627 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1626 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1628 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1062 : tensor<2x32x40x64xf16>) outs(%1627 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1629 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1628 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1630 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1631 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1629 : tensor<2x32x40x64xf64>) outs(%1630 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1632 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1631 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1633 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1629, %1632 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1634 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1633 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1635 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1636 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1634 : tensor<2x32x40x64xf64>) outs(%1635 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1637 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1636 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1638 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1637 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1639 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1640 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1628 : tensor<2x32x40x64xf32>) outs(%1639 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1641 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1640 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1642 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1638, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1643 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1642 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1644 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1062, %1641 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1645 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1644, %1643 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1063 = tensor.collapse_shape %1645 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1064 = tensor.expand_shape %collapsed_1063 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1065 = tensor.expand_shape %cst_261 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1646 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1064, %expanded_1065 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1066 = tensor.expand_shape %cst_262 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1647 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1646, %expanded_1066 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1648 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1649 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1648 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1650 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1649 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1651 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1647 : tensor<2x1280x8x8xf32>) outs(%1650 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1652 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1651 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1653 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1652, %1651 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1067 = tensor.pad %1653 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1654 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_264 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1655 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1067, %cst_263 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1654 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1656 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1657 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1656, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1658 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_265 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1659 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1660 = linalg.matmul ins(%1657, %1658 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1659 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1661 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_266, %1660 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1068 = tensor.expand_shape %1661 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1662 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1655, %expanded_1068 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1069 = tensor.collapse_shape %1662 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1070 = tensor.expand_shape %collapsed_1069 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1663 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1664 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1663 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1665 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1664 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1666 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1070 : tensor<2x32x40x64xf16>) outs(%1665 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1667 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1666 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1668 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1669 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1667 : tensor<2x32x40x64xf64>) outs(%1668 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1670 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1669 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1671 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1667, %1670 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1672 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1671 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1673 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1674 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1672 : tensor<2x32x40x64xf64>) outs(%1673 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1675 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1674 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1676 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1675 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1677 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1678 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1666 : tensor<2x32x40x64xf32>) outs(%1677 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1679 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1678 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1680 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1676, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1681 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1680 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1682 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1070, %1679 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1683 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1682, %1681 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1071 = tensor.collapse_shape %1683 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1072 = tensor.expand_shape %collapsed_1071 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1073 = tensor.expand_shape %cst_267 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1684 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1072, %expanded_1073 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1074 = tensor.expand_shape %cst_268 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1685 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1684, %expanded_1074 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1686 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1687 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1686 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1688 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1687 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1689 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1685 : tensor<2x1280x8x8xf32>) outs(%1688 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1690 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1689 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1691 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1690, %1689 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1075 = tensor.pad %1691 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1692 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_270 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1693 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1075, %cst_269 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1692 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1694 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1624, %1693 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1695 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1694, %cst_8 : tensor<2x1280x8x8xf16>, tensor<i64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: i64, %out: f16):
%4252 = arith.sitofp %in_1647 : i64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1076 = tensor.collapse_shape %1695 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1077 = tensor.expand_shape %collapsed_1076 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1696 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1697 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1696 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1698 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1697 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1699 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1077 : tensor<2x32x40x64xf16>) outs(%1698 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1700 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1699 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1701 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1702 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1700 : tensor<2x32x40x64xf64>) outs(%1701 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1703 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1702 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1704 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1700, %1703 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1705 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1704 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1706 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1707 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1705 : tensor<2x32x40x64xf64>) outs(%1706 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1708 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1707 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1709 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1708 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1710 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1711 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1699 : tensor<2x32x40x64xf32>) outs(%1710 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1712 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1711 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1713 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1709, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1714 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1713 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1715 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1077, %1712 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1716 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1715, %1714 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1078 = tensor.collapse_shape %1716 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1079 = tensor.expand_shape %collapsed_1078 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1080 = tensor.expand_shape %cst_271 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1717 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1079, %expanded_1080 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1081 = tensor.expand_shape %cst_272 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1718 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1717, %expanded_1081 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1719 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1720 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1719 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1721 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1720 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1722 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1718 : tensor<2x1280x8x8xf32>) outs(%1721 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1723 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_274 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1724 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1722, %cst_273 : tensor<2x1280x8x8xf16>, tensor<1280x1280x1x1xf16>) outs(%1723 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1725 = tensor.empty() : tensor<2x8x8x1280xf16>
%1726 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1724 : tensor<2x1280x8x8xf16>) outs(%1725 : tensor<2x8x8x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x8x1280xf16>
%collapsed_1082 = tensor.collapse_shape %1726 [[0], [1, 2], [3]] : tensor<2x8x8x1280xf16> into tensor<2x64x1280xf16>
%1727 = tensor.empty() : tensor<2x64x1xf16>
%1728 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1729 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_1082 : tensor<2x64x1280xf16>) outs(%1728 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1730 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1729 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1731 = tensor.empty() : tensor<2x64x1280xf16>
%1732 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1730 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1733 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1082, %1732 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1734 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1733 : tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1735 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1736 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1734 : tensor<2x64x1280xf16>) outs(%1735 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1737 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1736 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1738 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1737 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x64x1xf16>
%1739 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1738 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1740 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1739 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1741 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1733, %1740 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1742 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1741, %cst_275 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1743 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1742, %cst_276 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1744 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_277 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1083 = tensor.collapse_shape %1743 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%1745 = tensor.empty() : tensor<128x1280xf16>
%1746 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1747 = linalg.matmul ins(%collapsed_1083, %1744 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1746 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1748 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_278 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1749 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1750 = linalg.matmul ins(%collapsed_1083, %1748 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1749 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1751 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_279 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1752 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1753 = linalg.matmul ins(%collapsed_1083, %1751 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1752 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%expanded_1084 = tensor.expand_shape %1747 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%1754 = tensor.empty() : tensor<2x8x64x160xf16>
%1755 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1084 : tensor<2x64x8x160xf16>) outs(%1754 : tensor<2x8x64x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x64x160xf16>
%collapsed_1085 = tensor.collapse_shape %1755 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%expanded_1086 = tensor.expand_shape %1750 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%1756 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1086 : tensor<2x64x8x160xf16>) outs(%1754 : tensor<2x8x64x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x64x160xf16>
%collapsed_1087 = tensor.collapse_shape %1756 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%expanded_1088 = tensor.expand_shape %1753 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%1757 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1088 : tensor<2x64x8x160xf16>) outs(%1754 : tensor<2x8x64x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x64x160xf16>
%collapsed_1089 = tensor.collapse_shape %1757 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%1758 = tensor.empty() : tensor<16x160x64xf16>
%1759 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1087 : tensor<16x64x160xf16>) outs(%1758 : tensor<16x160x64xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x64xf16>
%1760 = tensor.empty() : tensor<16x64x64xf16>
%1761 = linalg.fill ins(%cst_695 : f16) outs(%1760 : tensor<16x64x64xf16>) -> tensor<16x64x64xf16>
%1762 = linalg.batch_matmul ins(%collapsed_1085, %1759 : tensor<16x64x160xf16>, tensor<16x160x64xf16>) outs(%1761 : tensor<16x64x64xf16>) -> tensor<16x64x64xf16>
%1763 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1762, %cst_0 : tensor<16x64x64xf16>, tensor<f64>) outs(%1760 : tensor<16x64x64xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x64x64xf16>
%1764 = tensor.empty() : tensor<16x64x1xf16>
%1765 = linalg.fill ins(%cst_697 : f16) outs(%1764 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%1766 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1763 : tensor<16x64x64xf16>) outs(%1765 : tensor<16x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x64x1xf16>
%1767 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1763, %1766 : tensor<16x64x64xf16>, tensor<16x64x1xf16>) outs(%1760 : tensor<16x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x64x64xf16>
%1768 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1767 : tensor<16x64x64xf16>) outs(%1760 : tensor<16x64x64xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x64x64xf16>
%1769 = linalg.fill ins(%cst_695 : f16) outs(%1764 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%1770 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1768 : tensor<16x64x64xf16>) outs(%1769 : tensor<16x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x64x1xf16>
%1771 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1768, %1770 : tensor<16x64x64xf16>, tensor<16x64x1xf16>) outs(%1760 : tensor<16x64x64xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x64x64xf16>
%1772 = tensor.empty() : tensor<16x64x160xf16>
%1773 = linalg.fill ins(%cst_695 : f16) outs(%1772 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%1774 = linalg.batch_matmul ins(%1771, %collapsed_1089 : tensor<16x64x64xf16>, tensor<16x64x160xf16>) outs(%1773 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%expanded_1090 = tensor.expand_shape %1774 [[0, 1], [2], [3]] : tensor<16x64x160xf16> into tensor<2x8x64x160xf16>
%1775 = tensor.empty() : tensor<2x64x8x160xf16>
%1776 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1090 : tensor<2x8x64x160xf16>) outs(%1775 : tensor<2x64x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x8x160xf16>
%1777 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_280 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1091 = tensor.collapse_shape %1776 [[0, 1], [2, 3]] : tensor<2x64x8x160xf16> into tensor<128x1280xf16>
%1778 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1779 = linalg.matmul ins(%collapsed_1091, %1777 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1778 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1780 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_281, %1779 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%1745 : tensor<128x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<128x1280xf16>
%expanded_1092 = tensor.expand_shape %1780 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%1781 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1092, %collapsed_1082 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1782 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1783 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1781 : tensor<2x64x1280xf16>) outs(%1782 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1784 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1783 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1785 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1784 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1786 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1781, %1785 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1787 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1786 : tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1788 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1789 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1787 : tensor<2x64x1280xf16>) outs(%1788 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1790 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1789 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1791 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1790 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x64x1xf16>
%1792 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1791 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1793 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1792 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1794 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1786, %1793 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1795 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1794, %cst_282 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1796 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1795, %cst_283 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1797 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_284 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1093 = tensor.collapse_shape %1796 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%1798 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1799 = linalg.matmul ins(%collapsed_1093, %1797 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1798 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1800 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_285 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1801 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1802 = linalg.matmul ins(%collapsed_766, %1800 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1801 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1803 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_286 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%1804 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1805 = linalg.matmul ins(%collapsed_766, %1803 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1804 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_1094 = tensor.expand_shape %1799 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%1806 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1094 : tensor<2x64x8x160xf16>) outs(%1754 : tensor<2x8x64x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x64x160xf16>
%collapsed_1095 = tensor.collapse_shape %1806 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%expanded_1096 = tensor.expand_shape %1802 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1807 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1096 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1097 = tensor.collapse_shape %1807 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_1098 = tensor.expand_shape %1805 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1808 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1098 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1099 = tensor.collapse_shape %1808 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1809 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1097 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%1810 = tensor.empty() : tensor<16x64x77xf16>
%1811 = linalg.fill ins(%cst_695 : f16) outs(%1810 : tensor<16x64x77xf16>) -> tensor<16x64x77xf16>
%1812 = linalg.batch_matmul ins(%collapsed_1095, %1809 : tensor<16x64x160xf16>, tensor<16x160x77xf16>) outs(%1811 : tensor<16x64x77xf16>) -> tensor<16x64x77xf16>
%1813 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1812, %cst_0 : tensor<16x64x77xf16>, tensor<f64>) outs(%1810 : tensor<16x64x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x64x77xf16>
%1814 = linalg.fill ins(%cst_697 : f16) outs(%1764 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%1815 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1813 : tensor<16x64x77xf16>) outs(%1814 : tensor<16x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x64x1xf16>
%1816 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1813, %1815 : tensor<16x64x77xf16>, tensor<16x64x1xf16>) outs(%1810 : tensor<16x64x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x64x77xf16>
%1817 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1816 : tensor<16x64x77xf16>) outs(%1810 : tensor<16x64x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x64x77xf16>
%1818 = linalg.fill ins(%cst_695 : f16) outs(%1764 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%1819 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1817 : tensor<16x64x77xf16>) outs(%1818 : tensor<16x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x64x1xf16>
%1820 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1817, %1819 : tensor<16x64x77xf16>, tensor<16x64x1xf16>) outs(%1810 : tensor<16x64x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x64x77xf16>
%1821 = linalg.fill ins(%cst_695 : f16) outs(%1772 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%1822 = linalg.batch_matmul ins(%1820, %collapsed_1099 : tensor<16x64x77xf16>, tensor<16x77x160xf16>) outs(%1821 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%expanded_1100 = tensor.expand_shape %1822 [[0, 1], [2], [3]] : tensor<16x64x160xf16> into tensor<2x8x64x160xf16>
%1823 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1100 : tensor<2x8x64x160xf16>) outs(%1775 : tensor<2x64x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x8x160xf16>
%1824 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_287 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1101 = tensor.collapse_shape %1823 [[0, 1], [2, 3]] : tensor<2x64x8x160xf16> into tensor<128x1280xf16>
%1825 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1826 = linalg.matmul ins(%collapsed_1101, %1824 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%1825 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1827 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_288, %1826 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%1745 : tensor<128x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<128x1280xf16>
%expanded_1102 = tensor.expand_shape %1827 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%1828 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1102, %1781 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1829 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1830 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1828 : tensor<2x64x1280xf16>) outs(%1829 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1831 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1830 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1832 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1831 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1833 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1828, %1832 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1834 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1833 : tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1835 = linalg.fill ins(%cst_695 : f16) outs(%1727 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%1836 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1834 : tensor<2x64x1280xf16>) outs(%1835 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1837 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1836 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1838 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1837 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x64x1xf16>
%1839 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1838 : tensor<2x64x1xf16>) outs(%1727 : tensor<2x64x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1xf16>
%1840 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1839 : tensor<2x64x1xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x64x1280xf16>
%1841 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1833, %1840 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1842 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1841, %cst_289 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1843 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1842, %cst_290 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%1844 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_291 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_1103 = tensor.collapse_shape %1843 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%1845 = tensor.empty() : tensor<128x10240xf16>
%1846 = linalg.fill ins(%cst_695 : f16) outs(%1845 : tensor<128x10240xf16>) -> tensor<128x10240xf16>
%1847 = linalg.matmul ins(%collapsed_1103, %1844 : tensor<128x1280xf16>, tensor<1280x10240xf16>) outs(%1846 : tensor<128x10240xf16>) -> tensor<128x10240xf16>
%1848 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_292, %1847 : tensor<10240xf16>, tensor<128x10240xf16>) outs(%1845 : tensor<128x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<128x10240xf16>
%expanded_1104 = tensor.expand_shape %1848 [[0, 1], [2]] : tensor<128x10240xf16> into tensor<2x64x10240xf16>
%extracted_slice_1105 = tensor.extract_slice %expanded_1104[0, 0, 0] [2, 64, 5120] [1, 1, 1] : tensor<2x64x10240xf16> to tensor<2x64x5120xf16>
%extracted_slice_1106 = tensor.extract_slice %expanded_1104[0, 0, 5120] [2, 64, 5120] [1, 1, 1] : tensor<2x64x10240xf16> to tensor<2x64x5120xf16>
%1849 = tensor.empty() : tensor<2x64x5120xf16>
%1850 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1106 : tensor<2x64x5120xf16>) outs(%1849 : tensor<2x64x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x64x5120xf16>
%1851 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1105, %1850 : tensor<2x64x5120xf16>, tensor<2x64x5120xf16>) outs(%1849 : tensor<2x64x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x5120xf16>
%1852 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_293 : tensor<1280x5120xf16>) outs(%1244 : tensor<5120x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<5120x1280xf16>
%collapsed_1107 = tensor.collapse_shape %1851 [[0, 1], [2]] : tensor<2x64x5120xf16> into tensor<128x5120xf16>
%1853 = linalg.fill ins(%cst_695 : f16) outs(%1745 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1854 = linalg.matmul ins(%collapsed_1107, %1852 : tensor<128x5120xf16>, tensor<5120x1280xf16>) outs(%1853 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%1855 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_294, %1854 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%1745 : tensor<128x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<128x1280xf16>
%expanded_1108 = tensor.expand_shape %1855 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%1856 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1108, %1828 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%1731 : tensor<2x64x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x64x1280xf16>
%expanded_1109 = tensor.expand_shape %1856 [[0], [1, 2], [3]] : tensor<2x64x1280xf16> into tensor<2x8x8x1280xf16>
%1857 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1109 : tensor<2x8x8x1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1858 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_296 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1859 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1857, %cst_295 : tensor<2x1280x8x8xf16>, tensor<1280x1280x1x1xf16>) outs(%1858 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1860 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1859, %1695 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1110 = tensor.collapse_shape %1860 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1111 = tensor.expand_shape %collapsed_1110 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1861 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1862 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1861 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1863 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1862 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1864 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1111 : tensor<2x32x40x64xf16>) outs(%1863 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1865 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1864 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1866 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1867 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1865 : tensor<2x32x40x64xf64>) outs(%1866 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1868 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1867 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1869 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1865, %1868 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1870 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1869 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1871 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1872 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1870 : tensor<2x32x40x64xf64>) outs(%1871 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1873 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1872 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1874 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1873 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1875 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1876 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1864 : tensor<2x32x40x64xf32>) outs(%1875 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1877 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1876 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1878 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1874, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1879 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1878 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1880 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1111, %1877 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1881 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1880, %1879 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1112 = tensor.collapse_shape %1881 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1113 = tensor.expand_shape %collapsed_1112 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1114 = tensor.expand_shape %cst_297 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1882 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1113, %expanded_1114 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1115 = tensor.expand_shape %cst_298 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1883 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1882, %expanded_1115 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1884 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1885 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1884 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1886 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1885 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1887 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1883 : tensor<2x1280x8x8xf32>) outs(%1886 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1888 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1887 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1889 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1888, %1887 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1116 = tensor.pad %1889 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1890 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_300 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1891 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1116, %cst_299 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1890 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1892 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1893 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1892, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1894 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_301 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1895 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1896 = linalg.matmul ins(%1893, %1894 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1895 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1897 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_302, %1896 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1117 = tensor.expand_shape %1897 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1898 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1891, %expanded_1117 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1118 = tensor.collapse_shape %1898 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1119 = tensor.expand_shape %collapsed_1118 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1899 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1900 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1899 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1901 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1900 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1902 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1119 : tensor<2x32x40x64xf16>) outs(%1901 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1903 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1902 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1904 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1905 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1903 : tensor<2x32x40x64xf64>) outs(%1904 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1906 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1905 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1907 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1903, %1906 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1908 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1907 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1909 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1910 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1908 : tensor<2x32x40x64xf64>) outs(%1909 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1911 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1910 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1912 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1911 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1913 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1914 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1902 : tensor<2x32x40x64xf32>) outs(%1913 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1915 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1914 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1916 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1912, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1917 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1916 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1918 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1119, %1915 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1919 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1918, %1917 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1120 = tensor.collapse_shape %1919 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1121 = tensor.expand_shape %collapsed_1120 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1122 = tensor.expand_shape %cst_303 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1920 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1121, %expanded_1122 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1123 = tensor.expand_shape %cst_304 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1921 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1920, %expanded_1123 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1922 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1923 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1922 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1924 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1923 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1925 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1921 : tensor<2x1280x8x8xf32>) outs(%1924 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1926 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1925 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%1927 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1926, %1925 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1124 = tensor.pad %1927 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1928 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_306 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1929 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1124, %cst_305 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1928 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1930 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1860, %1929 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%1931 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1930, %cst_8 : tensor<2x1280x8x8xf16>, tensor<i64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: i64, %out: f16):
%4252 = arith.sitofp %in_1647 : i64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%1932 = tensor.empty() : tensor<2x2560x8x8xf16>
%inserted_slice_1125 = tensor.insert_slice %1931 into %1932[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%inserted_slice_1126 = tensor.insert_slice %1624 into %inserted_slice_1125[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%collapsed_1127 = tensor.collapse_shape %inserted_slice_1126 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%expanded_1128 = tensor.expand_shape %collapsed_1127 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%1933 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1934 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1933 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1935 = tensor.empty() : tensor<2x32x80x64xf32>
%1936 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1934 : tensor<f32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x80x64xf32>
%1937 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1128 : tensor<2x32x80x64xf16>) outs(%1936 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%1938 = tensor.empty() : tensor<2x32x80x64xf64>
%1939 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1937 : tensor<2x32x80x64xf32>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%1940 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1941 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1939 : tensor<2x32x80x64xf64>) outs(%1940 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1942 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1941 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1943 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1939, %1942 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%1944 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1943 : tensor<2x32x80x64xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%1945 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1946 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1944 : tensor<2x32x80x64xf64>) outs(%1945 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1947 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1946 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1948 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1947 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1949 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1950 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1937 : tensor<2x32x80x64xf32>) outs(%1949 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1951 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1950 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_714 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1952 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1948, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1953 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1952 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1954 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1128, %1951 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x80x64xf32>
%1955 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1954, %1953 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%collapsed_1129 = tensor.collapse_shape %1955 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%expanded_1130 = tensor.expand_shape %collapsed_1129 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%expanded_1131 = tensor.expand_shape %cst_307 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%1956 = tensor.empty() : tensor<2x2560x8x8xf32>
%1957 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1130, %expanded_1131 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%expanded_1132 = tensor.expand_shape %cst_308 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%1958 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1957, %expanded_1132 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%1959 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1960 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1959 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1961 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1960 : tensor<f16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x2560x8x8xf16>
%1962 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1958 : tensor<2x2560x8x8xf32>) outs(%1961 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%1963 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1962 : tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x2560x8x8xf16>
%1964 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1963, %1962 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%padded_1133 = tensor.pad %1964 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%1965 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_310 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%1966 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1133, %cst_309 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%1965 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1967 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%1968 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%1967, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%1969 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_311 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%1970 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1971 = linalg.matmul ins(%1968, %1969 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1970 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1972 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_312, %1971 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1134 = tensor.expand_shape %1972 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1973 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1966, %expanded_1134 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1135 = tensor.collapse_shape %1973 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1136 = tensor.expand_shape %collapsed_1135 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1974 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1975 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1974 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%1976 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1975 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%1977 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1136 : tensor<2x32x40x64xf16>) outs(%1976 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%1978 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1977 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1979 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1980 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1978 : tensor<2x32x40x64xf64>) outs(%1979 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1981 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1980 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1982 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1978, %1981 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1983 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1982 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%1984 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1985 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1983 : tensor<2x32x40x64xf64>) outs(%1984 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1986 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1985 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%1987 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1986 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1988 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1989 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1977 : tensor<2x32x40x64xf32>) outs(%1988 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1990 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1989 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1991 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1987, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%1992 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1991 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%1993 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1136, %1990 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%1994 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1993, %1992 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1137 = tensor.collapse_shape %1994 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1138 = tensor.expand_shape %collapsed_1137 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1139 = tensor.expand_shape %cst_313 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1995 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1138, %expanded_1139 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1140 = tensor.expand_shape %cst_314 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1996 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1995, %expanded_1140 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%1997 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%1998 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%1997 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%1999 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1998 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2000 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1996 : tensor<2x1280x8x8xf32>) outs(%1999 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2001 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2000 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%2002 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2001, %2000 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1141 = tensor.pad %2002 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2003 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_316 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2004 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1141, %cst_315 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2003 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2005 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_318 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2006 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1126, %cst_317 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2005 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2007 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2006, %2004 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2008 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2007, %cst_4 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%inserted_slice_1142 = tensor.insert_slice %2008 into %1932[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%inserted_slice_1143 = tensor.insert_slice %1553 into %inserted_slice_1142[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%collapsed_1144 = tensor.collapse_shape %inserted_slice_1143 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%expanded_1145 = tensor.expand_shape %collapsed_1144 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%2009 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2010 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2009 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2011 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2010 : tensor<f32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x80x64xf32>
%2012 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1145 : tensor<2x32x80x64xf16>) outs(%2011 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%2013 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2012 : tensor<2x32x80x64xf32>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2014 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2015 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2013 : tensor<2x32x80x64xf64>) outs(%2014 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2016 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2015 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2017 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2013, %2016 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2018 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2017 : tensor<2x32x80x64xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2019 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2020 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2018 : tensor<2x32x80x64xf64>) outs(%2019 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2021 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2020 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2022 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2021 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2023 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2024 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2012 : tensor<2x32x80x64xf32>) outs(%2023 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2025 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2024 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_714 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2026 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2022, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2027 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2026 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2028 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1145, %2025 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x80x64xf32>
%2029 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2028, %2027 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%collapsed_1146 = tensor.collapse_shape %2029 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%expanded_1147 = tensor.expand_shape %collapsed_1146 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%expanded_1148 = tensor.expand_shape %cst_319 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2030 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1147, %expanded_1148 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%expanded_1149 = tensor.expand_shape %cst_320 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2031 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2030, %expanded_1149 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%2032 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2033 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2032 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2034 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2033 : tensor<f16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x2560x8x8xf16>
%2035 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2031 : tensor<2x2560x8x8xf32>) outs(%2034 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%2036 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2035 : tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x2560x8x8xf16>
%2037 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2036, %2035 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%padded_1150 = tensor.pad %2037 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%2038 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_322 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2039 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1150, %cst_321 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%2038 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2040 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%2041 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%2040, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%2042 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_323 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2043 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2044 = linalg.matmul ins(%2041, %2042 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2043 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2045 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_324, %2044 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1151 = tensor.expand_shape %2045 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2046 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2039, %expanded_1151 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1152 = tensor.collapse_shape %2046 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1153 = tensor.expand_shape %collapsed_1152 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2047 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2048 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2047 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2049 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2048 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%2050 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1153 : tensor<2x32x40x64xf16>) outs(%2049 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%2051 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2050 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2052 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2053 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2051 : tensor<2x32x40x64xf64>) outs(%2052 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2054 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2053 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2055 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2051, %2054 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2056 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2055 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2057 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2058 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2056 : tensor<2x32x40x64xf64>) outs(%2057 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2059 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2058 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2060 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2059 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2061 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2062 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2050 : tensor<2x32x40x64xf32>) outs(%2061 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2063 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2062 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2064 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2060, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2065 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2064 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2066 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1153, %2063 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%2067 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2066, %2065 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1154 = tensor.collapse_shape %2067 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1155 = tensor.expand_shape %collapsed_1154 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1156 = tensor.expand_shape %cst_325 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2068 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1155, %expanded_1156 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1157 = tensor.expand_shape %cst_326 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2069 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2068, %expanded_1157 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%2070 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2071 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2070 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2072 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2071 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2073 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2069 : tensor<2x1280x8x8xf32>) outs(%2072 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2074 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2073 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%2075 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2074, %2073 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1158 = tensor.pad %2075 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2076 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_328 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2077 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1158, %cst_327 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2076 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2078 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_330 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2079 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1143, %cst_329 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2078 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2080 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2079, %2077 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2081 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2080, %cst_4 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%inserted_slice_1159 = tensor.insert_slice %2081 into %1932[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%inserted_slice_1160 = tensor.insert_slice %1479 into %inserted_slice_1159[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%collapsed_1161 = tensor.collapse_shape %inserted_slice_1160 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%expanded_1162 = tensor.expand_shape %collapsed_1161 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%2082 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2083 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2082 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2084 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2083 : tensor<f32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x80x64xf32>
%2085 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1162 : tensor<2x32x80x64xf16>) outs(%2084 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%2086 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2085 : tensor<2x32x80x64xf32>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2087 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2088 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2086 : tensor<2x32x80x64xf64>) outs(%2087 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2089 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2088 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2090 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2086, %2089 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2091 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2090 : tensor<2x32x80x64xf64>) outs(%1938 : tensor<2x32x80x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x64xf64>
%2092 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2093 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2091 : tensor<2x32x80x64xf64>) outs(%2092 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2094 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2093 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_713 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2095 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2094 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2096 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2097 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2085 : tensor<2x32x80x64xf32>) outs(%2096 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2098 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2097 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_714 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2099 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2095, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2100 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2099 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2101 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1162, %2098 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x80x64xf32>
%2102 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2101, %2100 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%1935 : tensor<2x32x80x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x64xf32>
%collapsed_1163 = tensor.collapse_shape %2102 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%expanded_1164 = tensor.expand_shape %collapsed_1163 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%expanded_1165 = tensor.expand_shape %cst_331 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2103 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1164, %expanded_1165 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%expanded_1166 = tensor.expand_shape %cst_332 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2104 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2103, %expanded_1166 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%1956 : tensor<2x2560x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x8x8xf32>
%2105 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2106 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2105 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2107 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2106 : tensor<f16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x2560x8x8xf16>
%2108 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2104 : tensor<2x2560x8x8xf32>) outs(%2107 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%2109 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2108 : tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x2560x8x8xf16>
%2110 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2109, %2108 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%1932 : tensor<2x2560x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x2560x8x8xf16>
%padded_1167 = tensor.pad %2110 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%2111 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_334 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2112 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1167, %cst_333 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%2111 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2113 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%2114 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%2113, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%2115 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_335 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2116 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2117 = linalg.matmul ins(%2114, %2115 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2116 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2118 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_336, %2117 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1168 = tensor.expand_shape %2118 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2119 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2112, %expanded_1168 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%collapsed_1169 = tensor.collapse_shape %2119 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%expanded_1170 = tensor.expand_shape %collapsed_1169 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2120 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2121 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2120 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2122 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2121 : tensor<f32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x64xf32>
%2123 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1170 : tensor<2x32x40x64xf16>) outs(%2122 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%2124 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2123 : tensor<2x32x40x64xf32>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2125 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2126 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2124 : tensor<2x32x40x64xf64>) outs(%2125 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2127 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2126 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2128 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2124, %2127 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2129 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2128 : tensor<2x32x40x64xf64>) outs(%1485 : tensor<2x32x40x64xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x64xf64>
%2130 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2131 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2129 : tensor<2x32x40x64xf64>) outs(%2130 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2132 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2131 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_716 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2133 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2132 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2134 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2135 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2123 : tensor<2x32x40x64xf32>) outs(%2134 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2136 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2135 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_717 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2137 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2133, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2138 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2137 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2139 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1170, %2136 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x64xf32>
%2140 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2139, %2138 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1482 : tensor<2x32x40x64xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x64xf32>
%collapsed_1171 = tensor.collapse_shape %2140 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%expanded_1172 = tensor.expand_shape %collapsed_1171 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%expanded_1173 = tensor.expand_shape %cst_337 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2141 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1172, %expanded_1173 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%expanded_1174 = tensor.expand_shape %cst_338 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2142 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2141, %expanded_1174 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1503 : tensor<2x1280x8x8xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x8x8xf32>
%2143 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2144 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2143 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2145 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2144 : tensor<f16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2146 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2142 : tensor<2x1280x8x8xf32>) outs(%2145 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2147 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2146 : tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x8x8xf16>
%2148 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2147, %2146 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%padded_1175 = tensor.pad %2148 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2149 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_340 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2150 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1175, %cst_339 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2149 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2151 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_342 : tensor<1280xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x8x8xf16>
%2152 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1160, %cst_341 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2151 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2153 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2152, %2150 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x8x8xf16>
%2154 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2153, %cst_4 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1477 : tensor<2x1280x8x8xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x8x8xf16>
%2155 = linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%out: f16):
%4252 = linalg.index 0 : index
%4253 = linalg.index 1 : index
%4254 = linalg.index 2 : index
%4255 = linalg.index 3 : index
%4256 = arith.floordivsi %4254, %c2 : index
%4257 = arith.floordivsi %4255, %c2 : index
%extracted = tensor.extract %2154[%4252, %4253, %4256, %4257] : tensor<2x1280x8x8xf16>
linalg.yield %extracted : f16
} -> tensor<2x1280x16x16xf16>
%padded_1176 = tensor.pad %2155 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2156 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_344 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2157 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1176, %cst_343 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2156 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2158 = tensor.empty() : tensor<2x2560x16x16xf16>
%inserted_slice_1177 = tensor.insert_slice %2157 into %2158[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%inserted_slice_1178 = tensor.insert_slice %1476 into %inserted_slice_1177[0, 1280, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%collapsed_1179 = tensor.collapse_shape %inserted_slice_1178 [[0], [1], [2, 3]] : tensor<2x2560x16x16xf16> into tensor<2x2560x256xf16>
%expanded_1180 = tensor.expand_shape %collapsed_1179 [[0], [1, 2], [3]] : tensor<2x2560x256xf16> into tensor<2x32x80x256xf16>
%2159 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2160 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2159 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2161 = tensor.empty() : tensor<2x32x80x256xf32>
%2162 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2160 : tensor<f32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x80x256xf32>
%2163 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1180 : tensor<2x32x80x256xf16>) outs(%2162 : tensor<2x32x80x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x256xf32>
%2164 = tensor.empty() : tensor<2x32x80x256xf64>
%2165 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2163 : tensor<2x32x80x256xf32>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2166 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2167 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2165 : tensor<2x32x80x256xf64>) outs(%2166 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2168 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2167 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2169 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2165, %2168 : tensor<2x32x80x256xf64>, tensor<2x32x1x1xf64>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2170 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2169 : tensor<2x32x80x256xf64>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2171 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2172 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2170 : tensor<2x32x80x256xf64>) outs(%2171 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2173 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2172 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2174 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2173 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2175 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2176 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2163 : tensor<2x32x80x256xf32>) outs(%2175 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2177 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2176 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2178 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2174, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2179 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2178 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2180 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1180, %2177 : tensor<2x32x80x256xf16>, tensor<2x32x1x1xf32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x80x256xf32>
%2181 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2180, %2179 : tensor<2x32x80x256xf32>, tensor<2x32x1x1xf32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x256xf32>
%collapsed_1181 = tensor.collapse_shape %2181 [[0], [1, 2], [3]] : tensor<2x32x80x256xf32> into tensor<2x2560x256xf32>
%expanded_1182 = tensor.expand_shape %collapsed_1181 [[0], [1], [2, 3]] : tensor<2x2560x256xf32> into tensor<2x2560x16x16xf32>
%expanded_1183 = tensor.expand_shape %cst_345 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2182 = tensor.empty() : tensor<2x2560x16x16xf32>
%2183 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1182, %expanded_1183 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2182 : tensor<2x2560x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x16x16xf32>
%expanded_1184 = tensor.expand_shape %cst_346 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2184 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2183, %expanded_1184 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2182 : tensor<2x2560x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x16x16xf32>
%2185 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2186 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2185 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2187 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2186 : tensor<f16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x2560x16x16xf16>
%2188 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2184 : tensor<2x2560x16x16xf32>) outs(%2187 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x2560x16x16xf16>
%2189 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2188 : tensor<2x2560x16x16xf16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x2560x16x16xf16>
%2190 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2189, %2188 : tensor<2x2560x16x16xf16>, tensor<2x2560x16x16xf16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x2560x16x16xf16>
%padded_1185 = tensor.pad %2190 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x2560x16x16xf16> to tensor<2x2560x18x18xf16>
%2191 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_348 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2192 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1185, %cst_347 : tensor<2x2560x18x18xf16>, tensor<1280x2560x3x3xf16>) outs(%2191 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2193 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%2194 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%2193, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%2195 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_349 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2196 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2197 = linalg.matmul ins(%2194, %2195 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2196 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2198 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_350, %2197 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1186 = tensor.expand_shape %2198 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2199 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2192, %expanded_1186 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1187 = tensor.collapse_shape %2199 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1188 = tensor.expand_shape %collapsed_1187 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2200 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2201 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2200 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2202 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2201 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2203 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1188 : tensor<2x32x40x256xf16>) outs(%2202 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2204 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2203 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2205 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2206 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2204 : tensor<2x32x40x256xf64>) outs(%2205 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2207 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2206 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2208 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2204, %2207 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2209 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2208 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2210 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2211 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2209 : tensor<2x32x40x256xf64>) outs(%2210 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2212 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2211 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2213 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2212 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2214 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2215 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2203 : tensor<2x32x40x256xf32>) outs(%2214 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2216 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2215 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2217 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2213, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2218 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2217 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2219 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1188, %2216 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2220 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2219, %2218 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1189 = tensor.collapse_shape %2220 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1190 = tensor.expand_shape %collapsed_1189 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1191 = tensor.expand_shape %cst_351 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2221 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1190, %expanded_1191 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1192 = tensor.expand_shape %cst_352 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2222 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2221, %expanded_1192 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2223 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2224 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2223 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2225 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2224 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2226 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2222 : tensor<2x1280x16x16xf32>) outs(%2225 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2227 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2226 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%2228 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2227, %2226 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_1193 = tensor.pad %2228 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2229 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_354 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2230 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1193, %cst_353 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2229 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2231 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_356 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2232 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1178, %cst_355 : tensor<2x2560x16x16xf16>, tensor<1280x2560x1x1xf16>) outs(%2231 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2233 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2232, %2230 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2234 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2233, %cst_4 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1194 = tensor.collapse_shape %2234 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1195 = tensor.expand_shape %collapsed_1194 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2235 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2236 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2235 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2237 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2236 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2238 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1195 : tensor<2x32x40x256xf16>) outs(%2237 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2239 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2238 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2240 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2241 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2239 : tensor<2x32x40x256xf64>) outs(%2240 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2242 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2241 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2243 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2239, %2242 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2244 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2243 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2245 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2246 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2244 : tensor<2x32x40x256xf64>) outs(%2245 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2247 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2246 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2248 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2247 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2249 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2250 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2238 : tensor<2x32x40x256xf32>) outs(%2249 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2251 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2250 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2252 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2248, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2253 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2252 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2254 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1195, %2251 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2255 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2254, %2253 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1196 = tensor.collapse_shape %2255 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1197 = tensor.expand_shape %collapsed_1196 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1198 = tensor.expand_shape %cst_357 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2256 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1197, %expanded_1198 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1199 = tensor.expand_shape %cst_358 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2257 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2256, %expanded_1199 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2258 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2259 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2258 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2260 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2259 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2261 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2257 : tensor<2x1280x16x16xf32>) outs(%2260 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2262 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_360 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2263 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2261, %cst_359 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2262 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2264 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2263 : tensor<2x1280x16x16xf16>) outs(%1112 : tensor<2x16x16x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x16x16x1280xf16>
%collapsed_1200 = tensor.collapse_shape %2264 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%2265 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2266 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_1200 : tensor<2x256x1280xf16>) outs(%2265 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2267 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2266 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2268 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2267 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2269 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1200, %2268 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2270 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2269 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2271 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2272 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2270 : tensor<2x256x1280xf16>) outs(%2271 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2273 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2272 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2274 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2273 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2275 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2274 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2276 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2275 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2277 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2269, %2276 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2278 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2277, %cst_361 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2279 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2278, %cst_362 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2280 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_363 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1201 = tensor.collapse_shape %2279 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2281 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2282 = linalg.matmul ins(%collapsed_1201, %2280 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2281 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2283 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_364 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2284 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2285 = linalg.matmul ins(%collapsed_1201, %2283 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2284 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2286 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_365 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2287 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2288 = linalg.matmul ins(%collapsed_1201, %2286 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2287 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%expanded_1202 = tensor.expand_shape %2282 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2289 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1202 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1203 = tensor.collapse_shape %2289 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1204 = tensor.expand_shape %2285 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2290 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1204 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1205 = tensor.collapse_shape %2290 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1206 = tensor.expand_shape %2288 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2291 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1206 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1207 = tensor.collapse_shape %2291 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2292 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1205 : tensor<16x256x160xf16>) outs(%1145 : tensor<16x160x256xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x256xf16>
%2293 = linalg.fill ins(%cst_695 : f16) outs(%1147 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2294 = linalg.batch_matmul ins(%collapsed_1203, %2292 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%2293 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2295 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2294, %cst_0 : tensor<16x256x256xf16>, tensor<f64>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x256xf16>
%2296 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2297 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2295 : tensor<16x256x256xf16>) outs(%2296 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2298 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2295, %2297 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2299 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2298 : tensor<16x256x256xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2300 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2301 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2299 : tensor<16x256x256xf16>) outs(%2300 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2302 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2299, %2301 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2303 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2304 = linalg.batch_matmul ins(%2302, %collapsed_1207 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%2303 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1208 = tensor.expand_shape %2304 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2305 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1208 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2306 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_366 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1209 = tensor.collapse_shape %2305 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2307 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2308 = linalg.matmul ins(%collapsed_1209, %2306 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2307 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2309 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_367, %2308 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1210 = tensor.expand_shape %2309 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2310 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1210, %collapsed_1200 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2311 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2312 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2310 : tensor<2x256x1280xf16>) outs(%2311 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2313 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2312 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2314 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2313 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2315 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2310, %2314 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2316 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2315 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2317 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2318 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2316 : tensor<2x256x1280xf16>) outs(%2317 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2319 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2318 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2320 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2319 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2321 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2320 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2322 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2321 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2323 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2315, %2322 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2324 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2323, %cst_368 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2325 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2324, %cst_369 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2326 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_370 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1211 = tensor.collapse_shape %2325 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2327 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2328 = linalg.matmul ins(%collapsed_1211, %2326 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2327 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2329 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_371 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2330 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2331 = linalg.matmul ins(%collapsed_766, %2329 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2330 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2332 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_372 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2333 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2334 = linalg.matmul ins(%collapsed_766, %2332 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2333 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_1212 = tensor.expand_shape %2328 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2335 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1212 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1213 = tensor.collapse_shape %2335 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1214 = tensor.expand_shape %2331 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2336 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1214 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1215 = tensor.collapse_shape %2336 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_1216 = tensor.expand_shape %2334 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2337 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1216 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1217 = tensor.collapse_shape %2337 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2338 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1215 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%2339 = linalg.fill ins(%cst_695 : f16) outs(%1201 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2340 = linalg.batch_matmul ins(%collapsed_1213, %2338 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%2339 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2341 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2340, %cst_0 : tensor<16x256x77xf16>, tensor<f64>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x77xf16>
%2342 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2343 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2341 : tensor<16x256x77xf16>) outs(%2342 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2344 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2341, %2343 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2345 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2344 : tensor<16x256x77xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2346 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2347 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2345 : tensor<16x256x77xf16>) outs(%2346 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2348 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2345, %2347 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2349 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2350 = linalg.batch_matmul ins(%2348, %collapsed_1217 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%2349 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1218 = tensor.expand_shape %2350 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2351 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1218 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2352 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_373 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1219 = tensor.collapse_shape %2351 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2353 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2354 = linalg.matmul ins(%collapsed_1219, %2352 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2353 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2355 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_374, %2354 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1220 = tensor.expand_shape %2355 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2356 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1220, %2310 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2357 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2358 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2356 : tensor<2x256x1280xf16>) outs(%2357 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2359 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2358 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2360 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2359 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2361 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2356, %2360 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2362 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2361 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2363 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2364 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2362 : tensor<2x256x1280xf16>) outs(%2363 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2365 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2364 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2366 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2365 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2367 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2366 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2368 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2367 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2369 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2361, %2368 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2370 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2369, %cst_375 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2371 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2370, %cst_376 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2372 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_377 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_1221 = tensor.collapse_shape %2371 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2373 = linalg.fill ins(%cst_695 : f16) outs(%1237 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2374 = linalg.matmul ins(%collapsed_1221, %2372 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%2373 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2375 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_378, %2374 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1237 : tensor<512x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x10240xf16>
%expanded_1222 = tensor.expand_shape %2375 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%extracted_slice_1223 = tensor.extract_slice %expanded_1222[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%extracted_slice_1224 = tensor.extract_slice %expanded_1222[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%2376 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1224 : tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x256x5120xf16>
%2377 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1223, %2376 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x5120xf16>
%2378 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_379 : tensor<1280x5120xf16>) outs(%1244 : tensor<5120x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<5120x1280xf16>
%collapsed_1225 = tensor.collapse_shape %2377 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%2379 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2380 = linalg.matmul ins(%collapsed_1225, %2378 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%2379 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2381 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_380, %2380 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1226 = tensor.expand_shape %2381 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2382 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1226, %2356 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%expanded_1227 = tensor.expand_shape %2382 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%2383 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1227 : tensor<2x16x16x1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2384 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_382 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2385 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2383, %cst_381 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2384 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2386 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2385, %2234 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%inserted_slice_1228 = tensor.insert_slice %2386 into %2158[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%inserted_slice_1229 = tensor.insert_slice %1253 into %inserted_slice_1228[0, 1280, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%collapsed_1230 = tensor.collapse_shape %inserted_slice_1229 [[0], [1], [2, 3]] : tensor<2x2560x16x16xf16> into tensor<2x2560x256xf16>
%expanded_1231 = tensor.expand_shape %collapsed_1230 [[0], [1, 2], [3]] : tensor<2x2560x256xf16> into tensor<2x32x80x256xf16>
%2387 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2388 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2387 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2389 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2388 : tensor<f32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x80x256xf32>
%2390 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1231 : tensor<2x32x80x256xf16>) outs(%2389 : tensor<2x32x80x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x256xf32>
%2391 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2390 : tensor<2x32x80x256xf32>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2392 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2393 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2391 : tensor<2x32x80x256xf64>) outs(%2392 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2394 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2393 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2395 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2391, %2394 : tensor<2x32x80x256xf64>, tensor<2x32x1x1xf64>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2396 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2395 : tensor<2x32x80x256xf64>) outs(%2164 : tensor<2x32x80x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x80x256xf64>
%2397 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2398 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2396 : tensor<2x32x80x256xf64>) outs(%2397 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2399 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2398 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_710 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2400 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2399 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2401 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2402 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2390 : tensor<2x32x80x256xf32>) outs(%2401 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2403 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2402 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_711 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2404 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2400, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2405 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2404 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2406 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1231, %2403 : tensor<2x32x80x256xf16>, tensor<2x32x1x1xf32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x80x256xf32>
%2407 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2406, %2405 : tensor<2x32x80x256xf32>, tensor<2x32x1x1xf32>) outs(%2161 : tensor<2x32x80x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x80x256xf32>
%collapsed_1232 = tensor.collapse_shape %2407 [[0], [1, 2], [3]] : tensor<2x32x80x256xf32> into tensor<2x2560x256xf32>
%expanded_1233 = tensor.expand_shape %collapsed_1232 [[0], [1], [2, 3]] : tensor<2x2560x256xf32> into tensor<2x2560x16x16xf32>
%expanded_1234 = tensor.expand_shape %cst_383 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2408 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1233, %expanded_1234 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2182 : tensor<2x2560x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x16x16xf32>
%expanded_1235 = tensor.expand_shape %cst_384 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2409 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2408, %expanded_1235 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2182 : tensor<2x2560x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x2560x16x16xf32>
%2410 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2411 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2410 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2412 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2411 : tensor<f16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x2560x16x16xf16>
%2413 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2409 : tensor<2x2560x16x16xf32>) outs(%2412 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x2560x16x16xf16>
%2414 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2413 : tensor<2x2560x16x16xf16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x2560x16x16xf16>
%2415 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2414, %2413 : tensor<2x2560x16x16xf16>, tensor<2x2560x16x16xf16>) outs(%2158 : tensor<2x2560x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x2560x16x16xf16>
%padded_1236 = tensor.pad %2415 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x2560x16x16xf16> to tensor<2x2560x18x18xf16>
%2416 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_386 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2417 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1236, %cst_385 : tensor<2x2560x18x18xf16>, tensor<1280x2560x3x3xf16>) outs(%2416 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2418 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%2419 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%2418, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%2420 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_387 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2421 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2422 = linalg.matmul ins(%2419, %2420 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2421 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2423 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_388, %2422 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1237 = tensor.expand_shape %2423 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2424 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2417, %expanded_1237 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1238 = tensor.collapse_shape %2424 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1239 = tensor.expand_shape %collapsed_1238 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2425 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2426 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2425 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2427 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2426 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2428 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1239 : tensor<2x32x40x256xf16>) outs(%2427 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2429 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2428 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2430 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2431 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2429 : tensor<2x32x40x256xf64>) outs(%2430 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2432 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2431 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2433 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2429, %2432 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2434 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2433 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2435 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2436 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2434 : tensor<2x32x40x256xf64>) outs(%2435 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2437 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2436 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2438 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2437 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2439 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2440 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2428 : tensor<2x32x40x256xf32>) outs(%2439 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2441 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2440 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2442 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2438, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2443 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2442 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2444 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1239, %2441 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2445 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2444, %2443 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1240 = tensor.collapse_shape %2445 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1241 = tensor.expand_shape %collapsed_1240 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1242 = tensor.expand_shape %cst_389 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2446 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1241, %expanded_1242 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1243 = tensor.expand_shape %cst_390 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2447 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2446, %expanded_1243 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2448 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2449 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2448 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2450 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2449 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2451 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2447 : tensor<2x1280x16x16xf32>) outs(%2450 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2452 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2451 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%2453 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2452, %2451 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_1244 = tensor.pad %2453 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2454 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_392 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2455 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1244, %cst_391 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2454 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2456 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_394 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2457 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1229, %cst_393 : tensor<2x2560x16x16xf16>, tensor<1280x2560x1x1xf16>) outs(%2456 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2458 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2457, %2455 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2459 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2458, %cst_4 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1245 = tensor.collapse_shape %2459 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1246 = tensor.expand_shape %collapsed_1245 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2460 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2461 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2460 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2462 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2461 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2463 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1246 : tensor<2x32x40x256xf16>) outs(%2462 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2464 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2463 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2465 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2466 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2464 : tensor<2x32x40x256xf64>) outs(%2465 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2467 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2466 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2468 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2464, %2467 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2469 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2468 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2470 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2471 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2469 : tensor<2x32x40x256xf64>) outs(%2470 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2472 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2471 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2473 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2472 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2474 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2475 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2463 : tensor<2x32x40x256xf32>) outs(%2474 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2476 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2475 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2477 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2473, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2478 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2477 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2479 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1246, %2476 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2480 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2479, %2478 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1247 = tensor.collapse_shape %2480 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1248 = tensor.expand_shape %collapsed_1247 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1249 = tensor.expand_shape %cst_395 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2481 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1248, %expanded_1249 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1250 = tensor.expand_shape %cst_396 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2482 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2481, %expanded_1250 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2483 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2484 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2483 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2485 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2484 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2486 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2482 : tensor<2x1280x16x16xf32>) outs(%2485 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2487 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_398 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2488 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2486, %cst_397 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2487 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2489 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2488 : tensor<2x1280x16x16xf16>) outs(%1112 : tensor<2x16x16x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x16x16x1280xf16>
%collapsed_1251 = tensor.collapse_shape %2489 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%2490 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2491 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_1251 : tensor<2x256x1280xf16>) outs(%2490 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2492 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2491 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2493 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2492 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2494 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1251, %2493 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2495 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2494 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2496 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2497 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2495 : tensor<2x256x1280xf16>) outs(%2496 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2498 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2497 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2499 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2498 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2500 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2499 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2501 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2500 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2502 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2494, %2501 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2503 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2502, %cst_399 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2504 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2503, %cst_400 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2505 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_401 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1252 = tensor.collapse_shape %2504 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2506 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2507 = linalg.matmul ins(%collapsed_1252, %2505 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2506 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2508 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_402 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2509 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2510 = linalg.matmul ins(%collapsed_1252, %2508 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2509 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2511 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_403 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2512 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2513 = linalg.matmul ins(%collapsed_1252, %2511 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2512 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%expanded_1253 = tensor.expand_shape %2507 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2514 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1253 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1254 = tensor.collapse_shape %2514 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1255 = tensor.expand_shape %2510 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2515 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1255 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1256 = tensor.collapse_shape %2515 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1257 = tensor.expand_shape %2513 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2516 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1257 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1258 = tensor.collapse_shape %2516 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2517 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1256 : tensor<16x256x160xf16>) outs(%1145 : tensor<16x160x256xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x256xf16>
%2518 = linalg.fill ins(%cst_695 : f16) outs(%1147 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2519 = linalg.batch_matmul ins(%collapsed_1254, %2517 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%2518 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2520 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2519, %cst_0 : tensor<16x256x256xf16>, tensor<f64>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x256xf16>
%2521 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2522 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2520 : tensor<16x256x256xf16>) outs(%2521 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2523 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2520, %2522 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2524 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2523 : tensor<16x256x256xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2525 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2526 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2524 : tensor<16x256x256xf16>) outs(%2525 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2527 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2524, %2526 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2528 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2529 = linalg.batch_matmul ins(%2527, %collapsed_1258 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%2528 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1259 = tensor.expand_shape %2529 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2530 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1259 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2531 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_404 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1260 = tensor.collapse_shape %2530 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2532 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2533 = linalg.matmul ins(%collapsed_1260, %2531 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2532 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2534 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_405, %2533 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1261 = tensor.expand_shape %2534 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2535 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1261, %collapsed_1251 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2536 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2537 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2535 : tensor<2x256x1280xf16>) outs(%2536 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2538 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2537 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2539 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2538 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2540 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2535, %2539 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2541 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2540 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2542 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2543 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2541 : tensor<2x256x1280xf16>) outs(%2542 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2544 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2543 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2545 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2544 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2546 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2545 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2547 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2546 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2548 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2540, %2547 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2549 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2548, %cst_406 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2550 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2549, %cst_407 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2551 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_408 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1262 = tensor.collapse_shape %2550 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2552 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2553 = linalg.matmul ins(%collapsed_1262, %2551 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2552 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2554 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_409 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2555 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2556 = linalg.matmul ins(%collapsed_766, %2554 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2555 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2557 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_410 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2558 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2559 = linalg.matmul ins(%collapsed_766, %2557 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2558 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_1263 = tensor.expand_shape %2553 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2560 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1263 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1264 = tensor.collapse_shape %2560 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1265 = tensor.expand_shape %2556 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2561 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1265 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1266 = tensor.collapse_shape %2561 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_1267 = tensor.expand_shape %2559 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2562 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1267 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1268 = tensor.collapse_shape %2562 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2563 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1266 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%2564 = linalg.fill ins(%cst_695 : f16) outs(%1201 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2565 = linalg.batch_matmul ins(%collapsed_1264, %2563 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%2564 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2566 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2565, %cst_0 : tensor<16x256x77xf16>, tensor<f64>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x77xf16>
%2567 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2568 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2566 : tensor<16x256x77xf16>) outs(%2567 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2569 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2566, %2568 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2570 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2569 : tensor<16x256x77xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2571 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2572 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2570 : tensor<16x256x77xf16>) outs(%2571 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2573 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2570, %2572 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2574 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2575 = linalg.batch_matmul ins(%2573, %collapsed_1268 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%2574 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1269 = tensor.expand_shape %2575 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2576 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1269 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2577 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_411 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1270 = tensor.collapse_shape %2576 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2578 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2579 = linalg.matmul ins(%collapsed_1270, %2577 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2578 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2580 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_412, %2579 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1271 = tensor.expand_shape %2580 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2581 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1271, %2535 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2582 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2583 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2581 : tensor<2x256x1280xf16>) outs(%2582 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2584 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2583 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2585 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2584 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2586 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2581, %2585 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2587 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2586 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2588 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2589 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2587 : tensor<2x256x1280xf16>) outs(%2588 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2590 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2589 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2591 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2590 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2592 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2591 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2593 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2592 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2594 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2586, %2593 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2595 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2594, %cst_413 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2596 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2595, %cst_414 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2597 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_415 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_1272 = tensor.collapse_shape %2596 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2598 = linalg.fill ins(%cst_695 : f16) outs(%1237 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2599 = linalg.matmul ins(%collapsed_1272, %2597 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%2598 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2600 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_416, %2599 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1237 : tensor<512x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x10240xf16>
%expanded_1273 = tensor.expand_shape %2600 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%extracted_slice_1274 = tensor.extract_slice %expanded_1273[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%extracted_slice_1275 = tensor.extract_slice %expanded_1273[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%2601 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1275 : tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x256x5120xf16>
%2602 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1274, %2601 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x5120xf16>
%2603 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_417 : tensor<1280x5120xf16>) outs(%1244 : tensor<5120x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<5120x1280xf16>
%collapsed_1276 = tensor.collapse_shape %2602 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%2604 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2605 = linalg.matmul ins(%collapsed_1276, %2603 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%2604 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2606 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_418, %2605 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1277 = tensor.expand_shape %2606 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2607 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1277, %2581 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%expanded_1278 = tensor.expand_shape %2607 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%2608 = linalg.generic {indexing_maps = [#map1, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1278 : tensor<2x16x16x1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2609 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_420 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2610 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2608, %cst_419 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2609 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2611 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2610, %2459 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2612 = tensor.empty() : tensor<2x1920x16x16xf16>
%inserted_slice_1279 = tensor.insert_slice %2611 into %2612[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x1920x16x16xf16>
%inserted_slice_1280 = tensor.insert_slice %1002 into %inserted_slice_1279[0, 1280, 0, 0] [2, 640, 16, 16] [1, 1, 1, 1] : tensor<2x640x16x16xf16> into tensor<2x1920x16x16xf16>
%collapsed_1281 = tensor.collapse_shape %inserted_slice_1280 [[0], [1], [2, 3]] : tensor<2x1920x16x16xf16> into tensor<2x1920x256xf16>
%expanded_1282 = tensor.expand_shape %collapsed_1281 [[0], [1, 2], [3]] : tensor<2x1920x256xf16> into tensor<2x32x60x256xf16>
%2613 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2614 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2613 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2615 = tensor.empty() : tensor<2x32x60x256xf32>
%2616 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2614 : tensor<f32>) outs(%2615 : tensor<2x32x60x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x60x256xf32>
%2617 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1282 : tensor<2x32x60x256xf16>) outs(%2616 : tensor<2x32x60x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x60x256xf32>
%2618 = tensor.empty() : tensor<2x32x60x256xf64>
%2619 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2617 : tensor<2x32x60x256xf32>) outs(%2618 : tensor<2x32x60x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x60x256xf64>
%2620 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2621 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2619 : tensor<2x32x60x256xf64>) outs(%2620 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2622 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2621 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_718 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2623 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2619, %2622 : tensor<2x32x60x256xf64>, tensor<2x32x1x1xf64>) outs(%2618 : tensor<2x32x60x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x60x256xf64>
%2624 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2623 : tensor<2x32x60x256xf64>) outs(%2618 : tensor<2x32x60x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x60x256xf64>
%2625 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2626 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2624 : tensor<2x32x60x256xf64>) outs(%2625 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2627 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2626 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_718 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2628 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2627 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2629 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2630 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2617 : tensor<2x32x60x256xf32>) outs(%2629 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2631 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2630 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_719 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2632 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2628, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2633 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2632 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2634 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1282, %2631 : tensor<2x32x60x256xf16>, tensor<2x32x1x1xf32>) outs(%2615 : tensor<2x32x60x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x60x256xf32>
%2635 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2634, %2633 : tensor<2x32x60x256xf32>, tensor<2x32x1x1xf32>) outs(%2615 : tensor<2x32x60x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x60x256xf32>
%collapsed_1283 = tensor.collapse_shape %2635 [[0], [1, 2], [3]] : tensor<2x32x60x256xf32> into tensor<2x1920x256xf32>
%expanded_1284 = tensor.expand_shape %collapsed_1283 [[0], [1], [2, 3]] : tensor<2x1920x256xf32> into tensor<2x1920x16x16xf32>
%expanded_1285 = tensor.expand_shape %cst_421 [[0, 1, 2]] : tensor<1920xf16> into tensor<1920x1x1xf16>
%2636 = tensor.empty() : tensor<2x1920x16x16xf32>
%2637 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1284, %expanded_1285 : tensor<2x1920x16x16xf32>, tensor<1920x1x1xf16>) outs(%2636 : tensor<2x1920x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1920x16x16xf32>
%expanded_1286 = tensor.expand_shape %cst_422 [[0, 1, 2]] : tensor<1920xf16> into tensor<1920x1x1xf16>
%2638 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2637, %expanded_1286 : tensor<2x1920x16x16xf32>, tensor<1920x1x1xf16>) outs(%2636 : tensor<2x1920x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1920x16x16xf32>
%2639 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2640 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2639 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2641 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2640 : tensor<f16>) outs(%2612 : tensor<2x1920x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1920x16x16xf16>
%2642 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2638 : tensor<2x1920x16x16xf32>) outs(%2641 : tensor<2x1920x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1920x16x16xf16>
%2643 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2642 : tensor<2x1920x16x16xf16>) outs(%2612 : tensor<2x1920x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1920x16x16xf16>
%2644 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2643, %2642 : tensor<2x1920x16x16xf16>, tensor<2x1920x16x16xf16>) outs(%2612 : tensor<2x1920x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1920x16x16xf16>
%padded_1287 = tensor.pad %2644 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1920x16x16xf16> to tensor<2x1920x18x18xf16>
%2645 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_424 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2646 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1287, %cst_423 : tensor<2x1920x18x18xf16>, tensor<1280x1920x3x3xf16>) outs(%2645 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2647 = linalg.generic {indexing_maps = [#map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%45 : tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280xf16>
%2648 = linalg.generic {indexing_maps = [#map7, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%2647, %45 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%2649 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_425 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2650 = linalg.fill ins(%cst_695 : f16) outs(%35 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2651 = linalg.matmul ins(%2648, %2649 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2650 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2652 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_426, %2651 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%35 : tensor<2x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280xf16>
%expanded_1288 = tensor.expand_shape %2652 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2653 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2646, %expanded_1288 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1289 = tensor.collapse_shape %2653 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1290 = tensor.expand_shape %collapsed_1289 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2654 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2655 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2654 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2656 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2655 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2657 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1290 : tensor<2x32x40x256xf16>) outs(%2656 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2658 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2657 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2659 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2660 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2658 : tensor<2x32x40x256xf64>) outs(%2659 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2661 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2660 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2662 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2658, %2661 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2663 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2662 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2664 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2665 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2663 : tensor<2x32x40x256xf64>) outs(%2664 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2666 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2665 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2667 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2666 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2668 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2669 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2657 : tensor<2x32x40x256xf32>) outs(%2668 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2670 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2669 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2671 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2667, %cst_5 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2672 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2671 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2673 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1290, %2670 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2674 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2673, %2672 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1291 = tensor.collapse_shape %2674 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1292 = tensor.expand_shape %collapsed_1291 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1293 = tensor.expand_shape %cst_427 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2675 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1292, %expanded_1293 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1294 = tensor.expand_shape %cst_428 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2676 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2675, %expanded_1294 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2677 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2678 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2677 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2679 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2678 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2680 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2676 : tensor<2x1280x16x16xf32>) outs(%2679 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2681 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2680 : tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.negf %in : f16
%4253 = math.exp %4252 : f16
%4254 = arith.addf %4253, %cst_696 : f16
%4255 = arith.divf %cst_696, %4254 : f16
linalg.yield %4255 : f16
} -> tensor<2x1280x16x16xf16>
%2682 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2681, %2680 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%padded_1295 = tensor.pad %2682 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg4: index, %arg5: index, %arg6: index, %arg7: index):
tensor.yield %cst_695 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2683 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_430 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2684 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%padded_1295, %cst_429 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2683 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2685 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_432 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2686 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%inserted_slice_1280, %cst_431 : tensor<2x1920x16x16xf16>, tensor<1280x1920x1x1xf16>) outs(%2685 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2687 = linalg.generic {indexing_maps = [#map1, #map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2686, %2684 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2688 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2687, %cst_4 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.divf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x1280x16x16xf16>
%collapsed_1296 = tensor.collapse_shape %2688 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%expanded_1297 = tensor.expand_shape %collapsed_1296 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2689 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2690 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2689 : tensor<f64>) outs(%1 : tensor<f32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<f32>
%2691 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2690 : tensor<f32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %out: f32):
linalg.yield %in : f32
} -> tensor<2x32x40x256xf32>
%2692 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1297 : tensor<2x32x40x256xf16>) outs(%2691 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %out: f32):
%4252 = arith.extf %in : f16 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%2693 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2692 : tensor<2x32x40x256xf32>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f32, %out: f64):
%4252 = arith.extf %in : f32 to f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2694 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2695 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2693 : tensor<2x32x40x256xf64>) outs(%2694 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2696 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2695 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2697 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2693, %2696 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %in_1647: f64, %out: f64):
%4252 = arith.subf %in, %in_1647 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2698 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2697 : tensor<2x32x40x256xf64>) outs(%1050 : tensor<2x32x40x256xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.mulf %in, %in : f64
linalg.yield %4252 : f64
} -> tensor<2x32x40x256xf64>
%2699 = linalg.fill ins(%cst_700 : f64) outs(%56 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2700 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2698 : tensor<2x32x40x256xf64>) outs(%2699 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.addf %in, %out : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2701 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2700 : tensor<2x32x1x1xf64>) outs(%56 : tensor<2x32x1x1xf64>) {
^bb0(%in: f64, %out: f64):
%4252 = arith.divf %in, %cst_708 : f64
linalg.yield %4252 : f64
} -> tensor<2x32x1x1xf64>
%2702 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2701 : tensor<2x32x1x1xf64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f64, %out: f32):
%4252 = arith.truncf %in : f64 to f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2703 = linalg.fill ins(%cst_704 : f32) outs(%65 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2704 = linalg.generic {indexing_maps = [#map1, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2692 : tensor<2x32x40x256xf32>) outs(%2703 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.addf %in, %out : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2705 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2704 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = arith.divf %in, %cst_709 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2706 = linalg.generic {indexing_maps = [#map13, #map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2702, %cst_3 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %in_1647: f64, %out: f32):
%4252 = arith.truncf %in_1647 : f64 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x1x1xf32>
%2707 = linalg.generic {indexing_maps = [#map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2706 : tensor<2x32x1x1xf32>) outs(%65 : tensor<2x32x1x1xf32>) {
^bb0(%in: f32, %out: f32):
%4252 = math.rsqrt %in : f32
linalg.yield %4252 : f32
} -> tensor<2x32x1x1xf32>
%2708 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1297, %2705 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f16, %in_1647: f32, %out: f32):
%4252 = arith.extf %in : f16 to f32
%4253 = arith.subf %4252, %in_1647 : f32
linalg.yield %4253 : f32
} -> tensor<2x32x40x256xf32>
%2709 = linalg.generic {indexing_maps = [#map1, #map13, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2708, %2707 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1047 : tensor<2x32x40x256xf32>) {
^bb0(%in: f32, %in_1647: f32, %out: f32):
%4252 = arith.mulf %in, %in_1647 : f32
linalg.yield %4252 : f32
} -> tensor<2x32x40x256xf32>
%collapsed_1298 = tensor.collapse_shape %2709 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%expanded_1299 = tensor.expand_shape %collapsed_1298 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%expanded_1300 = tensor.expand_shape %cst_433 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2710 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1299, %expanded_1300 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.mulf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%expanded_1301 = tensor.expand_shape %cst_434 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2711 = linalg.generic {indexing_maps = [#map1, #map14, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2710, %expanded_1301 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1068 : tensor<2x1280x16x16xf32>) {
^bb0(%in: f32, %in_1647: f16, %out: f32):
%4252 = arith.extf %in_1647 : f16 to f32
%4253 = arith.addf %in, %4252 : f32
linalg.yield %4253 : f32
} -> tensor<2x1280x16x16xf32>
%2712 = linalg.fill ins(%cst_700 : f64) outs(%13 : tensor<f64>) -> tensor<f64>
%2713 = linalg.generic {indexing_maps = [#map0, #map0], iterator_types = []} ins(%2712 : tensor<f64>) outs(%28 : tensor<f16>) {
^bb0(%in: f64, %out: f16):
%4252 = arith.truncf %in : f64 to f16
linalg.yield %4252 : f16
} -> tensor<f16>
%2714 = linalg.generic {indexing_maps = [#map2, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2713 : tensor<f16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2715 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2711 : tensor<2x1280x16x16xf32>) outs(%2714 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f32, %out: f16):
%4252 = arith.truncf %in : f32 to f16
linalg.yield %4252 : f16
} -> tensor<2x1280x16x16xf16>
%2716 = linalg.generic {indexing_maps = [#map12, #map1], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_436 : tensor<1280xf16>) outs(%1035 : tensor<2x1280x16x16xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x1280x16x16xf16>
%2717 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2715, %cst_435 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2716 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2718 = linalg.generic {indexing_maps = [#map1, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2717 : tensor<2x1280x16x16xf16>) outs(%1112 : tensor<2x16x16x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x16x16x1280xf16>
%collapsed_1302 = tensor.collapse_shape %2718 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%2719 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2720 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%collapsed_1302 : tensor<2x256x1280xf16>) outs(%2719 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2721 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2720 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2722 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2721 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2723 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1302, %2722 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2724 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2723 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2725 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2726 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2724 : tensor<2x256x1280xf16>) outs(%2725 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2727 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2726 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2728 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2727 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2729 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2728 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2730 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2729 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2731 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2723, %2730 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2732 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2731, %cst_437 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2733 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2732, %cst_438 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2734 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_439 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1303 = tensor.collapse_shape %2733 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2735 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2736 = linalg.matmul ins(%collapsed_1303, %2734 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2735 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2737 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_440 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2738 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2739 = linalg.matmul ins(%collapsed_1303, %2737 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2738 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2740 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_441 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%2741 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2742 = linalg.matmul ins(%collapsed_1303, %2740 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2741 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%expanded_1304 = tensor.expand_shape %2736 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2743 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1304 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1305 = tensor.collapse_shape %2743 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1306 = tensor.expand_shape %2739 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2744 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1306 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1307 = tensor.collapse_shape %2744 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1308 = tensor.expand_shape %2742 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2745 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1308 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1309 = tensor.collapse_shape %2745 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2746 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1307 : tensor<16x256x160xf16>) outs(%1145 : tensor<16x160x256xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x256xf16>
%2747 = linalg.fill ins(%cst_695 : f16) outs(%1147 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2748 = linalg.batch_matmul ins(%collapsed_1305, %2746 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%2747 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2749 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2748, %cst_0 : tensor<16x256x256xf16>, tensor<f64>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x256xf16>
%2750 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2751 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2749 : tensor<16x256x256xf16>) outs(%2750 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2752 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2749, %2751 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2753 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2752 : tensor<16x256x256xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2754 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2755 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2753 : tensor<16x256x256xf16>) outs(%2754 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2756 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2753, %2755 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1147 : tensor<16x256x256xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x256xf16>
%2757 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2758 = linalg.batch_matmul ins(%2756, %collapsed_1309 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%2757 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1310 = tensor.expand_shape %2758 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2759 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1310 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2760 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_442 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1311 = tensor.collapse_shape %2759 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2761 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2762 = linalg.matmul ins(%collapsed_1311, %2760 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2761 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2763 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_443, %2762 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1312 = tensor.expand_shape %2763 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2764 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1312, %collapsed_1302 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2765 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2766 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2764 : tensor<2x256x1280xf16>) outs(%2765 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2767 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2766 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2768 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2767 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2769 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2764, %2768 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2770 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2769 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2771 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2772 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2770 : tensor<2x256x1280xf16>) outs(%2771 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2773 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2772 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2774 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2773 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2775 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2774 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2776 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2775 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2777 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2769, %2776 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2778 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2777, %cst_444 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2779 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2778, %cst_445 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2780 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_446 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1313 = tensor.collapse_shape %2779 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2781 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2782 = linalg.matmul ins(%collapsed_1313, %2780 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2781 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2783 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_447 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2784 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2785 = linalg.matmul ins(%collapsed_766, %2783 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2784 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2786 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_448 : tensor<1280x768xf16>) outs(%1187 : tensor<768x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<768x1280xf16>
%2787 = linalg.fill ins(%cst_695 : f16) outs(%1189 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2788 = linalg.matmul ins(%collapsed_766, %2786 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2787 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%expanded_1314 = tensor.expand_shape %2782 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2789 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1314 : tensor<2x256x8x160xf16>) outs(%1141 : tensor<2x8x256x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x256x160xf16>
%collapsed_1315 = tensor.collapse_shape %2789 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%expanded_1316 = tensor.expand_shape %2785 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2790 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1316 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1317 = tensor.collapse_shape %2790 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%expanded_1318 = tensor.expand_shape %2788 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2791 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1318 : tensor<2x77x8x160xf16>) outs(%1196 : tensor<2x8x77x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x8x77x160xf16>
%collapsed_1319 = tensor.collapse_shape %2791 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2792 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%collapsed_1317 : tensor<16x77x160xf16>) outs(%1199 : tensor<16x160x77xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<16x160x77xf16>
%2793 = linalg.fill ins(%cst_695 : f16) outs(%1201 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2794 = linalg.batch_matmul ins(%collapsed_1315, %2792 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%2793 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2795 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2794, %cst_0 : tensor<16x256x77xf16>, tensor<f64>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f64, %out: f16):
%4252 = arith.truncf %in_1647 : f64 to f16
%4253 = arith.mulf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<16x256x77xf16>
%2796 = linalg.fill ins(%cst_697 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2797 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2795 : tensor<16x256x77xf16>) outs(%2796 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.maxf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2798 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2795, %2797 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2799 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2798 : tensor<16x256x77xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.exp %in : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2800 = linalg.fill ins(%cst_695 : f16) outs(%1151 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2801 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2799 : tensor<16x256x77xf16>) outs(%2800 : tensor<16x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<16x256x1xf16>
%2802 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2799, %2801 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1201 : tensor<16x256x77xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.divf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<16x256x77xf16>
%2803 = linalg.fill ins(%cst_695 : f16) outs(%1159 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2804 = linalg.batch_matmul ins(%2802, %collapsed_1319 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%2803 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%expanded_1320 = tensor.expand_shape %2804 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2805 = linalg.generic {indexing_maps = [#map1, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%expanded_1320 : tensor<2x8x256x160xf16>) outs(%1162 : tensor<2x256x8x160xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x8x160xf16>
%2806 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_449 : tensor<1280x1280xf16>) outs(%41 : tensor<1280x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x1280xf16>
%collapsed_1321 = tensor.collapse_shape %2805 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2807 = linalg.fill ins(%cst_695 : f16) outs(%1132 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2808 = linalg.matmul ins(%collapsed_1321, %2806 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2807 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2809 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_450, %2808 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1132 : tensor<512x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x1280xf16>
%expanded_1322 = tensor.expand_shape %2809 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2810 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%expanded_1322, %2764 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2811 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2812 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2810 : tensor<2x256x1280xf16>) outs(%2811 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2813 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2812 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2814 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2813 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2815 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2810, %2814 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.subf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2816 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2815 : tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.mulf %in, %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2817 = linalg.fill ins(%cst_695 : f16) outs(%1114 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2818 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2816 : tensor<2x256x1280xf16>) outs(%2817 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.addf %in, %out : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2819 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2818 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.divf %in, %cst_715 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2820 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2819 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = arith.truncf %cst_701 : f64 to f16
%4253 = arith.addf %in, %4252 : f16
linalg.yield %4253 : f16
} -> tensor<2x256x1xf16>
%2821 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2820 : tensor<2x256x1xf16>) outs(%1114 : tensor<2x256x1xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.rsqrt %in : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1xf16>
%2822 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2821 : tensor<2x256x1xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<2x256x1280xf16>
%2823 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2815, %2822 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2824 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2823, %cst_451 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2825 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2824, %cst_452 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1118 : tensor<2x256x1280xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x1280xf16>
%2826 = linalg.generic {indexing_maps = [#map7, #map10], iterator_types = ["parallel", "parallel"]} ins(%cst_453 : tensor<10240x1280xf16>) outs(%1235 : tensor<1280x10240xf16>) {
^bb0(%in: f16, %out: f16):
linalg.yield %in : f16
} -> tensor<1280x10240xf16>
%collapsed_1323 = tensor.collapse_shape %2825 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2827 = linalg.fill ins(%cst_695 : f16) outs(%1237 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2828 = linalg.matmul ins(%collapsed_1323, %2826 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%2827 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2829 = linalg.generic {indexing_maps = [#map11, #map7, #map7], iterator_types = ["parallel", "parallel"]} ins(%cst_454, %2828 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1237 : tensor<512x10240xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.addf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<512x10240xf16>
%expanded_1324 = tensor.expand_shape %2829 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%extracted_slice_1325 = tensor.extract_slice %expanded_1324[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%extracted_slice_1326 = tensor.extract_slice %expanded_1324[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%2830 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1326 : tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %out: f16):
%4252 = math.sqrt %cst_698 : f16
%4253 = arith.divf %in, %4252 : f16
%4254 = math.erf %4253 : f16
%4255 = arith.addf %4254, %cst_696 : f16
%4256 = arith.mulf %4255, %cst_699 : f16
%4257 = arith.mulf %in, %4256 : f16
linalg.yield %4257 : f16
} -> tensor<2x256x5120xf16>
%2831 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%extracted_slice_1325, %2830 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1241 : tensor<2x256x5120xf16>) {
^bb0(%in: f16, %in_1647: f16, %out: f16):
%4252 = arith.mulf %in, %in_1647 : f16
linalg.yield %4252 : f16
} -> tensor<2x256x5120xf16>
%2832 = l
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment