Skip to content

Instantly share code, notes, and snippets.

@pashu123

pashu123/stable_diff_f16_elided.mlir

Created October 5, 2022 11:50
Show Gist options

  • Select an option

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

Select an option

Learn more about clone URLs
Save pashu123/facec30e8f185795025c7ddcca5f21d9 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
stable_diff_f16_elided.mlir
This file has been truncated, but you can view the full file.
#map0 = affine_map<(d0) -> (0)>
#map1 = affine_map<(d0) -> (d0)>
#map2 = affine_map<(d0) -> ()>
#map3 = affine_map<() -> ()>
#map4 = affine_map<(d0, d1) -> ()>
#map5 = affine_map<(d0, d1) -> (d0, d1)>
#map6 = affine_map<(d0, d1) -> (d0, 0)>
#map7 = affine_map<(d0, d1) -> (0, d1)>
#map8 = affine_map<(d0, d1) -> (d1, d0)>
#map9 = affine_map<(d0, d1) -> (d1)>
#map10 = affine_map<(d0, d1, d2, d3) -> (d1)>
#map11 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
#map12 = affine_map<(d0, d1, d2, d3) -> ()>
#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)>
module attributes {torch.debug_module_name = "_lambda"} {
func.func @forward(%arg0: tensor<2x4x64x64xf16>, %arg1: tensor<1xf16>, %arg2: tensor<2x77x768xf16>) -> tensor<2x4x64x64xf16> {
%cst = arith.constant dense<0.079056941504209485> : tensor<f64>
%cst_0 = arith.constant dense<0.11180339887498948> : tensor<f64>
%cst_1 = arith.constant dense<0.15811388300841897> : tensor<f64>
%cst_2 = arith.constant dense<9.9999999999999995E-7> : tensor<f64>
%cst_3 = arith.constant dense<1.000000e+00> : tensor<f64>
%cst_4 = arith.constant dense<1.000000e-05> : tensor<f64>
%cst_5 = arith.constant dense<1> : tensor<i64>
%cst_6 = arith.constant dense<160> : tensor<i64>
%cst_7 = arith.constant dense<-9.2103403719761836> : tensor<f64>
%cst_8 = arith.constant dense_resource<__elided__> : tensor<1280x320xf16>
%cst_9 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_10 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_11 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_12 = arith.constant dense_resource<__elided__> : tensor<320x4x3x3xf16>
%cst_13 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_17 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_18 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_19 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_23 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x1x1xf16>
%cst_27 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320xf16>
%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<320xf16>
%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<320x320xf16>
%cst_38 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_39 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_40 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_41 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<2560x320xf16>
%cst_45 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_46 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_47 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_48 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_49 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_53 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_54 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_55 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_59 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x1x1xf16>
%cst_63 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320xf16>
%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<320xf16>
%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<320x320xf16>
%cst_74 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_75 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_76 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_77 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<2560x320xf16>
%cst_81 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_82 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_83 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_84 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_85 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_86 = arith.constant dense_resource<__elided__> : tensor<320x320x3x3xf16>
%cst_87 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<640x320x3x3xf16>
%cst_91 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_92 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_93 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_97 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_98 = arith.constant dense_resource<__elided__> : tensor<640x320x1x1xf16>
%cst_99 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x1x1xf16>
%cst_103 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640xf16>
%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<640xf16>
%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<640x640xf16>
%cst_114 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_115 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_116 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_117 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<5120x640xf16>
%cst_121 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_122 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_123 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_124 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_125 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_129 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_130 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_131 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_135 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x1x1xf16>
%cst_139 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640xf16>
%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<640xf16>
%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<640x640xf16>
%cst_150 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_151 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_152 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_153 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<5120x640xf16>
%cst_157 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_158 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_159 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_160 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_161 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_162 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_163 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<1280x640x3x3xf16>
%cst_167 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_168 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_169 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_173 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_174 = arith.constant dense_resource<__elided__> : tensor<1280x640x1x1xf16>
%cst_175 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_179 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_190 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_191 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_192 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_193 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_197 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_198 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_199 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_200 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_201 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_205 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_206 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_207 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_211 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_215 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_226 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_227 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_228 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_229 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_233 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_234 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_235 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_236 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_237 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_238 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_239 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_243 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_244 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_245 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_249 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_253 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_254 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_255 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_259 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_263 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_264 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_265 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_269 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_273 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_284 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_285 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_286 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_287 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_291 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_292 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_293 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_294 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_295 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_299 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_300 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_301 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_305 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_306 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_307 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_308 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_309 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_310 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_311 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_315 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_316 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_317 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_318 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_319 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_320 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_321 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_322 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_323 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_327 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_328 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_329 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_330 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_331 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_332 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_333 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_334 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_335 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_339 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_340 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_341 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_342 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_343 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_344 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_345 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_346 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_347 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_348 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_349 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_353 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_354 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_355 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_359 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_370 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_371 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_372 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_373 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_377 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_378 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_379 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_380 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_381 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_382 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_383 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_384 = arith.constant dense_resource<__elided__> : tensor<1280x2560x3x3xf16>
%cst_385 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_386 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_387 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_391 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_392 = arith.constant dense_resource<__elided__> : tensor<1280x2560x1x1xf16>
%cst_393 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_397 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_408 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_409 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_410 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_411 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_415 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_416 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_417 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_418 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_419 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_420 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_421 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_422 = arith.constant dense_resource<__elided__> : tensor<1280x1920x3x3xf16>
%cst_423 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_424 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_425 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x3x3xf16>
%cst_429 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_430 = arith.constant dense_resource<__elided__> : tensor<1280x1920x1x1xf16>
%cst_431 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280x1x1xf16>
%cst_435 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<1280x1280xf16>
%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<1280xf16>
%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<1280x1280xf16>
%cst_446 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_447 = arith.constant dense_resource<__elided__> : tensor<1280x768xf16>
%cst_448 = arith.constant dense_resource<__elided__> : tensor<1280x1280xf16>
%cst_449 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%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<10240x1280xf16>
%cst_453 = arith.constant dense_resource<__elided__> : tensor<10240xf16>
%cst_454 = arith.constant dense_resource<__elided__> : tensor<1280x5120xf16>
%cst_455 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_456 = arith.constant dense_resource<__elided__> : tensor<1280x1280x1x1xf16>
%cst_457 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_458 = arith.constant dense_resource<__elided__> : tensor<1280x1280x3x3xf16>
%cst_459 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_460 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_461 = arith.constant dense_resource<__elided__> : tensor<1920xf16>
%cst_462 = arith.constant dense_resource<__elided__> : tensor<640x1920x3x3xf16>
%cst_463 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_464 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_465 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_469 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_470 = arith.constant dense_resource<__elided__> : tensor<640x1920x1x1xf16>
%cst_471 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x1x1xf16>
%cst_475 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640xf16>
%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<640xf16>
%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<640x640xf16>
%cst_486 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_487 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_488 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_489 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<5120x640xf16>
%cst_493 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_494 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_495 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_496 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_497 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_498 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_499 = arith.constant dense_resource<__elided__> : tensor<1280xf16>
%cst_500 = arith.constant dense_resource<__elided__> : tensor<640x1280x3x3xf16>
%cst_501 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_502 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_503 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_507 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_508 = arith.constant dense_resource<__elided__> : tensor<640x1280x1x1xf16>
%cst_509 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x1x1xf16>
%cst_513 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640xf16>
%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<640xf16>
%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<640x640xf16>
%cst_524 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_525 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_526 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_527 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<5120x640xf16>
%cst_531 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_532 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_533 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_534 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_535 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_536 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_537 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_538 = arith.constant dense_resource<__elided__> : tensor<640x960x3x3xf16>
%cst_539 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_540 = arith.constant dense_resource<__elided__> : tensor<640x1280xf16>
%cst_541 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x3x3xf16>
%cst_545 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_546 = arith.constant dense_resource<__elided__> : tensor<640x960x1x1xf16>
%cst_547 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640x1x1xf16>
%cst_551 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<640x640xf16>
%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<640xf16>
%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<640x640xf16>
%cst_562 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_563 = arith.constant dense_resource<__elided__> : tensor<640x768xf16>
%cst_564 = arith.constant dense_resource<__elided__> : tensor<640x640xf16>
%cst_565 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%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<5120x640xf16>
%cst_569 = arith.constant dense_resource<__elided__> : tensor<5120xf16>
%cst_570 = arith.constant dense_resource<__elided__> : tensor<640x2560xf16>
%cst_571 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_572 = arith.constant dense_resource<__elided__> : tensor<640x640x1x1xf16>
%cst_573 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_574 = arith.constant dense_resource<__elided__> : tensor<640x640x3x3xf16>
%cst_575 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_576 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_577 = arith.constant dense_resource<__elided__> : tensor<960xf16>
%cst_578 = arith.constant dense_resource<__elided__> : tensor<320x960x3x3xf16>
%cst_579 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_580 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_581 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_585 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_586 = arith.constant dense_resource<__elided__> : tensor<320x960x1x1xf16>
%cst_587 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x1x1xf16>
%cst_591 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320xf16>
%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<320xf16>
%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<320x320xf16>
%cst_602 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_603 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_604 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_605 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<2560x320xf16>
%cst_609 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_610 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_611 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_612 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_613 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_614 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_615 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_616 = arith.constant dense_resource<__elided__> : tensor<320x640x3x3xf16>
%cst_617 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_618 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_619 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_623 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_624 = arith.constant dense_resource<__elided__> : tensor<320x640x1x1xf16>
%cst_625 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x1x1xf16>
%cst_629 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320xf16>
%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<320xf16>
%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<320x320xf16>
%cst_640 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_641 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_642 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_643 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<2560x320xf16>
%cst_647 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_648 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_649 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_650 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_651 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_652 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_653 = arith.constant dense_resource<__elided__> : tensor<640xf16>
%cst_654 = arith.constant dense_resource<__elided__> : tensor<320x640x3x3xf16>
%cst_655 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_656 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_657 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x3x3xf16>
%cst_661 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_662 = arith.constant dense_resource<__elided__> : tensor<320x640x1x1xf16>
%cst_663 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320x1x1xf16>
%cst_667 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<320x320xf16>
%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<320xf16>
%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<320x320xf16>
%cst_678 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_679 = arith.constant dense_resource<__elided__> : tensor<320x768xf16>
%cst_680 = arith.constant dense_resource<__elided__> : tensor<320x320xf16>
%cst_681 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<2560x320xf16>
%cst_685 = arith.constant dense_resource<__elided__> : tensor<2560xf16>
%cst_686 = arith.constant dense_resource<__elided__> : tensor<320x1280xf16>
%cst_687 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%cst_688 = arith.constant dense_resource<__elided__> : tensor<320x320x1x1xf16>
%cst_689 = arith.constant dense_resource<__elided__> : tensor<320xf16>
%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<4x320x3x3xf16>
%cst_693 = arith.constant dense<[-1.393320e-03, -1.588820e-03, -2.624990e-04, -2.531050e-03]> : tensor<4xf16>
%cst_694 = arith.constant 0.000000e+00 : f16
%cst_695 = arith.constant 1.000000e+00 : f16
%cst_696 = arith.constant -6.550400e+04 : f16
%cst_697 = arith.constant 2.000000e+00 : f16
%cst_698 = arith.constant 5.000000e-01 : f16
%cst_699 = arith.constant 0.000000e+00 : f64
%cst_700 = arith.constant 1.000000e-05 : f64
%cst_701 = arith.constant 0.000000e+00 : f32
%cst_702 = arith.constant 4.096000e+04 : f64
%cst_703 = arith.constant 4.096000e+04 : f32
%cst_704 = arith.constant 3.200000e+02 : f16
%cst_705 = arith.constant 1.024000e+04 : f64
%cst_706 = arith.constant 1.024000e+04 : f32
%cst_707 = arith.constant 2.048000e+04 : f64
%cst_708 = arith.constant 2.048000e+04 : f32
%cst_709 = arith.constant 6.400000e+02 : f16
%cst_710 = arith.constant 5.120000e+03 : f64
%cst_711 = arith.constant 5.120000e+03 : f32
%cst_712 = arith.constant 1.280000e+03 : f16
%cst_713 = arith.constant 2.560000e+03 : f64
%cst_714 = arith.constant 2.560000e+03 : f32
%cst_715 = arith.constant 1.536000e+04 : f64
%cst_716 = arith.constant 1.536000e+04 : f32
%cst_717 = arith.constant 6.144000e+04 : f64
%cst_718 = arith.constant 6.144000e+04 : f32
%cst_719 = arith.constant 3.072000e+04 : f64
%cst_720 = arith.constant 3.072000e+04 : f32
%cst_721 = arith.constant 1.228800e+05 : f64
%cst_722 = arith.constant 1.228800e+05 : f32
%cst_723 = arith.constant 8.192000e+04 : f64
%cst_724 = arith.constant 8.192000e+04 : f32
%c0_i64 = arith.constant 0 : i64
%c2 = arith.constant 2 : index
%0 = linalg.init_tensor [2] : tensor<2xf16>
%1 = linalg.generic {indexing_maps = [#map0, #map1], iterator_types = ["parallel"]} ins(%arg1 : tensor<1xf16>) outs(%0 : tensor<2xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2xf16>
%2 = linalg.init_tensor [160] : tensor<160xf32>
%3 = linalg.generic {indexing_maps = [#map1], iterator_types = ["parallel"]} outs(%2 : tensor<160xf32>) {
^bb0(%arg3: f32):
%5200 = linalg.index 0 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.sitofp %5201 : i64 to f32
%5203 = arith.addf %5202, %cst_701 : f32
linalg.yield %5203 : f32
} -> tensor<160xf32>
%4 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel"]} ins(%3, %cst_7 : tensor<160xf32>, tensor<f64>) outs(%2 : tensor<160xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<160xf32>
%5 = linalg.generic {indexing_maps = [#map1, #map2, #map1], iterator_types = ["parallel"]} ins(%4, %cst_6 : tensor<160xf32>, tensor<i64>) outs(%2 : tensor<160xf32>) {
^bb0(%arg3: f32, %arg4: i64, %arg5: f32):
%5200 = arith.sitofp %arg4 : i64 to f32
%5201 = arith.divf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<160xf32>
%6 = linalg.generic {indexing_maps = [#map1, #map1], iterator_types = ["parallel"]} ins(%5 : tensor<160xf32>) outs(%2 : tensor<160xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.exp %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<160xf32>
%7 = tensor.expand_shape %1 [[0, 1]] : tensor<2xf16> into tensor<2x1xf16>
%8 = linalg.init_tensor [] : tensor<f64>
%9 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%10 = linalg.init_tensor [] : tensor<f32>
%11 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%9 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%12 = linalg.init_tensor [2, 1] : tensor<2x1xf32>
%13 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel"]} ins(%11 : tensor<f32>) outs(%12 : tensor<2x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x1xf32>
%14 = linalg.init_tensor [2, 1] : tensor<2x1xf16>
%15 = linalg.generic {indexing_maps = [#map6, #map5], iterator_types = ["parallel", "parallel"]} ins(%7 : tensor<2x1xf16>) outs(%14 : tensor<2x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1xf16>
%16 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%15 : tensor<2x1xf16>) outs(%13 : tensor<2x1xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x1xf32>
%17 = tensor.expand_shape %6 [[0, 1]] : tensor<160xf32> into tensor<1x160xf32>
%18 = linalg.init_tensor [2, 160] : tensor<2x160xf32>
%19 = linalg.generic {indexing_maps = [#map6, #map7, #map5], iterator_types = ["parallel", "parallel"]} ins(%16, %17 : tensor<2x1xf32>, tensor<1x160xf32>) outs(%18 : tensor<2x160xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x160xf32>
%20 = linalg.generic {indexing_maps = [#map5, #map4, #map5], iterator_types = ["parallel", "parallel"]} ins(%19, %cst_5 : tensor<2x160xf32>, tensor<i64>) outs(%18 : tensor<2x160xf32>) {
^bb0(%arg3: f32, %arg4: i64, %arg5: f32):
%5200 = arith.sitofp %arg4 : i64 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x160xf32>
%21 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%20 : tensor<2x160xf32>) outs(%18 : tensor<2x160xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.sin %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x160xf32>
%22 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%20 : tensor<2x160xf32>) outs(%18 : tensor<2x160xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.cos %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x160xf32>
%23 = linalg.init_tensor [2, 320] : tensor<2x320xf32>
%24 = tensor.insert_slice %21 into %23[0, 0] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%25 = tensor.insert_slice %22 into %24[0, 160] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%26 = tensor.extract_slice %25[0, 0] [2, 160] [1, 1] : tensor<2x320xf32> to tensor<2x160xf32>
%27 = tensor.insert_slice %22 into %23[0, 0] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%28 = tensor.insert_slice %26 into %27[0, 160] [2, 160] [1, 1] : tensor<2x160xf32> into tensor<2x320xf32>
%29 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%30 = linalg.init_tensor [] : tensor<f16>
%31 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%29 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%32 = linalg.init_tensor [2, 320] : tensor<2x320xf16>
%33 = linalg.generic {indexing_maps = [#map4, #map5], iterator_types = ["parallel", "parallel"]} ins(%31 : tensor<f16>) outs(%32 : tensor<2x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320xf16>
%34 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%28 : tensor<2x320xf32>) outs(%33 : tensor<2x320xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320xf16>
%35 = linalg.init_tensor [320, 1280] : tensor<320x1280xf16>
%36 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_8 : tensor<1280x320xf16>) outs(%35 : tensor<320x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x1280xf16>
%37 = linalg.init_tensor [2, 1280] : tensor<2x1280xf16>
%38 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%39 = linalg.matmul ins(%34, %36 : tensor<2x320xf16>, tensor<320x1280xf16>) outs(%38 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%40 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_9, %39 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%41 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%40 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%42 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%41, %40 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%43 = linalg.init_tensor [1280, 1280] : tensor<1280x1280xf16>
%44 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_10 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%45 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%46 = linalg.matmul ins(%42, %44 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%45 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%47 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_11, %46 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%48 = tensor.pad %arg0 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x4x64x64xf16> to tensor<2x4x66x66xf16>
%49 = linalg.init_tensor [2, 320, 64, 64] : tensor<2x320x64x64xf16>
%50 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_13 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%51 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%48, %cst_12 : tensor<2x4x66x66xf16>, tensor<320x4x3x3xf16>) outs(%50 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%52 = tensor.collapse_shape %51 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%53 = tensor.expand_shape %52 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%54 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%55 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%54 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%56 = linalg.init_tensor [2, 32, 10, 4096] : tensor<2x32x10x4096xf32>
%57 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%55 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%58 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%53 : tensor<2x32x10x4096xf16>) outs(%57 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%59 = linalg.init_tensor [2, 32, 10, 4096] : tensor<2x32x10x4096xf64>
%60 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%58 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%61 = linalg.init_tensor [2, 32, 1, 1] : tensor<2x32x1x1xf64>
%62 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%63 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%60 : tensor<2x32x10x4096xf64>) outs(%62 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%64 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%63 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%65 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%60, %64 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%66 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%65 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%67 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%68 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%66 : tensor<2x32x10x4096xf64>) outs(%67 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%69 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%68 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%70 = linalg.init_tensor [2, 32, 1, 1] : tensor<2x32x1x1xf32>
%71 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%69 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%72 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%73 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%58 : tensor<2x32x10x4096xf32>) outs(%72 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%74 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%73 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%75 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%71, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%76 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%75 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%77 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%53, %74 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%78 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%77, %76 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%79 = tensor.collapse_shape %78 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%80 = tensor.expand_shape %79 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%81 = tensor.expand_shape %cst_14 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%82 = linalg.init_tensor [2, 320, 64, 64] : tensor<2x320x64x64xf32>
%83 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%80, %81 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%84 = tensor.expand_shape %cst_15 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%85 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%83, %84 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%86 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%87 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%86 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%88 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%87 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%89 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%85 : tensor<2x320x64x64xf32>) outs(%88 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%90 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%89 : tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x320x64x64xf16>
%91 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%90, %89 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%92 = tensor.pad %91 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%93 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_17 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%94 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%92, %cst_16 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%93 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%95 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%96 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%95, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%97 = linalg.init_tensor [1280, 320] : tensor<1280x320xf16>
%98 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_18 : tensor<320x1280xf16>) outs(%97 : tensor<1280x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x320xf16>
%99 = linalg.fill ins(%cst_694 : f16) outs(%32 : tensor<2x320xf16>) -> tensor<2x320xf16>
%100 = linalg.matmul ins(%96, %98 : tensor<2x1280xf16>, tensor<1280x320xf16>) outs(%99 : tensor<2x320xf16>) -> tensor<2x320xf16>
%101 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_19, %100 : tensor<320xf16>, tensor<2x320xf16>) outs(%32 : tensor<2x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320xf16>
%102 = tensor.expand_shape %101 [[0], [1, 2, 3]] : tensor<2x320xf16> into tensor<2x320x1x1xf16>
%103 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%94, %102 : tensor<2x320x64x64xf16>, tensor<2x320x1x1xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%104 = tensor.collapse_shape %103 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%105 = tensor.expand_shape %104 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%106 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%107 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%106 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%108 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%107 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%109 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%105 : tensor<2x32x10x4096xf16>) outs(%108 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%110 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%109 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%111 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%112 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%110 : tensor<2x32x10x4096xf64>) outs(%111 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%113 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%112 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%114 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%110, %113 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%115 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%114 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%116 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%117 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%115 : tensor<2x32x10x4096xf64>) outs(%116 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%118 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%117 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%119 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%118 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%120 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%121 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%109 : tensor<2x32x10x4096xf32>) outs(%120 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%122 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%121 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%123 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%119, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%124 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%123 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%125 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%105, %122 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%126 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%125, %124 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%127 = tensor.collapse_shape %126 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%128 = tensor.expand_shape %127 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%129 = tensor.expand_shape %cst_20 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%130 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%128, %129 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%131 = tensor.expand_shape %cst_21 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%132 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%130, %131 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%133 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%134 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%133 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%135 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%134 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%136 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%132 : tensor<2x320x64x64xf32>) outs(%135 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%137 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%136 : tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x320x64x64xf16>
%138 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%137, %136 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%139 = tensor.pad %138 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%140 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_23 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%141 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%139, %cst_22 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%140 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%142 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%51, %141 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%143 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%142, %cst_3 : tensor<2x320x64x64xf16>, tensor<f64>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x320x64x64xf16>
%144 = tensor.collapse_shape %143 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%145 = tensor.expand_shape %144 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%146 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%147 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%146 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%148 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%147 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%149 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%145 : tensor<2x32x10x4096xf16>) outs(%148 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%150 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%149 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%151 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%152 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%150 : tensor<2x32x10x4096xf64>) outs(%151 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%153 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%152 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%154 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%150, %153 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%155 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%154 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%156 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%157 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%155 : tensor<2x32x10x4096xf64>) outs(%156 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%158 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%157 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%159 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%158 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%160 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%161 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%149 : tensor<2x32x10x4096xf32>) outs(%160 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%162 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%161 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%163 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%159, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%164 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%163 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%165 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%145, %162 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%166 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%165, %164 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%167 = tensor.collapse_shape %166 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%168 = tensor.expand_shape %167 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%169 = tensor.expand_shape %cst_24 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%170 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%168, %169 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%171 = tensor.expand_shape %cst_25 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%172 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%170, %171 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%173 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%174 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%173 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%175 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%174 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%176 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%172 : tensor<2x320x64x64xf32>) outs(%175 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%177 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_27 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%178 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%176, %cst_26 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%177 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%179 = linalg.init_tensor [2, 64, 64, 320] : tensor<2x64x64x320xf16>
%180 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%178 : tensor<2x320x64x64xf16>) outs(%179 : tensor<2x64x64x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x64x320xf16>
%181 = tensor.collapse_shape %180 [[0], [1, 2], [3]] : tensor<2x64x64x320xf16> into tensor<2x4096x320xf16>
%182 = linalg.init_tensor [2, 4096, 1] : tensor<2x4096x1xf16>
%183 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%184 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%181 : tensor<2x4096x320xf16>) outs(%183 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%185 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%184 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%186 = linalg.init_tensor [2, 4096, 320] : tensor<2x4096x320xf16>
%187 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%185 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%188 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%181, %187 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%189 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%188 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%190 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%191 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%189 : tensor<2x4096x320xf16>) outs(%190 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%192 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%191 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%193 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%192 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%194 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%193 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%195 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%194 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%196 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%188, %195 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%197 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%196, %cst_28 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%198 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%197, %cst_29 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%199 = linalg.init_tensor [320, 320] : tensor<320x320xf16>
%200 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_30 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%201 = tensor.collapse_shape %198 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%202 = linalg.init_tensor [8192, 320] : tensor<8192x320xf16>
%203 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%204 = linalg.matmul ins(%201, %200 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%203 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%205 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_31 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%206 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%207 = linalg.matmul ins(%201, %205 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%206 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%208 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_32 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%209 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%210 = linalg.matmul ins(%201, %208 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%209 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%211 = tensor.expand_shape %204 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%212 = linalg.init_tensor [2, 8, 4096, 40] : tensor<2x8x4096x40xf16>
%213 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%211 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%214 = tensor.collapse_shape %213 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%215 = tensor.expand_shape %207 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%216 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%215 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%217 = tensor.collapse_shape %216 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%218 = tensor.expand_shape %210 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%219 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%218 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%220 = tensor.collapse_shape %219 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%221 = linalg.init_tensor [16, 40, 4096] : tensor<16x40x4096xf16>
%222 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%217 : tensor<16x4096x40xf16>) outs(%221 : tensor<16x40x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x40x4096xf16>
%223 = linalg.init_tensor [16, 4096, 4096] : tensor<16x4096x4096xf16>
%224 = linalg.fill ins(%cst_694 : f16) outs(%223 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%225 = linalg.batch_matmul ins(%214, %222 : tensor<16x4096x40xf16>, tensor<16x40x4096xf16>) outs(%224 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%226 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%225, %cst_1 : tensor<16x4096x4096xf16>, tensor<f64>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x4096x4096xf16>
%227 = linalg.init_tensor [16, 4096, 1] : tensor<16x4096x1xi64>
%228 = linalg.fill ins(%c0_i64 : i64) outs(%227 : tensor<16x4096x1xi64>) -> tensor<16x4096x1xi64>
%229 = linalg.init_tensor [16, 4096, 1] : tensor<16x4096x1xf16>
%230 = linalg.fill ins(%cst_696 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%231:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%226 : tensor<16x4096x4096xf16>) outs(%230, %228 : tensor<16x4096x1xf16>, tensor<16x4096x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x4096x1xf16>, tensor<16x4096x1xi64>)
%232 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%226, %231#0 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%233 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%232 : tensor<16x4096x4096xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%234 = linalg.fill ins(%cst_694 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%235 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%233 : tensor<16x4096x4096xf16>) outs(%234 : tensor<16x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x1xf16>
%236 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%233, %235 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%237 = linalg.init_tensor [16, 4096, 40] : tensor<16x4096x40xf16>
%238 = linalg.fill ins(%cst_694 : f16) outs(%237 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%239 = linalg.batch_matmul ins(%236, %220 : tensor<16x4096x4096xf16>, tensor<16x4096x40xf16>) outs(%238 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%240 = tensor.expand_shape %239 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%241 = linalg.init_tensor [2, 4096, 8, 40] : tensor<2x4096x8x40xf16>
%242 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%240 : tensor<2x8x4096x40xf16>) outs(%241 : tensor<2x4096x8x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x8x40xf16>
%243 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_33 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%244 = tensor.collapse_shape %242 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%245 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%246 = linalg.matmul ins(%244, %243 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%245 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%247 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_34, %246 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%248 = tensor.expand_shape %247 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%249 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%248, %181 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%250 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%251 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%249 : tensor<2x4096x320xf16>) outs(%250 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%252 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%251 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%253 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%252 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%254 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%249, %253 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%255 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%254 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%256 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%257 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%255 : tensor<2x4096x320xf16>) outs(%256 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%258 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%257 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%259 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%258 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%260 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%259 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%261 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%260 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%262 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%254, %261 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%263 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%262, %cst_35 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%264 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%263, %cst_36 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%265 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_37 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%266 = tensor.collapse_shape %264 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%267 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%268 = linalg.matmul ins(%266, %265 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%267 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%269 = linalg.init_tensor [768, 320] : tensor<768x320xf16>
%270 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_38 : tensor<320x768xf16>) outs(%269 : tensor<768x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x320xf16>
%271 = tensor.collapse_shape %arg2 [[0, 1], [2]] : tensor<2x77x768xf16> into tensor<154x768xf16>
%272 = linalg.init_tensor [154, 320] : tensor<154x320xf16>
%273 = linalg.fill ins(%cst_694 : f16) outs(%272 : tensor<154x320xf16>) -> tensor<154x320xf16>
%274 = linalg.matmul ins(%271, %270 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%273 : tensor<154x320xf16>) -> tensor<154x320xf16>
%275 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_39 : tensor<320x768xf16>) outs(%269 : tensor<768x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x320xf16>
%276 = linalg.fill ins(%cst_694 : f16) outs(%272 : tensor<154x320xf16>) -> tensor<154x320xf16>
%277 = linalg.matmul ins(%271, %275 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%276 : tensor<154x320xf16>) -> tensor<154x320xf16>
%278 = tensor.expand_shape %268 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%279 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%278 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%280 = tensor.collapse_shape %279 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%281 = tensor.expand_shape %274 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%282 = linalg.init_tensor [2, 8, 77, 40] : tensor<2x8x77x40xf16>
%283 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%281 : tensor<2x77x8x40xf16>) outs(%282 : tensor<2x8x77x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x40xf16>
%284 = tensor.collapse_shape %283 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%285 = tensor.expand_shape %277 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%286 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%285 : tensor<2x77x8x40xf16>) outs(%282 : tensor<2x8x77x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x40xf16>
%287 = tensor.collapse_shape %286 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%288 = linalg.init_tensor [16, 40, 77] : tensor<16x40x77xf16>
%289 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%284 : tensor<16x77x40xf16>) outs(%288 : tensor<16x40x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x40x77xf16>
%290 = linalg.init_tensor [16, 4096, 77] : tensor<16x4096x77xf16>
%291 = linalg.fill ins(%cst_694 : f16) outs(%290 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%292 = linalg.batch_matmul ins(%280, %289 : tensor<16x4096x40xf16>, tensor<16x40x77xf16>) outs(%291 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%293 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%292, %cst_1 : tensor<16x4096x77xf16>, tensor<f64>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x4096x77xf16>
%294 = linalg.fill ins(%c0_i64 : i64) outs(%227 : tensor<16x4096x1xi64>) -> tensor<16x4096x1xi64>
%295 = linalg.fill ins(%cst_696 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%296:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%293 : tensor<16x4096x77xf16>) outs(%295, %294 : tensor<16x4096x1xf16>, tensor<16x4096x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x4096x1xf16>, tensor<16x4096x1xi64>)
%297 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%293, %296#0 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%298 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%297 : tensor<16x4096x77xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%299 = linalg.fill ins(%cst_694 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%300 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%298 : tensor<16x4096x77xf16>) outs(%299 : tensor<16x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x1xf16>
%301 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%298, %300 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%302 = linalg.fill ins(%cst_694 : f16) outs(%237 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%303 = linalg.batch_matmul ins(%301, %287 : tensor<16x4096x77xf16>, tensor<16x77x40xf16>) outs(%302 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%304 = tensor.expand_shape %303 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%305 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%304 : tensor<2x8x4096x40xf16>) outs(%241 : tensor<2x4096x8x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x8x40xf16>
%306 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_40 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%307 = tensor.collapse_shape %305 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%308 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%309 = linalg.matmul ins(%307, %306 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%308 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%310 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_41, %309 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%311 = tensor.expand_shape %310 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%312 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%311, %249 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%313 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%314 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%312 : tensor<2x4096x320xf16>) outs(%313 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%315 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%314 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%316 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%315 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%317 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%312, %316 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%318 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%317 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%319 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%320 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%318 : tensor<2x4096x320xf16>) outs(%319 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%321 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%320 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%322 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%321 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%323 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%322 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%324 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%323 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%325 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%317, %324 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%326 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%325, %cst_42 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%327 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%326, %cst_43 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%328 = linalg.init_tensor [320, 2560] : tensor<320x2560xf16>
%329 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_44 : tensor<2560x320xf16>) outs(%328 : tensor<320x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x2560xf16>
%330 = tensor.collapse_shape %327 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%331 = linalg.init_tensor [8192, 2560] : tensor<8192x2560xf16>
%332 = linalg.fill ins(%cst_694 : f16) outs(%331 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%333 = linalg.matmul ins(%330, %329 : tensor<8192x320xf16>, tensor<320x2560xf16>) outs(%332 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%334 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_45, %333 : tensor<2560xf16>, tensor<8192x2560xf16>) outs(%331 : tensor<8192x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x2560xf16>
%335 = tensor.expand_shape %334 [[0, 1], [2]] : tensor<8192x2560xf16> into tensor<2x4096x2560xf16>
%336 = tensor.extract_slice %335[0, 0, 0] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%337 = tensor.extract_slice %335[0, 0, 1280] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%338 = linalg.init_tensor [2, 4096, 1280] : tensor<2x4096x1280xf16>
%339 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%337 : tensor<2x4096x1280xf16>) outs(%338 : tensor<2x4096x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x4096x1280xf16>
%340 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%336, %339 : tensor<2x4096x1280xf16>, tensor<2x4096x1280xf16>) outs(%338 : tensor<2x4096x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1280xf16>
%341 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_46 : tensor<320x1280xf16>) outs(%97 : tensor<1280x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x320xf16>
%342 = tensor.collapse_shape %340 [[0, 1], [2]] : tensor<2x4096x1280xf16> into tensor<8192x1280xf16>
%343 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%344 = linalg.matmul ins(%342, %341 : tensor<8192x1280xf16>, tensor<1280x320xf16>) outs(%343 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%345 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_47, %344 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%346 = tensor.expand_shape %345 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%347 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%346, %312 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%348 = tensor.expand_shape %347 [[0], [1, 2], [3]] : tensor<2x4096x320xf16> into tensor<2x64x64x320xf16>
%349 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%348 : tensor<2x64x64x320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%350 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_49 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%351 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%349, %cst_48 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%350 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%352 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%351, %143 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%353 = tensor.collapse_shape %352 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%354 = tensor.expand_shape %353 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%355 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%356 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%355 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%357 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%356 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%358 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%354 : tensor<2x32x10x4096xf16>) outs(%357 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%359 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%358 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%360 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%361 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%359 : tensor<2x32x10x4096xf64>) outs(%360 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%362 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%361 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%363 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%359, %362 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%364 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%363 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%365 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%366 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%364 : tensor<2x32x10x4096xf64>) outs(%365 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%367 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%366 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%368 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%367 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%369 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%370 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%358 : tensor<2x32x10x4096xf32>) outs(%369 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%371 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%370 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%372 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%368, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%373 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%372 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%374 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%354, %371 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%375 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%374, %373 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%376 = tensor.collapse_shape %375 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%377 = tensor.expand_shape %376 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%378 = tensor.expand_shape %cst_50 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%379 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%377, %378 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%380 = tensor.expand_shape %cst_51 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%381 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%379, %380 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%382 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%383 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%382 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%384 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%383 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%385 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%381 : tensor<2x320x64x64xf32>) outs(%384 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%386 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%385 : tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x320x64x64xf16>
%387 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%386, %385 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%388 = tensor.pad %387 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%389 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_53 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%390 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%388, %cst_52 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%389 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%391 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%392 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%391, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%393 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_54 : tensor<320x1280xf16>) outs(%97 : tensor<1280x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x320xf16>
%394 = linalg.fill ins(%cst_694 : f16) outs(%32 : tensor<2x320xf16>) -> tensor<2x320xf16>
%395 = linalg.matmul ins(%392, %393 : tensor<2x1280xf16>, tensor<1280x320xf16>) outs(%394 : tensor<2x320xf16>) -> tensor<2x320xf16>
%396 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_55, %395 : tensor<320xf16>, tensor<2x320xf16>) outs(%32 : tensor<2x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320xf16>
%397 = tensor.expand_shape %396 [[0], [1, 2, 3]] : tensor<2x320xf16> into tensor<2x320x1x1xf16>
%398 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%390, %397 : tensor<2x320x64x64xf16>, tensor<2x320x1x1xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%399 = tensor.collapse_shape %398 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%400 = tensor.expand_shape %399 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%401 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%402 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%401 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%403 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%402 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%404 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%400 : tensor<2x32x10x4096xf16>) outs(%403 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%405 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%404 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%406 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%407 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%405 : tensor<2x32x10x4096xf64>) outs(%406 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%408 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%407 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%409 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%405, %408 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%410 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%409 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%411 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%412 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%410 : tensor<2x32x10x4096xf64>) outs(%411 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%413 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%412 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%414 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%413 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%415 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%416 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%404 : tensor<2x32x10x4096xf32>) outs(%415 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%417 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%416 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%418 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%414, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%419 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%418 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%420 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%400, %417 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%421 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%420, %419 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%422 = tensor.collapse_shape %421 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%423 = tensor.expand_shape %422 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%424 = tensor.expand_shape %cst_56 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%425 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%423, %424 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%426 = tensor.expand_shape %cst_57 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%427 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%425, %426 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%428 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%429 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%428 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%430 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%429 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%431 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%427 : tensor<2x320x64x64xf32>) outs(%430 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%432 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%431 : tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x320x64x64xf16>
%433 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%432, %431 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%434 = tensor.pad %433 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%435 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_59 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%436 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%434, %cst_58 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%435 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%437 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%352, %436 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%438 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%437, %cst_3 : tensor<2x320x64x64xf16>, tensor<f64>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x320x64x64xf16>
%439 = tensor.collapse_shape %438 [[0], [1], [2, 3]] : tensor<2x320x64x64xf16> into tensor<2x320x4096xf16>
%440 = tensor.expand_shape %439 [[0], [1, 2], [3]] : tensor<2x320x4096xf16> into tensor<2x32x10x4096xf16>
%441 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%442 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%441 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%443 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%442 : tensor<f32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x4096xf32>
%444 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%440 : tensor<2x32x10x4096xf16>) outs(%443 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%445 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%444 : tensor<2x32x10x4096xf32>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%446 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%447 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%445 : tensor<2x32x10x4096xf64>) outs(%446 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%448 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%447 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%449 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%445, %448 : tensor<2x32x10x4096xf64>, tensor<2x32x1x1xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%450 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%449 : tensor<2x32x10x4096xf64>) outs(%59 : tensor<2x32x10x4096xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x4096xf64>
%451 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%452 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%450 : tensor<2x32x10x4096xf64>) outs(%451 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%453 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%452 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_702 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%454 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%453 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%455 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%456 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%444 : tensor<2x32x10x4096xf32>) outs(%455 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%457 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%456 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_703 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%458 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%454, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%459 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%458 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%460 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%440, %457 : tensor<2x32x10x4096xf16>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x4096xf32>
%461 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%460, %459 : tensor<2x32x10x4096xf32>, tensor<2x32x1x1xf32>) outs(%56 : tensor<2x32x10x4096xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x4096xf32>
%462 = tensor.collapse_shape %461 [[0], [1, 2], [3]] : tensor<2x32x10x4096xf32> into tensor<2x320x4096xf32>
%463 = tensor.expand_shape %462 [[0], [1], [2, 3]] : tensor<2x320x4096xf32> into tensor<2x320x64x64xf32>
%464 = tensor.expand_shape %cst_60 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%465 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%463, %464 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%466 = tensor.expand_shape %cst_61 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%467 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%465, %466 : tensor<2x320x64x64xf32>, tensor<320x1x1xf16>) outs(%82 : tensor<2x320x64x64xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x64x64xf32>
%468 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%469 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%468 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%470 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%469 : tensor<f16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%471 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%467 : tensor<2x320x64x64xf32>) outs(%470 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%472 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_63 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%473 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%471, %cst_62 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%472 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%474 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%473 : tensor<2x320x64x64xf16>) outs(%179 : tensor<2x64x64x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x64x320xf16>
%475 = tensor.collapse_shape %474 [[0], [1, 2], [3]] : tensor<2x64x64x320xf16> into tensor<2x4096x320xf16>
%476 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%477 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%475 : tensor<2x4096x320xf16>) outs(%476 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%478 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%477 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%479 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%478 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%480 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%475, %479 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%481 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%480 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%482 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%483 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%481 : tensor<2x4096x320xf16>) outs(%482 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%484 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%483 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%485 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%484 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%486 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%485 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%487 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%486 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%488 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%480, %487 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%489 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%488, %cst_64 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%490 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%489, %cst_65 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%491 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_66 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%492 = tensor.collapse_shape %490 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%493 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%494 = linalg.matmul ins(%492, %491 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%493 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%495 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_67 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%496 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%497 = linalg.matmul ins(%492, %495 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%496 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%498 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_68 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%499 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%500 = linalg.matmul ins(%492, %498 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%499 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%501 = tensor.expand_shape %494 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%502 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%501 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%503 = tensor.collapse_shape %502 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%504 = tensor.expand_shape %497 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%505 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%504 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%506 = tensor.collapse_shape %505 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%507 = tensor.expand_shape %500 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%508 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%507 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%509 = tensor.collapse_shape %508 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%510 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%506 : tensor<16x4096x40xf16>) outs(%221 : tensor<16x40x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x40x4096xf16>
%511 = linalg.fill ins(%cst_694 : f16) outs(%223 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%512 = linalg.batch_matmul ins(%503, %510 : tensor<16x4096x40xf16>, tensor<16x40x4096xf16>) outs(%511 : tensor<16x4096x4096xf16>) -> tensor<16x4096x4096xf16>
%513 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%512, %cst_1 : tensor<16x4096x4096xf16>, tensor<f64>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x4096x4096xf16>
%514 = linalg.fill ins(%c0_i64 : i64) outs(%227 : tensor<16x4096x1xi64>) -> tensor<16x4096x1xi64>
%515 = linalg.fill ins(%cst_696 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%516:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%513 : tensor<16x4096x4096xf16>) outs(%515, %514 : tensor<16x4096x1xf16>, tensor<16x4096x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x4096x1xf16>, tensor<16x4096x1xi64>)
%517 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%513, %516#0 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%518 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%517 : tensor<16x4096x4096xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%519 = linalg.fill ins(%cst_694 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%520 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%518 : tensor<16x4096x4096xf16>) outs(%519 : tensor<16x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x1xf16>
%521 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%518, %520 : tensor<16x4096x4096xf16>, tensor<16x4096x1xf16>) outs(%223 : tensor<16x4096x4096xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x4096xf16>
%522 = linalg.fill ins(%cst_694 : f16) outs(%237 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%523 = linalg.batch_matmul ins(%521, %509 : tensor<16x4096x4096xf16>, tensor<16x4096x40xf16>) outs(%522 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%524 = tensor.expand_shape %523 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%525 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%524 : tensor<2x8x4096x40xf16>) outs(%241 : tensor<2x4096x8x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x8x40xf16>
%526 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_69 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%527 = tensor.collapse_shape %525 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%528 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%529 = linalg.matmul ins(%527, %526 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%528 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%530 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_70, %529 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%531 = tensor.expand_shape %530 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%532 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%531, %475 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%533 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%534 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%532 : tensor<2x4096x320xf16>) outs(%533 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%535 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%534 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%536 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%535 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%537 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%532, %536 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%538 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%537 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%539 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%540 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%538 : tensor<2x4096x320xf16>) outs(%539 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%541 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%540 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%542 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%541 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%543 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%542 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%544 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%543 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%545 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%537, %544 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%546 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%545, %cst_71 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%547 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%546, %cst_72 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%548 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_73 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%549 = tensor.collapse_shape %547 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%550 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%551 = linalg.matmul ins(%549, %548 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%550 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%552 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_74 : tensor<320x768xf16>) outs(%269 : tensor<768x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x320xf16>
%553 = linalg.fill ins(%cst_694 : f16) outs(%272 : tensor<154x320xf16>) -> tensor<154x320xf16>
%554 = linalg.matmul ins(%271, %552 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%553 : tensor<154x320xf16>) -> tensor<154x320xf16>
%555 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_75 : tensor<320x768xf16>) outs(%269 : tensor<768x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x320xf16>
%556 = linalg.fill ins(%cst_694 : f16) outs(%272 : tensor<154x320xf16>) -> tensor<154x320xf16>
%557 = linalg.matmul ins(%271, %555 : tensor<154x768xf16>, tensor<768x320xf16>) outs(%556 : tensor<154x320xf16>) -> tensor<154x320xf16>
%558 = tensor.expand_shape %551 [[0, 1], [2, 3]] : tensor<8192x320xf16> into tensor<2x4096x8x40xf16>
%559 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%558 : tensor<2x4096x8x40xf16>) outs(%212 : tensor<2x8x4096x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x4096x40xf16>
%560 = tensor.collapse_shape %559 [[0, 1], [2], [3]] : tensor<2x8x4096x40xf16> into tensor<16x4096x40xf16>
%561 = tensor.expand_shape %554 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%562 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%561 : tensor<2x77x8x40xf16>) outs(%282 : tensor<2x8x77x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x40xf16>
%563 = tensor.collapse_shape %562 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%564 = tensor.expand_shape %557 [[0, 1], [2, 3]] : tensor<154x320xf16> into tensor<2x77x8x40xf16>
%565 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%564 : tensor<2x77x8x40xf16>) outs(%282 : tensor<2x8x77x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x40xf16>
%566 = tensor.collapse_shape %565 [[0, 1], [2], [3]] : tensor<2x8x77x40xf16> into tensor<16x77x40xf16>
%567 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%563 : tensor<16x77x40xf16>) outs(%288 : tensor<16x40x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x40x77xf16>
%568 = linalg.fill ins(%cst_694 : f16) outs(%290 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%569 = linalg.batch_matmul ins(%560, %567 : tensor<16x4096x40xf16>, tensor<16x40x77xf16>) outs(%568 : tensor<16x4096x77xf16>) -> tensor<16x4096x77xf16>
%570 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%569, %cst_1 : tensor<16x4096x77xf16>, tensor<f64>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x4096x77xf16>
%571 = linalg.fill ins(%c0_i64 : i64) outs(%227 : tensor<16x4096x1xi64>) -> tensor<16x4096x1xi64>
%572 = linalg.fill ins(%cst_696 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%573:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%570 : tensor<16x4096x77xf16>) outs(%572, %571 : tensor<16x4096x1xf16>, tensor<16x4096x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x4096x1xf16>, tensor<16x4096x1xi64>)
%574 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%570, %573#0 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%575 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%574 : tensor<16x4096x77xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%576 = linalg.fill ins(%cst_694 : f16) outs(%229 : tensor<16x4096x1xf16>) -> tensor<16x4096x1xf16>
%577 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%575 : tensor<16x4096x77xf16>) outs(%576 : tensor<16x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x1xf16>
%578 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%575, %577 : tensor<16x4096x77xf16>, tensor<16x4096x1xf16>) outs(%290 : tensor<16x4096x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x4096x77xf16>
%579 = linalg.fill ins(%cst_694 : f16) outs(%237 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%580 = linalg.batch_matmul ins(%578, %566 : tensor<16x4096x77xf16>, tensor<16x77x40xf16>) outs(%579 : tensor<16x4096x40xf16>) -> tensor<16x4096x40xf16>
%581 = tensor.expand_shape %580 [[0, 1], [2], [3]] : tensor<16x4096x40xf16> into tensor<2x8x4096x40xf16>
%582 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%581 : tensor<2x8x4096x40xf16>) outs(%241 : tensor<2x4096x8x40xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x8x40xf16>
%583 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_76 : tensor<320x320xf16>) outs(%199 : tensor<320x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x320xf16>
%584 = tensor.collapse_shape %582 [[0, 1], [2, 3]] : tensor<2x4096x8x40xf16> into tensor<8192x320xf16>
%585 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%586 = linalg.matmul ins(%584, %583 : tensor<8192x320xf16>, tensor<320x320xf16>) outs(%585 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%587 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_77, %586 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%588 = tensor.expand_shape %587 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%589 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%588, %532 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%590 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%591 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%589 : tensor<2x4096x320xf16>) outs(%590 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%592 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%591 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%593 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%592 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%594 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%589, %593 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%595 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%594 : tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%596 = linalg.fill ins(%cst_694 : f16) outs(%182 : tensor<2x4096x1xf16>) -> tensor<2x4096x1xf16>
%597 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%595 : tensor<2x4096x320xf16>) outs(%596 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%598 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%597 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_704 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%599 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%598 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x4096x1xf16>
%600 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%599 : tensor<2x4096x1xf16>) outs(%182 : tensor<2x4096x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1xf16>
%601 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%600 : tensor<2x4096x1xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x4096x320xf16>
%602 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%594, %601 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%603 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%602, %cst_78 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%604 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%603, %cst_79 : tensor<2x4096x320xf16>, tensor<320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%605 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_80 : tensor<2560x320xf16>) outs(%328 : tensor<320x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<320x2560xf16>
%606 = tensor.collapse_shape %604 [[0, 1], [2]] : tensor<2x4096x320xf16> into tensor<8192x320xf16>
%607 = linalg.fill ins(%cst_694 : f16) outs(%331 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%608 = linalg.matmul ins(%606, %605 : tensor<8192x320xf16>, tensor<320x2560xf16>) outs(%607 : tensor<8192x2560xf16>) -> tensor<8192x2560xf16>
%609 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_81, %608 : tensor<2560xf16>, tensor<8192x2560xf16>) outs(%331 : tensor<8192x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x2560xf16>
%610 = tensor.expand_shape %609 [[0, 1], [2]] : tensor<8192x2560xf16> into tensor<2x4096x2560xf16>
%611 = tensor.extract_slice %610[0, 0, 0] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%612 = tensor.extract_slice %610[0, 0, 1280] [2, 4096, 1280] [1, 1, 1] : tensor<2x4096x2560xf16> to tensor<2x4096x1280xf16>
%613 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%612 : tensor<2x4096x1280xf16>) outs(%338 : tensor<2x4096x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x4096x1280xf16>
%614 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%611, %613 : tensor<2x4096x1280xf16>, tensor<2x4096x1280xf16>) outs(%338 : tensor<2x4096x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x1280xf16>
%615 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_82 : tensor<320x1280xf16>) outs(%97 : tensor<1280x320xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x320xf16>
%616 = tensor.collapse_shape %614 [[0, 1], [2]] : tensor<2x4096x1280xf16> into tensor<8192x1280xf16>
%617 = linalg.fill ins(%cst_694 : f16) outs(%202 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%618 = linalg.matmul ins(%616, %615 : tensor<8192x1280xf16>, tensor<1280x320xf16>) outs(%617 : tensor<8192x320xf16>) -> tensor<8192x320xf16>
%619 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_83, %618 : tensor<320xf16>, tensor<8192x320xf16>) outs(%202 : tensor<8192x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<8192x320xf16>
%620 = tensor.expand_shape %619 [[0, 1], [2]] : tensor<8192x320xf16> into tensor<2x4096x320xf16>
%621 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%620, %589 : tensor<2x4096x320xf16>, tensor<2x4096x320xf16>) outs(%186 : tensor<2x4096x320xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x4096x320xf16>
%622 = tensor.expand_shape %621 [[0], [1, 2], [3]] : tensor<2x4096x320xf16> into tensor<2x64x64x320xf16>
%623 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%622 : tensor<2x64x64x320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%624 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_85 : tensor<320xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x64x64xf16>
%625 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%623, %cst_84 : tensor<2x320x64x64xf16>, tensor<320x320x1x1xf16>) outs(%624 : tensor<2x320x64x64xf16>) -> tensor<2x320x64x64xf16>
%626 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%625, %438 : tensor<2x320x64x64xf16>, tensor<2x320x64x64xf16>) outs(%49 : tensor<2x320x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x64x64xf16>
%627 = tensor.pad %626 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x64x64xf16> to tensor<2x320x66x66xf16>
%628 = linalg.init_tensor [2, 320, 32, 32] : tensor<2x320x32x32xf16>
%629 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_87 : tensor<320xf16>) outs(%628 : tensor<2x320x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x32x32xf16>
%630 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%627, %cst_86 : tensor<2x320x66x66xf16>, tensor<320x320x3x3xf16>) outs(%629 : tensor<2x320x32x32xf16>) -> tensor<2x320x32x32xf16>
%631 = tensor.collapse_shape %630 [[0], [1], [2, 3]] : tensor<2x320x32x32xf16> into tensor<2x320x1024xf16>
%632 = tensor.expand_shape %631 [[0], [1, 2], [3]] : tensor<2x320x1024xf16> into tensor<2x32x10x1024xf16>
%633 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%634 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%633 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%635 = linalg.init_tensor [2, 32, 10, 1024] : tensor<2x32x10x1024xf32>
%636 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%634 : tensor<f32>) outs(%635 : tensor<2x32x10x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x10x1024xf32>
%637 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%632 : tensor<2x32x10x1024xf16>) outs(%636 : tensor<2x32x10x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x1024xf32>
%638 = linalg.init_tensor [2, 32, 10, 1024] : tensor<2x32x10x1024xf64>
%639 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%637 : tensor<2x32x10x1024xf32>) outs(%638 : tensor<2x32x10x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x1024xf64>
%640 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%641 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%639 : tensor<2x32x10x1024xf64>) outs(%640 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%642 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%641 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%643 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%639, %642 : tensor<2x32x10x1024xf64>, tensor<2x32x1x1xf64>) outs(%638 : tensor<2x32x10x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x1024xf64>
%644 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%643 : tensor<2x32x10x1024xf64>) outs(%638 : tensor<2x32x10x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x10x1024xf64>
%645 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%646 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%644 : tensor<2x32x10x1024xf64>) outs(%645 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%647 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%646 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%648 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%647 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%649 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%650 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%637 : tensor<2x32x10x1024xf32>) outs(%649 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%651 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%650 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%652 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%648, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%653 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%652 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%654 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%632, %651 : tensor<2x32x10x1024xf16>, tensor<2x32x1x1xf32>) outs(%635 : tensor<2x32x10x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x10x1024xf32>
%655 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%654, %653 : tensor<2x32x10x1024xf32>, tensor<2x32x1x1xf32>) outs(%635 : tensor<2x32x10x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x10x1024xf32>
%656 = tensor.collapse_shape %655 [[0], [1, 2], [3]] : tensor<2x32x10x1024xf32> into tensor<2x320x1024xf32>
%657 = tensor.expand_shape %656 [[0], [1], [2, 3]] : tensor<2x320x1024xf32> into tensor<2x320x32x32xf32>
%658 = tensor.expand_shape %cst_88 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%659 = linalg.init_tensor [2, 320, 32, 32] : tensor<2x320x32x32xf32>
%660 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%657, %658 : tensor<2x320x32x32xf32>, tensor<320x1x1xf16>) outs(%659 : tensor<2x320x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x32x32xf32>
%661 = tensor.expand_shape %cst_89 [[0, 1, 2]] : tensor<320xf16> into tensor<320x1x1xf16>
%662 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%660, %661 : tensor<2x320x32x32xf32>, tensor<320x1x1xf16>) outs(%659 : tensor<2x320x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x320x32x32xf32>
%663 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%664 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%663 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%665 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%664 : tensor<f16>) outs(%628 : tensor<2x320x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x320x32x32xf16>
%666 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%662 : tensor<2x320x32x32xf32>) outs(%665 : tensor<2x320x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x320x32x32xf16>
%667 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%666 : tensor<2x320x32x32xf16>) outs(%628 : tensor<2x320x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x320x32x32xf16>
%668 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%667, %666 : tensor<2x320x32x32xf16>, tensor<2x320x32x32xf16>) outs(%628 : tensor<2x320x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x320x32x32xf16>
%669 = tensor.pad %668 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x320x32x32xf16> to tensor<2x320x34x34xf16>
%670 = linalg.init_tensor [2, 640, 32, 32] : tensor<2x640x32x32xf16>
%671 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_91 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%672 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%669, %cst_90 : tensor<2x320x34x34xf16>, tensor<640x320x3x3xf16>) outs(%671 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%673 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%674 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%673, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%675 = linalg.init_tensor [1280, 640] : tensor<1280x640xf16>
%676 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_92 : tensor<640x1280xf16>) outs(%675 : tensor<1280x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x640xf16>
%677 = linalg.init_tensor [2, 640] : tensor<2x640xf16>
%678 = linalg.fill ins(%cst_694 : f16) outs(%677 : tensor<2x640xf16>) -> tensor<2x640xf16>
%679 = linalg.matmul ins(%674, %676 : tensor<2x1280xf16>, tensor<1280x640xf16>) outs(%678 : tensor<2x640xf16>) -> tensor<2x640xf16>
%680 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_93, %679 : tensor<640xf16>, tensor<2x640xf16>) outs(%677 : tensor<2x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640xf16>
%681 = tensor.expand_shape %680 [[0], [1, 2, 3]] : tensor<2x640xf16> into tensor<2x640x1x1xf16>
%682 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%672, %681 : tensor<2x640x32x32xf16>, tensor<2x640x1x1xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%683 = tensor.collapse_shape %682 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%684 = tensor.expand_shape %683 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%685 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%686 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%685 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%687 = linalg.init_tensor [2, 32, 20, 1024] : tensor<2x32x20x1024xf32>
%688 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%686 : tensor<f32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x1024xf32>
%689 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%684 : tensor<2x32x20x1024xf16>) outs(%688 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%690 = linalg.init_tensor [2, 32, 20, 1024] : tensor<2x32x20x1024xf64>
%691 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%689 : tensor<2x32x20x1024xf32>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%692 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%693 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%691 : tensor<2x32x20x1024xf64>) outs(%692 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%694 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%693 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%695 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%691, %694 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%696 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%695 : tensor<2x32x20x1024xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%697 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%698 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%696 : tensor<2x32x20x1024xf64>) outs(%697 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%699 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%698 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%700 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%699 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%701 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%702 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%689 : tensor<2x32x20x1024xf32>) outs(%701 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%703 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%702 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%704 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%700, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%705 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%704 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%706 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%684, %703 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x1024xf32>
%707 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%706, %705 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%708 = tensor.collapse_shape %707 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%709 = tensor.expand_shape %708 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%710 = tensor.expand_shape %cst_94 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%711 = linalg.init_tensor [2, 640, 32, 32] : tensor<2x640x32x32xf32>
%712 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%709, %710 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%713 = tensor.expand_shape %cst_95 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%714 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%712, %713 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%715 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%716 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%715 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%717 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%716 : tensor<f16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%718 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%714 : tensor<2x640x32x32xf32>) outs(%717 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%719 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%718 : tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x640x32x32xf16>
%720 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%719, %718 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%721 = tensor.pad %720 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%722 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_97 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%723 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%721, %cst_96 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%722 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%724 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_99 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%725 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%630, %cst_98 : tensor<2x320x32x32xf16>, tensor<640x320x1x1xf16>) outs(%724 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%726 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%725, %723 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%727 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%726, %cst_3 : tensor<2x640x32x32xf16>, tensor<f64>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x640x32x32xf16>
%728 = tensor.collapse_shape %727 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%729 = tensor.expand_shape %728 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%730 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%731 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%730 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%732 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%731 : tensor<f32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x1024xf32>
%733 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%729 : tensor<2x32x20x1024xf16>) outs(%732 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%734 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%733 : tensor<2x32x20x1024xf32>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%735 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%736 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%734 : tensor<2x32x20x1024xf64>) outs(%735 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%737 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%736 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%738 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%734, %737 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%739 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%738 : tensor<2x32x20x1024xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%740 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%741 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%739 : tensor<2x32x20x1024xf64>) outs(%740 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%742 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%741 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%743 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%742 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%744 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%745 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%733 : tensor<2x32x20x1024xf32>) outs(%744 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%746 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%745 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%747 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%743, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%748 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%747 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%749 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%729, %746 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x1024xf32>
%750 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%749, %748 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%751 = tensor.collapse_shape %750 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%752 = tensor.expand_shape %751 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%753 = tensor.expand_shape %cst_100 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%754 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%752, %753 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%755 = tensor.expand_shape %cst_101 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%756 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%754, %755 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%757 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%758 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%757 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%759 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%758 : tensor<f16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%760 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%756 : tensor<2x640x32x32xf32>) outs(%759 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%761 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_103 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%762 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%760, %cst_102 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%761 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%763 = linalg.init_tensor [2, 32, 32, 640] : tensor<2x32x32x640xf16>
%764 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%762 : tensor<2x640x32x32xf16>) outs(%763 : tensor<2x32x32x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x32x32x640xf16>
%765 = tensor.collapse_shape %764 [[0], [1, 2], [3]] : tensor<2x32x32x640xf16> into tensor<2x1024x640xf16>
%766 = linalg.init_tensor [2, 1024, 1] : tensor<2x1024x1xf16>
%767 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%768 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%765 : tensor<2x1024x640xf16>) outs(%767 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%769 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%768 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%770 = linalg.init_tensor [2, 1024, 640] : tensor<2x1024x640xf16>
%771 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%769 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%772 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%765, %771 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%773 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%772 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%774 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%775 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%773 : tensor<2x1024x640xf16>) outs(%774 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%776 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%775 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%777 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%776 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%778 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%777 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%779 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%778 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%780 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%772, %779 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%781 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%780, %cst_104 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%782 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%781, %cst_105 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%783 = linalg.init_tensor [640, 640] : tensor<640x640xf16>
%784 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_106 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%785 = tensor.collapse_shape %782 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%786 = linalg.init_tensor [2048, 640] : tensor<2048x640xf16>
%787 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%788 = linalg.matmul ins(%785, %784 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%787 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%789 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_107 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%790 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%791 = linalg.matmul ins(%785, %789 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%790 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%792 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_108 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%793 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%794 = linalg.matmul ins(%785, %792 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%793 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%795 = tensor.expand_shape %788 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%796 = linalg.init_tensor [2, 8, 1024, 80] : tensor<2x8x1024x80xf16>
%797 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%795 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%798 = tensor.collapse_shape %797 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%799 = tensor.expand_shape %791 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%800 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%799 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%801 = tensor.collapse_shape %800 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%802 = tensor.expand_shape %794 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%803 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%802 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%804 = tensor.collapse_shape %803 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%805 = linalg.init_tensor [16, 80, 1024] : tensor<16x80x1024xf16>
%806 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%801 : tensor<16x1024x80xf16>) outs(%805 : tensor<16x80x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x80x1024xf16>
%807 = linalg.init_tensor [16, 1024, 1024] : tensor<16x1024x1024xf16>
%808 = linalg.fill ins(%cst_694 : f16) outs(%807 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%809 = linalg.batch_matmul ins(%798, %806 : tensor<16x1024x80xf16>, tensor<16x80x1024xf16>) outs(%808 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%810 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%809, %cst_0 : tensor<16x1024x1024xf16>, tensor<f64>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x1024x1024xf16>
%811 = linalg.init_tensor [16, 1024, 1] : tensor<16x1024x1xi64>
%812 = linalg.fill ins(%c0_i64 : i64) outs(%811 : tensor<16x1024x1xi64>) -> tensor<16x1024x1xi64>
%813 = linalg.init_tensor [16, 1024, 1] : tensor<16x1024x1xf16>
%814 = linalg.fill ins(%cst_696 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%815:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%810 : tensor<16x1024x1024xf16>) outs(%814, %812 : tensor<16x1024x1xf16>, tensor<16x1024x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x1024x1xf16>, tensor<16x1024x1xi64>)
%816 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%810, %815#0 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%817 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%816 : tensor<16x1024x1024xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%818 = linalg.fill ins(%cst_694 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%819 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%817 : tensor<16x1024x1024xf16>) outs(%818 : tensor<16x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1xf16>
%820 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%817, %819 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%821 = linalg.init_tensor [16, 1024, 80] : tensor<16x1024x80xf16>
%822 = linalg.fill ins(%cst_694 : f16) outs(%821 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%823 = linalg.batch_matmul ins(%820, %804 : tensor<16x1024x1024xf16>, tensor<16x1024x80xf16>) outs(%822 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%824 = tensor.expand_shape %823 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%825 = linalg.init_tensor [2, 1024, 8, 80] : tensor<2x1024x8x80xf16>
%826 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%824 : tensor<2x8x1024x80xf16>) outs(%825 : tensor<2x1024x8x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x8x80xf16>
%827 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_109 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%828 = tensor.collapse_shape %826 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%829 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%830 = linalg.matmul ins(%828, %827 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%829 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%831 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_110, %830 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%832 = tensor.expand_shape %831 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%833 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%832, %765 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%834 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%835 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%833 : tensor<2x1024x640xf16>) outs(%834 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%836 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%835 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%837 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%836 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%838 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%833, %837 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%839 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%838 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%840 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%841 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%839 : tensor<2x1024x640xf16>) outs(%840 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%842 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%841 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%843 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%842 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%844 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%843 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%845 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%844 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%846 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%838, %845 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%847 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%846, %cst_111 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%848 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%847, %cst_112 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%849 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_113 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%850 = tensor.collapse_shape %848 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%851 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%852 = linalg.matmul ins(%850, %849 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%851 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%853 = linalg.init_tensor [768, 640] : tensor<768x640xf16>
%854 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_114 : tensor<640x768xf16>) outs(%853 : tensor<768x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x640xf16>
%855 = linalg.init_tensor [154, 640] : tensor<154x640xf16>
%856 = linalg.fill ins(%cst_694 : f16) outs(%855 : tensor<154x640xf16>) -> tensor<154x640xf16>
%857 = linalg.matmul ins(%271, %854 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%856 : tensor<154x640xf16>) -> tensor<154x640xf16>
%858 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_115 : tensor<640x768xf16>) outs(%853 : tensor<768x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x640xf16>
%859 = linalg.fill ins(%cst_694 : f16) outs(%855 : tensor<154x640xf16>) -> tensor<154x640xf16>
%860 = linalg.matmul ins(%271, %858 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%859 : tensor<154x640xf16>) -> tensor<154x640xf16>
%861 = tensor.expand_shape %852 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%862 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%861 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%863 = tensor.collapse_shape %862 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%864 = tensor.expand_shape %857 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%865 = linalg.init_tensor [2, 8, 77, 80] : tensor<2x8x77x80xf16>
%866 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%864 : tensor<2x77x8x80xf16>) outs(%865 : tensor<2x8x77x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x80xf16>
%867 = tensor.collapse_shape %866 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%868 = tensor.expand_shape %860 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%869 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%868 : tensor<2x77x8x80xf16>) outs(%865 : tensor<2x8x77x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x80xf16>
%870 = tensor.collapse_shape %869 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%871 = linalg.init_tensor [16, 80, 77] : tensor<16x80x77xf16>
%872 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%867 : tensor<16x77x80xf16>) outs(%871 : tensor<16x80x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x80x77xf16>
%873 = linalg.init_tensor [16, 1024, 77] : tensor<16x1024x77xf16>
%874 = linalg.fill ins(%cst_694 : f16) outs(%873 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%875 = linalg.batch_matmul ins(%863, %872 : tensor<16x1024x80xf16>, tensor<16x80x77xf16>) outs(%874 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%876 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%875, %cst_0 : tensor<16x1024x77xf16>, tensor<f64>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x1024x77xf16>
%877 = linalg.fill ins(%c0_i64 : i64) outs(%811 : tensor<16x1024x1xi64>) -> tensor<16x1024x1xi64>
%878 = linalg.fill ins(%cst_696 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%879:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%876 : tensor<16x1024x77xf16>) outs(%878, %877 : tensor<16x1024x1xf16>, tensor<16x1024x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x1024x1xf16>, tensor<16x1024x1xi64>)
%880 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%876, %879#0 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%881 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%880 : tensor<16x1024x77xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%882 = linalg.fill ins(%cst_694 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%883 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%881 : tensor<16x1024x77xf16>) outs(%882 : tensor<16x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1xf16>
%884 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%881, %883 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%885 = linalg.fill ins(%cst_694 : f16) outs(%821 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%886 = linalg.batch_matmul ins(%884, %870 : tensor<16x1024x77xf16>, tensor<16x77x80xf16>) outs(%885 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%887 = tensor.expand_shape %886 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%888 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%887 : tensor<2x8x1024x80xf16>) outs(%825 : tensor<2x1024x8x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x8x80xf16>
%889 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_116 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%890 = tensor.collapse_shape %888 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%891 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%892 = linalg.matmul ins(%890, %889 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%891 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%893 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_117, %892 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%894 = tensor.expand_shape %893 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%895 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%894, %833 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%896 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%897 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%895 : tensor<2x1024x640xf16>) outs(%896 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%898 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%897 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%899 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%898 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%900 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%895, %899 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%901 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%900 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%902 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%903 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%901 : tensor<2x1024x640xf16>) outs(%902 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%904 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%903 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%905 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%904 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%906 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%905 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%907 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%906 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%908 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%900, %907 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%909 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%908, %cst_118 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%910 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%909, %cst_119 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%911 = linalg.init_tensor [640, 5120] : tensor<640x5120xf16>
%912 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_120 : tensor<5120x640xf16>) outs(%911 : tensor<640x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x5120xf16>
%913 = tensor.collapse_shape %910 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%914 = linalg.init_tensor [2048, 5120] : tensor<2048x5120xf16>
%915 = linalg.fill ins(%cst_694 : f16) outs(%914 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%916 = linalg.matmul ins(%913, %912 : tensor<2048x640xf16>, tensor<640x5120xf16>) outs(%915 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%917 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_121, %916 : tensor<5120xf16>, tensor<2048x5120xf16>) outs(%914 : tensor<2048x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x5120xf16>
%918 = tensor.expand_shape %917 [[0, 1], [2]] : tensor<2048x5120xf16> into tensor<2x1024x5120xf16>
%919 = tensor.extract_slice %918[0, 0, 0] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%920 = tensor.extract_slice %918[0, 0, 2560] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%921 = linalg.init_tensor [2, 1024, 2560] : tensor<2x1024x2560xf16>
%922 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%920 : tensor<2x1024x2560xf16>) outs(%921 : tensor<2x1024x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x1024x2560xf16>
%923 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%919, %922 : tensor<2x1024x2560xf16>, tensor<2x1024x2560xf16>) outs(%921 : tensor<2x1024x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x2560xf16>
%924 = linalg.init_tensor [2560, 640] : tensor<2560x640xf16>
%925 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_122 : tensor<640x2560xf16>) outs(%924 : tensor<2560x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2560x640xf16>
%926 = tensor.collapse_shape %923 [[0, 1], [2]] : tensor<2x1024x2560xf16> into tensor<2048x2560xf16>
%927 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%928 = linalg.matmul ins(%926, %925 : tensor<2048x2560xf16>, tensor<2560x640xf16>) outs(%927 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%929 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_123, %928 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%930 = tensor.expand_shape %929 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%931 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%930, %895 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%932 = tensor.expand_shape %931 [[0], [1, 2], [3]] : tensor<2x1024x640xf16> into tensor<2x32x32x640xf16>
%933 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%932 : tensor<2x32x32x640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%934 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_125 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%935 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%933, %cst_124 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%934 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%936 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%935, %727 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%937 = tensor.collapse_shape %936 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%938 = tensor.expand_shape %937 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%939 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%940 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%939 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%941 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%940 : tensor<f32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x1024xf32>
%942 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%938 : tensor<2x32x20x1024xf16>) outs(%941 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%943 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%942 : tensor<2x32x20x1024xf32>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%944 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%945 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%943 : tensor<2x32x20x1024xf64>) outs(%944 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%946 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%945 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%947 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%943, %946 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%948 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%947 : tensor<2x32x20x1024xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%949 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%950 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%948 : tensor<2x32x20x1024xf64>) outs(%949 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%951 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%950 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%952 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%951 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%953 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%954 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%942 : tensor<2x32x20x1024xf32>) outs(%953 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%955 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%954 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%956 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%952, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%957 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%956 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%958 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%938, %955 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x1024xf32>
%959 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%958, %957 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%960 = tensor.collapse_shape %959 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%961 = tensor.expand_shape %960 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%962 = tensor.expand_shape %cst_126 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%963 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%961, %962 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%964 = tensor.expand_shape %cst_127 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%965 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%963, %964 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%966 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%967 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%966 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%968 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%967 : tensor<f16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%969 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%965 : tensor<2x640x32x32xf32>) outs(%968 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%970 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%969 : tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x640x32x32xf16>
%971 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%970, %969 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%972 = tensor.pad %971 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%973 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_129 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%974 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%972, %cst_128 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%973 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%975 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%976 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%975, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%977 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_130 : tensor<640x1280xf16>) outs(%675 : tensor<1280x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x640xf16>
%978 = linalg.fill ins(%cst_694 : f16) outs(%677 : tensor<2x640xf16>) -> tensor<2x640xf16>
%979 = linalg.matmul ins(%976, %977 : tensor<2x1280xf16>, tensor<1280x640xf16>) outs(%978 : tensor<2x640xf16>) -> tensor<2x640xf16>
%980 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_131, %979 : tensor<640xf16>, tensor<2x640xf16>) outs(%677 : tensor<2x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640xf16>
%981 = tensor.expand_shape %980 [[0], [1, 2, 3]] : tensor<2x640xf16> into tensor<2x640x1x1xf16>
%982 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%974, %981 : tensor<2x640x32x32xf16>, tensor<2x640x1x1xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%983 = tensor.collapse_shape %982 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%984 = tensor.expand_shape %983 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%985 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%986 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%985 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%987 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%986 : tensor<f32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x1024xf32>
%988 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%984 : tensor<2x32x20x1024xf16>) outs(%987 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%989 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%988 : tensor<2x32x20x1024xf32>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%990 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%991 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%989 : tensor<2x32x20x1024xf64>) outs(%990 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%992 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%991 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%993 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%989, %992 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%994 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%993 : tensor<2x32x20x1024xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%995 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%996 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%994 : tensor<2x32x20x1024xf64>) outs(%995 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%997 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%996 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%998 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%997 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%999 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1000 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%988 : tensor<2x32x20x1024xf32>) outs(%999 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1001 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1000 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1002 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%998, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1003 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1002 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1004 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%984, %1001 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x1024xf32>
%1005 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1004, %1003 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%1006 = tensor.collapse_shape %1005 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%1007 = tensor.expand_shape %1006 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%1008 = tensor.expand_shape %cst_132 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1009 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1007, %1008 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%1010 = tensor.expand_shape %cst_133 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1011 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1009, %1010 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%1012 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1013 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1012 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1014 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1013 : tensor<f16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1015 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1011 : tensor<2x640x32x32xf32>) outs(%1014 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%1016 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1015 : tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x640x32x32xf16>
%1017 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1016, %1015 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%1018 = tensor.pad %1017 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%1019 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_135 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1020 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1018, %cst_134 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%1019 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%1021 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%936, %1020 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%1022 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1021, %cst_3 : tensor<2x640x32x32xf16>, tensor<f64>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x640x32x32xf16>
%1023 = tensor.collapse_shape %1022 [[0], [1], [2, 3]] : tensor<2x640x32x32xf16> into tensor<2x640x1024xf16>
%1024 = tensor.expand_shape %1023 [[0], [1, 2], [3]] : tensor<2x640x1024xf16> into tensor<2x32x20x1024xf16>
%1025 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1026 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1025 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1027 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1026 : tensor<f32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x1024xf32>
%1028 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1024 : tensor<2x32x20x1024xf16>) outs(%1027 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%1029 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1028 : tensor<2x32x20x1024xf32>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%1030 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1031 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1029 : tensor<2x32x20x1024xf64>) outs(%1030 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1032 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1031 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1033 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1029, %1032 : tensor<2x32x20x1024xf64>, tensor<2x32x1x1xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%1034 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1033 : tensor<2x32x20x1024xf64>) outs(%690 : tensor<2x32x20x1024xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x1024xf64>
%1035 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1036 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1034 : tensor<2x32x20x1024xf64>) outs(%1035 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1037 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1036 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1038 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1037 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1039 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1040 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1028 : tensor<2x32x20x1024xf32>) outs(%1039 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1041 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1040 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1042 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1038, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1043 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1042 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1044 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1024, %1041 : tensor<2x32x20x1024xf16>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x1024xf32>
%1045 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1044, %1043 : tensor<2x32x20x1024xf32>, tensor<2x32x1x1xf32>) outs(%687 : tensor<2x32x20x1024xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x1024xf32>
%1046 = tensor.collapse_shape %1045 [[0], [1, 2], [3]] : tensor<2x32x20x1024xf32> into tensor<2x640x1024xf32>
%1047 = tensor.expand_shape %1046 [[0], [1], [2, 3]] : tensor<2x640x1024xf32> into tensor<2x640x32x32xf32>
%1048 = tensor.expand_shape %cst_136 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1049 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1047, %1048 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%1050 = tensor.expand_shape %cst_137 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1051 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1049, %1050 : tensor<2x640x32x32xf32>, tensor<640x1x1xf16>) outs(%711 : tensor<2x640x32x32xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x32x32xf32>
%1052 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1053 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1052 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1054 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1053 : tensor<f16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1055 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1051 : tensor<2x640x32x32xf32>) outs(%1054 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%1056 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_139 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1057 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1055, %cst_138 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%1056 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%1058 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1057 : tensor<2x640x32x32xf16>) outs(%763 : tensor<2x32x32x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x32x32x640xf16>
%1059 = tensor.collapse_shape %1058 [[0], [1, 2], [3]] : tensor<2x32x32x640xf16> into tensor<2x1024x640xf16>
%1060 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1061 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1059 : tensor<2x1024x640xf16>) outs(%1060 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1062 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1061 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1063 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1062 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1064 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1059, %1063 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1065 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1064 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1066 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1067 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1065 : tensor<2x1024x640xf16>) outs(%1066 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1068 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1067 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1069 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1068 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%1070 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1069 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1071 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1070 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1072 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1064, %1071 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1073 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1072, %cst_140 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1074 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1073, %cst_141 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1075 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_142 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1076 = tensor.collapse_shape %1074 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%1077 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1078 = linalg.matmul ins(%1076, %1075 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1077 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1079 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_143 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1080 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1081 = linalg.matmul ins(%1076, %1079 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1080 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1082 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_144 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1083 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1084 = linalg.matmul ins(%1076, %1082 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1083 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1085 = tensor.expand_shape %1078 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%1086 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1085 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%1087 = tensor.collapse_shape %1086 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%1088 = tensor.expand_shape %1081 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%1089 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1088 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%1090 = tensor.collapse_shape %1089 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%1091 = tensor.expand_shape %1084 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%1092 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1091 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%1093 = tensor.collapse_shape %1092 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%1094 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1090 : tensor<16x1024x80xf16>) outs(%805 : tensor<16x80x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x80x1024xf16>
%1095 = linalg.fill ins(%cst_694 : f16) outs(%807 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%1096 = linalg.batch_matmul ins(%1087, %1094 : tensor<16x1024x80xf16>, tensor<16x80x1024xf16>) outs(%1095 : tensor<16x1024x1024xf16>) -> tensor<16x1024x1024xf16>
%1097 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1096, %cst_0 : tensor<16x1024x1024xf16>, tensor<f64>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x1024x1024xf16>
%1098 = linalg.fill ins(%c0_i64 : i64) outs(%811 : tensor<16x1024x1xi64>) -> tensor<16x1024x1xi64>
%1099 = linalg.fill ins(%cst_696 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%1100:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1097 : tensor<16x1024x1024xf16>) outs(%1099, %1098 : tensor<16x1024x1xf16>, tensor<16x1024x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x1024x1xf16>, tensor<16x1024x1xi64>)
%1101 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1097, %1100#0 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%1102 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1101 : tensor<16x1024x1024xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%1103 = linalg.fill ins(%cst_694 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%1104 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1102 : tensor<16x1024x1024xf16>) outs(%1103 : tensor<16x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1xf16>
%1105 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1102, %1104 : tensor<16x1024x1024xf16>, tensor<16x1024x1xf16>) outs(%807 : tensor<16x1024x1024xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1024xf16>
%1106 = linalg.fill ins(%cst_694 : f16) outs(%821 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%1107 = linalg.batch_matmul ins(%1105, %1093 : tensor<16x1024x1024xf16>, tensor<16x1024x80xf16>) outs(%1106 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%1108 = tensor.expand_shape %1107 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%1109 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1108 : tensor<2x8x1024x80xf16>) outs(%825 : tensor<2x1024x8x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x8x80xf16>
%1110 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_145 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1111 = tensor.collapse_shape %1109 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%1112 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1113 = linalg.matmul ins(%1111, %1110 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1112 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1114 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_146, %1113 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%1115 = tensor.expand_shape %1114 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%1116 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1115, %1059 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1117 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1118 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1116 : tensor<2x1024x640xf16>) outs(%1117 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1119 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1118 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1120 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1119 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1121 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1116, %1120 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1122 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1121 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1123 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1124 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1122 : tensor<2x1024x640xf16>) outs(%1123 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1125 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1124 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1126 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1125 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%1127 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1126 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1128 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1127 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1129 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1121, %1128 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1130 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1129, %cst_147 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1131 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1130, %cst_148 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1132 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_149 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1133 = tensor.collapse_shape %1131 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%1134 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1135 = linalg.matmul ins(%1133, %1132 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1134 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1136 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_150 : tensor<640x768xf16>) outs(%853 : tensor<768x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x640xf16>
%1137 = linalg.fill ins(%cst_694 : f16) outs(%855 : tensor<154x640xf16>) -> tensor<154x640xf16>
%1138 = linalg.matmul ins(%271, %1136 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%1137 : tensor<154x640xf16>) -> tensor<154x640xf16>
%1139 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_151 : tensor<640x768xf16>) outs(%853 : tensor<768x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x640xf16>
%1140 = linalg.fill ins(%cst_694 : f16) outs(%855 : tensor<154x640xf16>) -> tensor<154x640xf16>
%1141 = linalg.matmul ins(%271, %1139 : tensor<154x768xf16>, tensor<768x640xf16>) outs(%1140 : tensor<154x640xf16>) -> tensor<154x640xf16>
%1142 = tensor.expand_shape %1135 [[0, 1], [2, 3]] : tensor<2048x640xf16> into tensor<2x1024x8x80xf16>
%1143 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1142 : tensor<2x1024x8x80xf16>) outs(%796 : tensor<2x8x1024x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x1024x80xf16>
%1144 = tensor.collapse_shape %1143 [[0, 1], [2], [3]] : tensor<2x8x1024x80xf16> into tensor<16x1024x80xf16>
%1145 = tensor.expand_shape %1138 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%1146 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1145 : tensor<2x77x8x80xf16>) outs(%865 : tensor<2x8x77x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x80xf16>
%1147 = tensor.collapse_shape %1146 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%1148 = tensor.expand_shape %1141 [[0, 1], [2, 3]] : tensor<154x640xf16> into tensor<2x77x8x80xf16>
%1149 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1148 : tensor<2x77x8x80xf16>) outs(%865 : tensor<2x8x77x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x80xf16>
%1150 = tensor.collapse_shape %1149 [[0, 1], [2], [3]] : tensor<2x8x77x80xf16> into tensor<16x77x80xf16>
%1151 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1147 : tensor<16x77x80xf16>) outs(%871 : tensor<16x80x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x80x77xf16>
%1152 = linalg.fill ins(%cst_694 : f16) outs(%873 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%1153 = linalg.batch_matmul ins(%1144, %1151 : tensor<16x1024x80xf16>, tensor<16x80x77xf16>) outs(%1152 : tensor<16x1024x77xf16>) -> tensor<16x1024x77xf16>
%1154 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1153, %cst_0 : tensor<16x1024x77xf16>, tensor<f64>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x1024x77xf16>
%1155 = linalg.fill ins(%c0_i64 : i64) outs(%811 : tensor<16x1024x1xi64>) -> tensor<16x1024x1xi64>
%1156 = linalg.fill ins(%cst_696 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%1157:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1154 : tensor<16x1024x77xf16>) outs(%1156, %1155 : tensor<16x1024x1xf16>, tensor<16x1024x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x1024x1xf16>, tensor<16x1024x1xi64>)
%1158 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1154, %1157#0 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%1159 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1158 : tensor<16x1024x77xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%1160 = linalg.fill ins(%cst_694 : f16) outs(%813 : tensor<16x1024x1xf16>) -> tensor<16x1024x1xf16>
%1161 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1159 : tensor<16x1024x77xf16>) outs(%1160 : tensor<16x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x1xf16>
%1162 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1159, %1161 : tensor<16x1024x77xf16>, tensor<16x1024x1xf16>) outs(%873 : tensor<16x1024x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x1024x77xf16>
%1163 = linalg.fill ins(%cst_694 : f16) outs(%821 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%1164 = linalg.batch_matmul ins(%1162, %1150 : tensor<16x1024x77xf16>, tensor<16x77x80xf16>) outs(%1163 : tensor<16x1024x80xf16>) -> tensor<16x1024x80xf16>
%1165 = tensor.expand_shape %1164 [[0, 1], [2], [3]] : tensor<16x1024x80xf16> into tensor<2x8x1024x80xf16>
%1166 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1165 : tensor<2x8x1024x80xf16>) outs(%825 : tensor<2x1024x8x80xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x8x80xf16>
%1167 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_152 : tensor<640x640xf16>) outs(%783 : tensor<640x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x640xf16>
%1168 = tensor.collapse_shape %1166 [[0, 1], [2, 3]] : tensor<2x1024x8x80xf16> into tensor<2048x640xf16>
%1169 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1170 = linalg.matmul ins(%1168, %1167 : tensor<2048x640xf16>, tensor<640x640xf16>) outs(%1169 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1171 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_153, %1170 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%1172 = tensor.expand_shape %1171 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%1173 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1172, %1116 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1174 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1175 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1173 : tensor<2x1024x640xf16>) outs(%1174 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1176 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1175 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1177 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1176 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1178 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1173, %1177 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1179 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1178 : tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1180 = linalg.fill ins(%cst_694 : f16) outs(%766 : tensor<2x1024x1xf16>) -> tensor<2x1024x1xf16>
%1181 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1179 : tensor<2x1024x640xf16>) outs(%1180 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1182 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1181 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_709 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1183 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1182 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1024x1xf16>
%1184 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1183 : tensor<2x1024x1xf16>) outs(%766 : tensor<2x1024x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x1xf16>
%1185 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1184 : tensor<2x1024x1xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1024x640xf16>
%1186 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1178, %1185 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1187 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1186, %cst_154 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1188 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1187, %cst_155 : tensor<2x1024x640xf16>, tensor<640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1189 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_156 : tensor<5120x640xf16>) outs(%911 : tensor<640x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<640x5120xf16>
%1190 = tensor.collapse_shape %1188 [[0, 1], [2]] : tensor<2x1024x640xf16> into tensor<2048x640xf16>
%1191 = linalg.fill ins(%cst_694 : f16) outs(%914 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%1192 = linalg.matmul ins(%1190, %1189 : tensor<2048x640xf16>, tensor<640x5120xf16>) outs(%1191 : tensor<2048x5120xf16>) -> tensor<2048x5120xf16>
%1193 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_157, %1192 : tensor<5120xf16>, tensor<2048x5120xf16>) outs(%914 : tensor<2048x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x5120xf16>
%1194 = tensor.expand_shape %1193 [[0, 1], [2]] : tensor<2048x5120xf16> into tensor<2x1024x5120xf16>
%1195 = tensor.extract_slice %1194[0, 0, 0] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%1196 = tensor.extract_slice %1194[0, 0, 2560] [2, 1024, 2560] [1, 1, 1] : tensor<2x1024x5120xf16> to tensor<2x1024x2560xf16>
%1197 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1196 : tensor<2x1024x2560xf16>) outs(%921 : tensor<2x1024x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x1024x2560xf16>
%1198 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1195, %1197 : tensor<2x1024x2560xf16>, tensor<2x1024x2560xf16>) outs(%921 : tensor<2x1024x2560xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x2560xf16>
%1199 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_158 : tensor<640x2560xf16>) outs(%924 : tensor<2560x640xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2560x640xf16>
%1200 = tensor.collapse_shape %1198 [[0, 1], [2]] : tensor<2x1024x2560xf16> into tensor<2048x2560xf16>
%1201 = linalg.fill ins(%cst_694 : f16) outs(%786 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1202 = linalg.matmul ins(%1200, %1199 : tensor<2048x2560xf16>, tensor<2560x640xf16>) outs(%1201 : tensor<2048x640xf16>) -> tensor<2048x640xf16>
%1203 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_159, %1202 : tensor<640xf16>, tensor<2048x640xf16>) outs(%786 : tensor<2048x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2048x640xf16>
%1204 = tensor.expand_shape %1203 [[0, 1], [2]] : tensor<2048x640xf16> into tensor<2x1024x640xf16>
%1205 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1204, %1173 : tensor<2x1024x640xf16>, tensor<2x1024x640xf16>) outs(%770 : tensor<2x1024x640xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1024x640xf16>
%1206 = tensor.expand_shape %1205 [[0], [1, 2], [3]] : tensor<2x1024x640xf16> into tensor<2x32x32x640xf16>
%1207 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1206 : tensor<2x32x32x640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1208 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_161 : tensor<640xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x32x32xf16>
%1209 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1207, %cst_160 : tensor<2x640x32x32xf16>, tensor<640x640x1x1xf16>) outs(%1208 : tensor<2x640x32x32xf16>) -> tensor<2x640x32x32xf16>
%1210 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1209, %1022 : tensor<2x640x32x32xf16>, tensor<2x640x32x32xf16>) outs(%670 : tensor<2x640x32x32xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x32x32xf16>
%1211 = tensor.pad %1210 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x640x32x32xf16> to tensor<2x640x34x34xf16>
%1212 = linalg.init_tensor [2, 640, 16, 16] : tensor<2x640x16x16xf16>
%1213 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_163 : tensor<640xf16>) outs(%1212 : tensor<2x640x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x16x16xf16>
%1214 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%1211, %cst_162 : tensor<2x640x34x34xf16>, tensor<640x640x3x3xf16>) outs(%1213 : tensor<2x640x16x16xf16>) -> tensor<2x640x16x16xf16>
%1215 = tensor.collapse_shape %1214 [[0], [1], [2, 3]] : tensor<2x640x16x16xf16> into tensor<2x640x256xf16>
%1216 = tensor.expand_shape %1215 [[0], [1, 2], [3]] : tensor<2x640x256xf16> into tensor<2x32x20x256xf16>
%1217 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1218 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1217 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1219 = linalg.init_tensor [2, 32, 20, 256] : tensor<2x32x20x256xf32>
%1220 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1218 : tensor<f32>) outs(%1219 : tensor<2x32x20x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x20x256xf32>
%1221 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1216 : tensor<2x32x20x256xf16>) outs(%1220 : tensor<2x32x20x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x256xf32>
%1222 = linalg.init_tensor [2, 32, 20, 256] : tensor<2x32x20x256xf64>
%1223 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1221 : tensor<2x32x20x256xf32>) outs(%1222 : tensor<2x32x20x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x256xf64>
%1224 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1225 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1223 : tensor<2x32x20x256xf64>) outs(%1224 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1226 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1225 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1227 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1223, %1226 : tensor<2x32x20x256xf64>, tensor<2x32x1x1xf64>) outs(%1222 : tensor<2x32x20x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x256xf64>
%1228 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1227 : tensor<2x32x20x256xf64>) outs(%1222 : tensor<2x32x20x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x20x256xf64>
%1229 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1230 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1228 : tensor<2x32x20x256xf64>) outs(%1229 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1231 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1230 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1232 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1231 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1233 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1234 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1221 : tensor<2x32x20x256xf32>) outs(%1233 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1235 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1234 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_711 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1236 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1232, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1237 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1236 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1238 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1216, %1235 : tensor<2x32x20x256xf16>, tensor<2x32x1x1xf32>) outs(%1219 : tensor<2x32x20x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x20x256xf32>
%1239 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1238, %1237 : tensor<2x32x20x256xf32>, tensor<2x32x1x1xf32>) outs(%1219 : tensor<2x32x20x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x20x256xf32>
%1240 = tensor.collapse_shape %1239 [[0], [1, 2], [3]] : tensor<2x32x20x256xf32> into tensor<2x640x256xf32>
%1241 = tensor.expand_shape %1240 [[0], [1], [2, 3]] : tensor<2x640x256xf32> into tensor<2x640x16x16xf32>
%1242 = tensor.expand_shape %cst_164 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1243 = linalg.init_tensor [2, 640, 16, 16] : tensor<2x640x16x16xf32>
%1244 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1241, %1242 : tensor<2x640x16x16xf32>, tensor<640x1x1xf16>) outs(%1243 : tensor<2x640x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x16x16xf32>
%1245 = tensor.expand_shape %cst_165 [[0, 1, 2]] : tensor<640xf16> into tensor<640x1x1xf16>
%1246 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1244, %1245 : tensor<2x640x16x16xf32>, tensor<640x1x1xf16>) outs(%1243 : tensor<2x640x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x640x16x16xf32>
%1247 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1248 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1247 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1249 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1248 : tensor<f16>) outs(%1212 : tensor<2x640x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x640x16x16xf16>
%1250 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1246 : tensor<2x640x16x16xf32>) outs(%1249 : tensor<2x640x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x640x16x16xf16>
%1251 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1250 : tensor<2x640x16x16xf16>) outs(%1212 : tensor<2x640x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x640x16x16xf16>
%1252 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1251, %1250 : tensor<2x640x16x16xf16>, tensor<2x640x16x16xf16>) outs(%1212 : tensor<2x640x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x640x16x16xf16>
%1253 = tensor.pad %1252 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x640x16x16xf16> to tensor<2x640x18x18xf16>
%1254 = linalg.init_tensor [2, 1280, 16, 16] : tensor<2x1280x16x16xf16>
%1255 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_167 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1256 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1253, %cst_166 : tensor<2x640x18x18xf16>, tensor<1280x640x3x3xf16>) outs(%1255 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1257 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%1258 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%1257, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1259 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_168 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1260 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1261 = linalg.matmul ins(%1258, %1259 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1260 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1262 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_169, %1261 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1263 = tensor.expand_shape %1262 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1264 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1256, %1263 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1265 = tensor.collapse_shape %1264 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%1266 = tensor.expand_shape %1265 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1267 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1268 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1267 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1269 = linalg.init_tensor [2, 32, 40, 256] : tensor<2x32x40x256xf32>
%1270 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1268 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%1271 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1266 : tensor<2x32x40x256xf16>) outs(%1270 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1272 = linalg.init_tensor [2, 32, 40, 256] : tensor<2x32x40x256xf64>
%1273 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1271 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1274 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1275 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1273 : tensor<2x32x40x256xf64>) outs(%1274 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1276 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1275 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1277 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1273, %1276 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1278 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1277 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1279 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1280 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1278 : tensor<2x32x40x256xf64>) outs(%1279 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1281 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1280 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1282 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1281 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1283 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1284 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1271 : tensor<2x32x40x256xf32>) outs(%1283 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1285 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1284 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1286 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1282, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1287 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1286 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1288 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1266, %1285 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%1289 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1288, %1287 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1290 = tensor.collapse_shape %1289 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%1291 = tensor.expand_shape %1290 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%1292 = tensor.expand_shape %cst_170 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1293 = linalg.init_tensor [2, 1280, 16, 16] : tensor<2x1280x16x16xf32>
%1294 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1291, %1292 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1295 = tensor.expand_shape %cst_171 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1296 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1294, %1295 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1297 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1298 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1297 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1299 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1298 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1300 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1296 : tensor<2x1280x16x16xf32>) outs(%1299 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1301 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1300 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%1302 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1301, %1300 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1303 = tensor.pad %1302 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1304 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_173 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1305 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1303, %cst_172 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1304 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1306 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_175 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1307 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1214, %cst_174 : tensor<2x640x16x16xf16>, tensor<1280x640x1x1xf16>) outs(%1306 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1308 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1307, %1305 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1309 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1308, %cst_3 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x16x16xf16>
%1310 = tensor.collapse_shape %1309 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%1311 = tensor.expand_shape %1310 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1312 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1313 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1312 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1314 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1313 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%1315 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1311 : tensor<2x32x40x256xf16>) outs(%1314 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1316 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1315 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1317 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1318 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1316 : tensor<2x32x40x256xf64>) outs(%1317 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1319 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1318 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1320 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1316, %1319 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1321 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1320 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1322 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1323 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1321 : tensor<2x32x40x256xf64>) outs(%1322 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1324 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1323 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1325 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1324 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1326 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1327 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1315 : tensor<2x32x40x256xf32>) outs(%1326 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1328 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1327 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1329 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1325, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1330 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1329 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1331 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1311, %1328 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%1332 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1331, %1330 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1333 = tensor.collapse_shape %1332 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%1334 = tensor.expand_shape %1333 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%1335 = tensor.expand_shape %cst_176 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1336 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1334, %1335 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1337 = tensor.expand_shape %cst_177 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1338 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1336, %1337 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1339 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1340 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1339 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1341 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1340 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1342 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1338 : tensor<2x1280x16x16xf32>) outs(%1341 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1343 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_179 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1344 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1342, %cst_178 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1343 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1345 = linalg.init_tensor [2, 16, 16, 1280] : tensor<2x16x16x1280xf16>
%1346 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1344 : tensor<2x1280x16x16xf16>) outs(%1345 : tensor<2x16x16x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x16x16x1280xf16>
%1347 = tensor.collapse_shape %1346 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%1348 = linalg.init_tensor [2, 256, 1] : tensor<2x256x1xf16>
%1349 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1350 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1347 : tensor<2x256x1280xf16>) outs(%1349 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1351 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1350 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1352 = linalg.init_tensor [2, 256, 1280] : tensor<2x256x1280xf16>
%1353 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1351 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1354 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1347, %1353 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1355 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1354 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1356 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1357 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1355 : tensor<2x256x1280xf16>) outs(%1356 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1358 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1357 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1359 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1358 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1360 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1359 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1361 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1360 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1362 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1354, %1361 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1363 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1362, %cst_180 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1364 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1363, %cst_181 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1365 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_182 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1366 = tensor.collapse_shape %1364 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1367 = linalg.init_tensor [512, 1280] : tensor<512x1280xf16>
%1368 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1369 = linalg.matmul ins(%1366, %1365 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1368 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1370 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_183 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1371 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1372 = linalg.matmul ins(%1366, %1370 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1371 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1373 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_184 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1374 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1375 = linalg.matmul ins(%1366, %1373 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1374 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1376 = tensor.expand_shape %1369 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1377 = linalg.init_tensor [2, 8, 256, 160] : tensor<2x8x256x160xf16>
%1378 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1376 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1379 = tensor.collapse_shape %1378 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1380 = tensor.expand_shape %1372 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1381 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1380 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1382 = tensor.collapse_shape %1381 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1383 = tensor.expand_shape %1375 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1384 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1383 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1385 = tensor.collapse_shape %1384 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1386 = linalg.init_tensor [16, 160, 256] : tensor<16x160x256xf16>
%1387 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1382 : tensor<16x256x160xf16>) outs(%1386 : tensor<16x160x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x256xf16>
%1388 = linalg.init_tensor [16, 256, 256] : tensor<16x256x256xf16>
%1389 = linalg.fill ins(%cst_694 : f16) outs(%1388 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1390 = linalg.batch_matmul ins(%1379, %1387 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%1389 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1391 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1390, %cst : tensor<16x256x256xf16>, tensor<f64>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x256xf16>
%1392 = linalg.init_tensor [16, 256, 1] : tensor<16x256x1xi64>
%1393 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%1394 = linalg.init_tensor [16, 256, 1] : tensor<16x256x1xf16>
%1395 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1396:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1391 : tensor<16x256x256xf16>) outs(%1395, %1393 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%1397 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1391, %1396#0 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1398 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1397 : tensor<16x256x256xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1399 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1400 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1398 : tensor<16x256x256xf16>) outs(%1399 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%1401 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1398, %1400 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1402 = linalg.init_tensor [16, 256, 160] : tensor<16x256x160xf16>
%1403 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1404 = linalg.batch_matmul ins(%1401, %1385 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%1403 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1405 = tensor.expand_shape %1404 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1406 = linalg.init_tensor [2, 256, 8, 160] : tensor<2x256x8x160xf16>
%1407 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1405 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%1408 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_185 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1409 = tensor.collapse_shape %1407 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1410 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1411 = linalg.matmul ins(%1409, %1408 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1410 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1412 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_186, %1411 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1413 = tensor.expand_shape %1412 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1414 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1413, %1347 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1415 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1416 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1414 : tensor<2x256x1280xf16>) outs(%1415 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1417 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1416 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1418 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1417 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1419 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1414, %1418 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1420 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1419 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1421 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1422 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1420 : tensor<2x256x1280xf16>) outs(%1421 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1423 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1422 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1424 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1423 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1425 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1424 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1426 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1425 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1427 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1419, %1426 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1428 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1427, %cst_187 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1429 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1428, %cst_188 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1430 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_189 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1431 = tensor.collapse_shape %1429 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1432 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1433 = linalg.matmul ins(%1431, %1430 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1432 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1434 = linalg.init_tensor [768, 1280] : tensor<768x1280xf16>
%1435 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_190 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%1436 = linalg.init_tensor [154, 1280] : tensor<154x1280xf16>
%1437 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1438 = linalg.matmul ins(%271, %1435 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1437 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1439 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_191 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%1440 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1441 = linalg.matmul ins(%271, %1439 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1440 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1442 = tensor.expand_shape %1433 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1443 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1442 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1444 = tensor.collapse_shape %1443 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1445 = tensor.expand_shape %1438 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1446 = linalg.init_tensor [2, 8, 77, 160] : tensor<2x8x77x160xf16>
%1447 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1445 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%1448 = tensor.collapse_shape %1447 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1449 = tensor.expand_shape %1441 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1450 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1449 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%1451 = tensor.collapse_shape %1450 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1452 = linalg.init_tensor [16, 160, 77] : tensor<16x160x77xf16>
%1453 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1448 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%1454 = linalg.init_tensor [16, 256, 77] : tensor<16x256x77xf16>
%1455 = linalg.fill ins(%cst_694 : f16) outs(%1454 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1456 = linalg.batch_matmul ins(%1444, %1453 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%1455 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1457 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1456, %cst : tensor<16x256x77xf16>, tensor<f64>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x77xf16>
%1458 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%1459 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1460:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1457 : tensor<16x256x77xf16>) outs(%1459, %1458 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%1461 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1457, %1460#0 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1462 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1461 : tensor<16x256x77xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1463 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1464 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1462 : tensor<16x256x77xf16>) outs(%1463 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%1465 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1462, %1464 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1466 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1467 = linalg.batch_matmul ins(%1465, %1451 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%1466 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1468 = tensor.expand_shape %1467 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1469 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1468 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%1470 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_192 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1471 = tensor.collapse_shape %1469 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1472 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1473 = linalg.matmul ins(%1471, %1470 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1472 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1474 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_193, %1473 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1475 = tensor.expand_shape %1474 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1476 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1475, %1414 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1477 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1478 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1476 : tensor<2x256x1280xf16>) outs(%1477 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1479 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1478 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1480 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1479 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1481 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1476, %1480 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1482 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1481 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1483 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1484 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1482 : tensor<2x256x1280xf16>) outs(%1483 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1485 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1484 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1486 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1485 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1487 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1486 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1488 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1487 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1489 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1481, %1488 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1490 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1489, %cst_194 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1491 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1490, %cst_195 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1492 = linalg.init_tensor [1280, 10240] : tensor<1280x10240xf16>
%1493 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_196 : tensor<10240x1280xf16>) outs(%1492 : tensor<1280x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x10240xf16>
%1494 = tensor.collapse_shape %1491 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1495 = linalg.init_tensor [512, 10240] : tensor<512x10240xf16>
%1496 = linalg.fill ins(%cst_694 : f16) outs(%1495 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1497 = linalg.matmul ins(%1494, %1493 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%1496 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1498 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_197, %1497 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1495 : tensor<512x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x10240xf16>
%1499 = tensor.expand_shape %1498 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%1500 = tensor.extract_slice %1499[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1501 = tensor.extract_slice %1499[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1502 = linalg.init_tensor [2, 256, 5120] : tensor<2x256x5120xf16>
%1503 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1501 : tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x256x5120xf16>
%1504 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1500, %1503 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x5120xf16>
%1505 = linalg.init_tensor [5120, 1280] : tensor<5120x1280xf16>
%1506 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_198 : tensor<1280x5120xf16>) outs(%1505 : tensor<5120x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<5120x1280xf16>
%1507 = tensor.collapse_shape %1504 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%1508 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1509 = linalg.matmul ins(%1507, %1506 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%1508 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1510 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_199, %1509 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1511 = tensor.expand_shape %1510 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1512 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1511, %1476 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1513 = tensor.expand_shape %1512 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%1514 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1513 : tensor<2x16x16x1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1515 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_201 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1516 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1514, %cst_200 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1515 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1517 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1516, %1309 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1518 = tensor.collapse_shape %1517 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%1519 = tensor.expand_shape %1518 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1520 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1521 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1520 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1522 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1521 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%1523 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1519 : tensor<2x32x40x256xf16>) outs(%1522 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1524 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1523 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1525 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1526 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1524 : tensor<2x32x40x256xf64>) outs(%1525 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1527 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1526 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1528 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1524, %1527 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1529 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1528 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1530 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1531 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1529 : tensor<2x32x40x256xf64>) outs(%1530 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1532 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1531 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1533 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1532 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1534 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1535 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1523 : tensor<2x32x40x256xf32>) outs(%1534 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1536 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1535 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1537 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1533, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1538 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1537 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1539 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1519, %1536 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%1540 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1539, %1538 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1541 = tensor.collapse_shape %1540 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%1542 = tensor.expand_shape %1541 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%1543 = tensor.expand_shape %cst_202 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1544 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1542, %1543 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1545 = tensor.expand_shape %cst_203 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1546 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1544, %1545 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1547 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1548 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1547 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1549 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1548 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1550 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1546 : tensor<2x1280x16x16xf32>) outs(%1549 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1551 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1550 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%1552 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1551, %1550 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1553 = tensor.pad %1552 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1554 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_205 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1555 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1553, %cst_204 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1554 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1556 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%1557 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%1556, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1558 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_206 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1559 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1560 = linalg.matmul ins(%1557, %1558 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1559 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1561 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_207, %1560 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1562 = tensor.expand_shape %1561 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1563 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1555, %1562 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1564 = tensor.collapse_shape %1563 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%1565 = tensor.expand_shape %1564 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1566 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1567 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1566 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1568 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1567 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%1569 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1565 : tensor<2x32x40x256xf16>) outs(%1568 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1570 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1569 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1571 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1572 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1570 : tensor<2x32x40x256xf64>) outs(%1571 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1573 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1572 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1574 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1570, %1573 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1575 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1574 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1576 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1577 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1575 : tensor<2x32x40x256xf64>) outs(%1576 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1578 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1577 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1579 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1578 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1580 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1581 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1569 : tensor<2x32x40x256xf32>) outs(%1580 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1582 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1581 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1583 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1579, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1584 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1583 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1585 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1565, %1582 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%1586 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1585, %1584 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1587 = tensor.collapse_shape %1586 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%1588 = tensor.expand_shape %1587 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%1589 = tensor.expand_shape %cst_208 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1590 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1588, %1589 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1591 = tensor.expand_shape %cst_209 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1592 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1590, %1591 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1593 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1594 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1593 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1595 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1594 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1596 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1592 : tensor<2x1280x16x16xf32>) outs(%1595 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1597 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1596 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%1598 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1597, %1596 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1599 = tensor.pad %1598 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1600 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_211 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1601 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1599, %cst_210 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1600 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1602 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1517, %1601 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1603 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1602, %cst_3 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x16x16xf16>
%1604 = tensor.collapse_shape %1603 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%1605 = tensor.expand_shape %1604 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%1606 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1607 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1606 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1608 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1607 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%1609 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1605 : tensor<2x32x40x256xf16>) outs(%1608 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1610 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1609 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1611 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1612 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1610 : tensor<2x32x40x256xf64>) outs(%1611 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1613 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1612 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1614 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1610, %1613 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1615 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1614 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%1616 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1617 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1615 : tensor<2x32x40x256xf64>) outs(%1616 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1618 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1617 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1619 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1618 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1620 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1621 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1609 : tensor<2x32x40x256xf32>) outs(%1620 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1622 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1621 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1623 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1619, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1624 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1623 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1625 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1605, %1622 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%1626 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1625, %1624 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%1627 = tensor.collapse_shape %1626 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%1628 = tensor.expand_shape %1627 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%1629 = tensor.expand_shape %cst_212 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1630 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1628, %1629 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1631 = tensor.expand_shape %cst_213 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1632 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1630, %1631 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%1633 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1634 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1633 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1635 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1634 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1636 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1632 : tensor<2x1280x16x16xf32>) outs(%1635 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1637 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_215 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1638 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1636, %cst_214 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1637 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1639 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1638 : tensor<2x1280x16x16xf16>) outs(%1345 : tensor<2x16x16x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x16x16x1280xf16>
%1640 = tensor.collapse_shape %1639 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%1641 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1642 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1640 : tensor<2x256x1280xf16>) outs(%1641 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1643 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1642 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1644 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1643 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1645 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1640, %1644 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1646 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1645 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1647 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1648 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1646 : tensor<2x256x1280xf16>) outs(%1647 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1649 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1648 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1650 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1649 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1651 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1650 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1652 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1651 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1653 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1645, %1652 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1654 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1653, %cst_216 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1655 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1654, %cst_217 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1656 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_218 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1657 = tensor.collapse_shape %1655 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1658 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1659 = linalg.matmul ins(%1657, %1656 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1658 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1660 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_219 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1661 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1662 = linalg.matmul ins(%1657, %1660 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1661 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1663 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_220 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1664 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1665 = linalg.matmul ins(%1657, %1663 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1664 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1666 = tensor.expand_shape %1659 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1667 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1666 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1668 = tensor.collapse_shape %1667 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1669 = tensor.expand_shape %1662 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1670 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1669 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1671 = tensor.collapse_shape %1670 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1672 = tensor.expand_shape %1665 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1673 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1672 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1674 = tensor.collapse_shape %1673 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1675 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1671 : tensor<16x256x160xf16>) outs(%1386 : tensor<16x160x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x256xf16>
%1676 = linalg.fill ins(%cst_694 : f16) outs(%1388 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1677 = linalg.batch_matmul ins(%1668, %1675 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%1676 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%1678 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1677, %cst : tensor<16x256x256xf16>, tensor<f64>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x256xf16>
%1679 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%1680 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1681:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1678 : tensor<16x256x256xf16>) outs(%1680, %1679 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%1682 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1678, %1681#0 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1683 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1682 : tensor<16x256x256xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1684 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1685 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1683 : tensor<16x256x256xf16>) outs(%1684 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%1686 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1683, %1685 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%1687 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1688 = linalg.batch_matmul ins(%1686, %1674 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%1687 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1689 = tensor.expand_shape %1688 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1690 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1689 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%1691 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_221 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1692 = tensor.collapse_shape %1690 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1693 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1694 = linalg.matmul ins(%1692, %1691 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1693 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1695 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_222, %1694 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1696 = tensor.expand_shape %1695 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1697 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1696, %1640 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1698 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1699 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1697 : tensor<2x256x1280xf16>) outs(%1698 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1700 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1699 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1701 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1700 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1702 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1697, %1701 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1703 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1702 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1704 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1705 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1703 : tensor<2x256x1280xf16>) outs(%1704 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1706 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1705 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1707 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1706 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1708 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1707 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1709 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1708 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1710 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1702, %1709 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1711 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1710, %cst_223 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1712 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1711, %cst_224 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1713 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_225 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1714 = tensor.collapse_shape %1712 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1715 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1716 = linalg.matmul ins(%1714, %1713 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1715 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1717 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_226 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%1718 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1719 = linalg.matmul ins(%271, %1717 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1718 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1720 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_227 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%1721 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1722 = linalg.matmul ins(%271, %1720 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%1721 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%1723 = tensor.expand_shape %1716 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%1724 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1723 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%1725 = tensor.collapse_shape %1724 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%1726 = tensor.expand_shape %1719 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1727 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1726 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%1728 = tensor.collapse_shape %1727 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1729 = tensor.expand_shape %1722 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%1730 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1729 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%1731 = tensor.collapse_shape %1730 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%1732 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1728 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%1733 = linalg.fill ins(%cst_694 : f16) outs(%1454 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1734 = linalg.batch_matmul ins(%1725, %1732 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%1733 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%1735 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1734, %cst : tensor<16x256x77xf16>, tensor<f64>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x77xf16>
%1736 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%1737 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1738:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1735 : tensor<16x256x77xf16>) outs(%1737, %1736 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%1739 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1735, %1738#0 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1740 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1739 : tensor<16x256x77xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1741 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%1742 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1740 : tensor<16x256x77xf16>) outs(%1741 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%1743 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1740, %1742 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%1744 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1745 = linalg.batch_matmul ins(%1743, %1731 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%1744 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%1746 = tensor.expand_shape %1745 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%1747 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1746 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%1748 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_228 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1749 = tensor.collapse_shape %1747 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%1750 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1751 = linalg.matmul ins(%1749, %1748 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%1750 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1752 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_229, %1751 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1753 = tensor.expand_shape %1752 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1754 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1753, %1697 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1755 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1756 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1754 : tensor<2x256x1280xf16>) outs(%1755 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1757 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1756 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1758 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1757 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1759 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1754, %1758 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1760 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1759 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1761 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%1762 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%1760 : tensor<2x256x1280xf16>) outs(%1761 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1763 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1762 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1764 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1763 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%1765 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1764 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%1766 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1765 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%1767 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1759, %1766 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1768 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1767, %cst_230 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1769 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1768, %cst_231 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1770 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_232 : tensor<10240x1280xf16>) outs(%1492 : tensor<1280x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x10240xf16>
%1771 = tensor.collapse_shape %1769 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%1772 = linalg.fill ins(%cst_694 : f16) outs(%1495 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1773 = linalg.matmul ins(%1771, %1770 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%1772 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%1774 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_233, %1773 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1495 : tensor<512x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x10240xf16>
%1775 = tensor.expand_shape %1774 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%1776 = tensor.extract_slice %1775[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1777 = tensor.extract_slice %1775[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%1778 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1777 : tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x256x5120xf16>
%1779 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1776, %1778 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x5120xf16>
%1780 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_234 : tensor<1280x5120xf16>) outs(%1505 : tensor<5120x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<5120x1280xf16>
%1781 = tensor.collapse_shape %1779 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%1782 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1783 = linalg.matmul ins(%1781, %1780 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%1782 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%1784 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_235, %1783 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%1785 = tensor.expand_shape %1784 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%1786 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%1785, %1754 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%1787 = tensor.expand_shape %1786 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%1788 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1787 : tensor<2x16x16x1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1789 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_237 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%1790 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1788, %cst_236 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%1789 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%1791 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1790, %1603 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%1792 = tensor.pad %1791 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%1793 = linalg.init_tensor [2, 1280, 8, 8] : tensor<2x1280x8x8xf16>
%1794 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_239 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1795 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<2> : vector<2xi64>} ins(%1792, %cst_238 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%1794 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1796 = tensor.collapse_shape %1795 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%1797 = tensor.expand_shape %1796 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1798 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1799 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1798 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1800 = linalg.init_tensor [2, 32, 40, 64] : tensor<2x32x40x64xf32>
%1801 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1799 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%1802 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1797 : tensor<2x32x40x64xf16>) outs(%1801 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1803 = linalg.init_tensor [2, 32, 40, 64] : tensor<2x32x40x64xf64>
%1804 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1802 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1805 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1806 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1804 : tensor<2x32x40x64xf64>) outs(%1805 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1807 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1806 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1808 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1804, %1807 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1809 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1808 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1810 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1811 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1809 : tensor<2x32x40x64xf64>) outs(%1810 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1812 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1811 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1813 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1812 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1814 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1815 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1802 : tensor<2x32x40x64xf32>) outs(%1814 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1816 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1815 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1817 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1813, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1818 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1817 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1819 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1797, %1816 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%1820 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1819, %1818 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1821 = tensor.collapse_shape %1820 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%1822 = tensor.expand_shape %1821 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%1823 = tensor.expand_shape %cst_240 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1824 = linalg.init_tensor [2, 1280, 8, 8] : tensor<2x1280x8x8xf32>
%1825 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1822, %1823 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1826 = tensor.expand_shape %cst_241 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1827 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1825, %1826 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1828 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1829 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1828 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1830 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1829 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1831 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1827 : tensor<2x1280x8x8xf32>) outs(%1830 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1832 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1831 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%1833 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1832, %1831 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1834 = tensor.pad %1833 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1835 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_243 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1836 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1834, %cst_242 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1835 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1837 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%1838 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%1837, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1839 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_244 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1840 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1841 = linalg.matmul ins(%1838, %1839 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1840 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1842 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_245, %1841 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1843 = tensor.expand_shape %1842 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1844 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1836, %1843 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1845 = tensor.collapse_shape %1844 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%1846 = tensor.expand_shape %1845 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1847 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1848 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1847 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1849 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1848 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%1850 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1846 : tensor<2x32x40x64xf16>) outs(%1849 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1851 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1850 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1852 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1853 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1851 : tensor<2x32x40x64xf64>) outs(%1852 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1854 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1853 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1855 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1851, %1854 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1856 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1855 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1857 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1858 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1856 : tensor<2x32x40x64xf64>) outs(%1857 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1859 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1858 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1860 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1859 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1861 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1862 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1850 : tensor<2x32x40x64xf32>) outs(%1861 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1863 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1862 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1864 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1860, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1865 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1864 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1866 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1846, %1863 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%1867 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1866, %1865 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1868 = tensor.collapse_shape %1867 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%1869 = tensor.expand_shape %1868 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%1870 = tensor.expand_shape %cst_246 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1871 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1869, %1870 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1872 = tensor.expand_shape %cst_247 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1873 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1871, %1872 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1874 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1875 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1874 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1876 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1875 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1877 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1873 : tensor<2x1280x8x8xf32>) outs(%1876 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1878 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1877 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%1879 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1878, %1877 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1880 = tensor.pad %1879 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1881 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_249 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1882 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1880, %cst_248 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1881 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1883 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1795, %1882 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1884 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1883, %cst_3 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%1885 = tensor.collapse_shape %1884 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%1886 = tensor.expand_shape %1885 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1887 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1888 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1887 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1889 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1888 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%1890 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1886 : tensor<2x32x40x64xf16>) outs(%1889 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1891 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1890 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1892 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1893 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1891 : tensor<2x32x40x64xf64>) outs(%1892 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1894 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1893 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1895 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1891, %1894 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1896 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1895 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1897 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1898 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1896 : tensor<2x32x40x64xf64>) outs(%1897 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1899 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1898 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1900 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1899 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1901 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1902 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1890 : tensor<2x32x40x64xf32>) outs(%1901 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1903 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1902 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1904 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1900, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1905 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1904 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1906 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1886, %1903 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%1907 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1906, %1905 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1908 = tensor.collapse_shape %1907 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%1909 = tensor.expand_shape %1908 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%1910 = tensor.expand_shape %cst_250 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1911 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1909, %1910 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1912 = tensor.expand_shape %cst_251 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1913 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1911, %1912 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1914 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1915 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1914 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1916 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1915 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1917 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1913 : tensor<2x1280x8x8xf32>) outs(%1916 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1918 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1917 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%1919 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1918, %1917 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1920 = tensor.pad %1919 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1921 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_253 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1922 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1920, %cst_252 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1921 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1923 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%1924 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%1923, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1925 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_254 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%1926 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1927 = linalg.matmul ins(%1924, %1925 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%1926 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%1928 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_255, %1927 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%1929 = tensor.expand_shape %1928 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%1930 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1922, %1929 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1931 = tensor.collapse_shape %1930 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%1932 = tensor.expand_shape %1931 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1933 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1934 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1933 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1935 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1934 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%1936 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1932 : tensor<2x32x40x64xf16>) outs(%1935 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1937 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1936 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1938 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1939 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1937 : tensor<2x32x40x64xf64>) outs(%1938 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1940 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1939 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1941 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1937, %1940 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1942 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1941 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1943 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1944 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1942 : tensor<2x32x40x64xf64>) outs(%1943 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1945 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1944 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1946 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1945 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1947 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1948 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1936 : tensor<2x32x40x64xf32>) outs(%1947 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1949 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1948 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1950 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1946, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1951 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1950 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1952 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1932, %1949 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%1953 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1952, %1951 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1954 = tensor.collapse_shape %1953 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%1955 = tensor.expand_shape %1954 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%1956 = tensor.expand_shape %cst_256 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1957 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1955, %1956 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1958 = tensor.expand_shape %cst_257 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1959 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1957, %1958 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1960 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1961 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1960 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%1962 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1961 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1963 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1959 : tensor<2x1280x8x8xf32>) outs(%1962 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1964 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1963 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%1965 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1964, %1963 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1966 = tensor.pad %1965 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%1967 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_259 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%1968 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%1966, %cst_258 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%1967 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%1969 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1884, %1968 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%1970 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1969, %cst_3 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%1971 = tensor.collapse_shape %1970 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%1972 = tensor.expand_shape %1971 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%1973 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%1974 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%1973 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%1975 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1974 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%1976 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1972 : tensor<2x32x40x64xf16>) outs(%1975 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1977 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1976 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1978 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1979 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1977 : tensor<2x32x40x64xf64>) outs(%1978 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1980 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1979 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1981 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1977, %1980 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1982 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1981 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%1983 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%1984 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1982 : tensor<2x32x40x64xf64>) outs(%1983 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1985 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1984 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%1986 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1985 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1987 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%1988 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%1976 : tensor<2x32x40x64xf32>) outs(%1987 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1989 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1988 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1990 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1986, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%1991 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1990 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%1992 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1972, %1989 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%1993 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1992, %1991 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%1994 = tensor.collapse_shape %1993 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%1995 = tensor.expand_shape %1994 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%1996 = tensor.expand_shape %cst_260 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1997 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1995, %1996 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%1998 = tensor.expand_shape %cst_261 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%1999 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1997, %1998 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2000 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2001 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2000 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2002 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2001 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2003 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1999 : tensor<2x1280x8x8xf32>) outs(%2002 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2004 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2003 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2005 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2004, %2003 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2006 = tensor.pad %2005 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2007 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_263 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2008 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2006, %cst_262 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2007 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2009 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2010 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2009, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2011 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_264 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2012 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2013 = linalg.matmul ins(%2010, %2011 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2012 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2014 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_265, %2013 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2015 = tensor.expand_shape %2014 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2016 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2008, %2015 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2017 = tensor.collapse_shape %2016 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2018 = tensor.expand_shape %2017 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2019 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2020 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2019 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2021 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2020 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2022 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2018 : tensor<2x32x40x64xf16>) outs(%2021 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2023 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2022 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2024 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2025 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2023 : tensor<2x32x40x64xf64>) outs(%2024 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2026 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2025 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2027 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2023, %2026 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2028 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2027 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2029 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2030 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2028 : tensor<2x32x40x64xf64>) outs(%2029 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2031 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2030 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2032 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2031 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2033 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2034 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2022 : tensor<2x32x40x64xf32>) outs(%2033 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2035 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2034 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2036 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2032, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2037 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2036 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2038 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2018, %2035 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2039 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2038, %2037 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2040 = tensor.collapse_shape %2039 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2041 = tensor.expand_shape %2040 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2042 = tensor.expand_shape %cst_266 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2043 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2041, %2042 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2044 = tensor.expand_shape %cst_267 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2045 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2043, %2044 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2046 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2047 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2046 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2048 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2047 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2049 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2045 : tensor<2x1280x8x8xf32>) outs(%2048 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2050 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2049 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2051 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2050, %2049 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2052 = tensor.pad %2051 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2053 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_269 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2054 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2052, %cst_268 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2053 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2055 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%1970, %2054 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2056 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2055, %cst_5 : tensor<2x1280x8x8xf16>, tensor<i64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: i64, %arg5: f16):
%5200 = arith.sitofp %arg4 : i64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%2057 = tensor.collapse_shape %2056 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2058 = tensor.expand_shape %2057 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2059 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2060 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2059 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2061 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2060 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2062 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2058 : tensor<2x32x40x64xf16>) outs(%2061 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2063 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2062 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2064 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2065 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2063 : tensor<2x32x40x64xf64>) outs(%2064 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2066 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2065 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2067 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2063, %2066 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2068 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2067 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2069 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2070 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2068 : tensor<2x32x40x64xf64>) outs(%2069 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2071 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2070 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2072 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2071 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2073 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2074 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2062 : tensor<2x32x40x64xf32>) outs(%2073 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2075 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2074 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2076 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2072, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2077 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2076 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2078 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2058, %2075 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2079 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2078, %2077 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2080 = tensor.collapse_shape %2079 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2081 = tensor.expand_shape %2080 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2082 = tensor.expand_shape %cst_270 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2083 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2081, %2082 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2084 = tensor.expand_shape %cst_271 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2085 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2083, %2084 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2086 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2087 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2086 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2088 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2087 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2089 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2085 : tensor<2x1280x8x8xf32>) outs(%2088 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2090 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_273 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2091 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2089, %cst_272 : tensor<2x1280x8x8xf16>, tensor<1280x1280x1x1xf16>) outs(%2090 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2092 = linalg.init_tensor [2, 8, 8, 1280] : tensor<2x8x8x1280xf16>
%2093 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2091 : tensor<2x1280x8x8xf16>) outs(%2092 : tensor<2x8x8x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x8x1280xf16>
%2094 = tensor.collapse_shape %2093 [[0], [1, 2], [3]] : tensor<2x8x8x1280xf16> into tensor<2x64x1280xf16>
%2095 = linalg.init_tensor [2, 64, 1] : tensor<2x64x1xf16>
%2096 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2097 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2094 : tensor<2x64x1280xf16>) outs(%2096 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2098 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2097 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2099 = linalg.init_tensor [2, 64, 1280] : tensor<2x64x1280xf16>
%2100 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2098 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2101 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2094, %2100 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2102 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2101 : tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2103 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2104 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2102 : tensor<2x64x1280xf16>) outs(%2103 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2105 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2104 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2106 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2105 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x64x1xf16>
%2107 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2106 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2108 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2107 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2109 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2101, %2108 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2110 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2109, %cst_274 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2111 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2110, %cst_275 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2112 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_276 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2113 = tensor.collapse_shape %2111 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%2114 = linalg.init_tensor [128, 1280] : tensor<128x1280xf16>
%2115 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2116 = linalg.matmul ins(%2113, %2112 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2115 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2117 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_277 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2118 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2119 = linalg.matmul ins(%2113, %2117 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2118 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2120 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_278 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2121 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2122 = linalg.matmul ins(%2113, %2120 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2121 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2123 = tensor.expand_shape %2116 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%2124 = linalg.init_tensor [2, 8, 64, 160] : tensor<2x8x64x160xf16>
%2125 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2123 : tensor<2x64x8x160xf16>) outs(%2124 : tensor<2x8x64x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x64x160xf16>
%2126 = tensor.collapse_shape %2125 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%2127 = tensor.expand_shape %2119 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%2128 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2127 : tensor<2x64x8x160xf16>) outs(%2124 : tensor<2x8x64x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x64x160xf16>
%2129 = tensor.collapse_shape %2128 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%2130 = tensor.expand_shape %2122 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%2131 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2130 : tensor<2x64x8x160xf16>) outs(%2124 : tensor<2x8x64x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x64x160xf16>
%2132 = tensor.collapse_shape %2131 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%2133 = linalg.init_tensor [16, 160, 64] : tensor<16x160x64xf16>
%2134 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2129 : tensor<16x64x160xf16>) outs(%2133 : tensor<16x160x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x64xf16>
%2135 = linalg.init_tensor [16, 64, 64] : tensor<16x64x64xf16>
%2136 = linalg.fill ins(%cst_694 : f16) outs(%2135 : tensor<16x64x64xf16>) -> tensor<16x64x64xf16>
%2137 = linalg.batch_matmul ins(%2126, %2134 : tensor<16x64x160xf16>, tensor<16x160x64xf16>) outs(%2136 : tensor<16x64x64xf16>) -> tensor<16x64x64xf16>
%2138 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2137, %cst : tensor<16x64x64xf16>, tensor<f64>) outs(%2135 : tensor<16x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x64x64xf16>
%2139 = linalg.init_tensor [16, 64, 1] : tensor<16x64x1xi64>
%2140 = linalg.fill ins(%c0_i64 : i64) outs(%2139 : tensor<16x64x1xi64>) -> tensor<16x64x1xi64>
%2141 = linalg.init_tensor [16, 64, 1] : tensor<16x64x1xf16>
%2142 = linalg.fill ins(%cst_696 : f16) outs(%2141 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%2143:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2138 : tensor<16x64x64xf16>) outs(%2142, %2140 : tensor<16x64x1xf16>, tensor<16x64x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x64x1xf16>, tensor<16x64x1xi64>)
%2144 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2138, %2143#0 : tensor<16x64x64xf16>, tensor<16x64x1xf16>) outs(%2135 : tensor<16x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x64xf16>
%2145 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2144 : tensor<16x64x64xf16>) outs(%2135 : tensor<16x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x64xf16>
%2146 = linalg.fill ins(%cst_694 : f16) outs(%2141 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%2147 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2145 : tensor<16x64x64xf16>) outs(%2146 : tensor<16x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x1xf16>
%2148 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2145, %2147 : tensor<16x64x64xf16>, tensor<16x64x1xf16>) outs(%2135 : tensor<16x64x64xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x64xf16>
%2149 = linalg.init_tensor [16, 64, 160] : tensor<16x64x160xf16>
%2150 = linalg.fill ins(%cst_694 : f16) outs(%2149 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%2151 = linalg.batch_matmul ins(%2148, %2132 : tensor<16x64x64xf16>, tensor<16x64x160xf16>) outs(%2150 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%2152 = tensor.expand_shape %2151 [[0, 1], [2], [3]] : tensor<16x64x160xf16> into tensor<2x8x64x160xf16>
%2153 = linalg.init_tensor [2, 64, 8, 160] : tensor<2x64x8x160xf16>
%2154 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2152 : tensor<2x8x64x160xf16>) outs(%2153 : tensor<2x64x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x8x160xf16>
%2155 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_279 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2156 = tensor.collapse_shape %2154 [[0, 1], [2, 3]] : tensor<2x64x8x160xf16> into tensor<128x1280xf16>
%2157 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2158 = linalg.matmul ins(%2156, %2155 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2157 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2159 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_280, %2158 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%2114 : tensor<128x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<128x1280xf16>
%2160 = tensor.expand_shape %2159 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%2161 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2160, %2094 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2162 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2163 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2161 : tensor<2x64x1280xf16>) outs(%2162 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2164 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2163 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2165 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2164 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2166 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2161, %2165 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2167 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2166 : tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2168 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2169 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2167 : tensor<2x64x1280xf16>) outs(%2168 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2170 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2169 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2171 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2170 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x64x1xf16>
%2172 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2171 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2173 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2172 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2174 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2166, %2173 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2175 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2174, %cst_281 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2176 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2175, %cst_282 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2177 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_283 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2178 = tensor.collapse_shape %2176 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%2179 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2180 = linalg.matmul ins(%2178, %2177 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2179 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2181 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_284 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%2182 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2183 = linalg.matmul ins(%271, %2181 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2182 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2184 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_285 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%2185 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2186 = linalg.matmul ins(%271, %2184 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2185 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2187 = tensor.expand_shape %2180 [[0, 1], [2, 3]] : tensor<128x1280xf16> into tensor<2x64x8x160xf16>
%2188 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2187 : tensor<2x64x8x160xf16>) outs(%2124 : tensor<2x8x64x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x64x160xf16>
%2189 = tensor.collapse_shape %2188 [[0, 1], [2], [3]] : tensor<2x8x64x160xf16> into tensor<16x64x160xf16>
%2190 = tensor.expand_shape %2183 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2191 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2190 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%2192 = tensor.collapse_shape %2191 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2193 = tensor.expand_shape %2186 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2194 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2193 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%2195 = tensor.collapse_shape %2194 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2196 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2192 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%2197 = linalg.init_tensor [16, 64, 77] : tensor<16x64x77xf16>
%2198 = linalg.fill ins(%cst_694 : f16) outs(%2197 : tensor<16x64x77xf16>) -> tensor<16x64x77xf16>
%2199 = linalg.batch_matmul ins(%2189, %2196 : tensor<16x64x160xf16>, tensor<16x160x77xf16>) outs(%2198 : tensor<16x64x77xf16>) -> tensor<16x64x77xf16>
%2200 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2199, %cst : tensor<16x64x77xf16>, tensor<f64>) outs(%2197 : tensor<16x64x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x64x77xf16>
%2201 = linalg.fill ins(%c0_i64 : i64) outs(%2139 : tensor<16x64x1xi64>) -> tensor<16x64x1xi64>
%2202 = linalg.fill ins(%cst_696 : f16) outs(%2141 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%2203:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2200 : tensor<16x64x77xf16>) outs(%2202, %2201 : tensor<16x64x1xf16>, tensor<16x64x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x64x1xf16>, tensor<16x64x1xi64>)
%2204 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2200, %2203#0 : tensor<16x64x77xf16>, tensor<16x64x1xf16>) outs(%2197 : tensor<16x64x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x77xf16>
%2205 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2204 : tensor<16x64x77xf16>) outs(%2197 : tensor<16x64x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x77xf16>
%2206 = linalg.fill ins(%cst_694 : f16) outs(%2141 : tensor<16x64x1xf16>) -> tensor<16x64x1xf16>
%2207 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2205 : tensor<16x64x77xf16>) outs(%2206 : tensor<16x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x1xf16>
%2208 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2205, %2207 : tensor<16x64x77xf16>, tensor<16x64x1xf16>) outs(%2197 : tensor<16x64x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x64x77xf16>
%2209 = linalg.fill ins(%cst_694 : f16) outs(%2149 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%2210 = linalg.batch_matmul ins(%2208, %2195 : tensor<16x64x77xf16>, tensor<16x77x160xf16>) outs(%2209 : tensor<16x64x160xf16>) -> tensor<16x64x160xf16>
%2211 = tensor.expand_shape %2210 [[0, 1], [2], [3]] : tensor<16x64x160xf16> into tensor<2x8x64x160xf16>
%2212 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2211 : tensor<2x8x64x160xf16>) outs(%2153 : tensor<2x64x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x8x160xf16>
%2213 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_286 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2214 = tensor.collapse_shape %2212 [[0, 1], [2, 3]] : tensor<2x64x8x160xf16> into tensor<128x1280xf16>
%2215 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2216 = linalg.matmul ins(%2214, %2213 : tensor<128x1280xf16>, tensor<1280x1280xf16>) outs(%2215 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2217 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_287, %2216 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%2114 : tensor<128x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<128x1280xf16>
%2218 = tensor.expand_shape %2217 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%2219 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2218, %2161 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2220 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2221 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2219 : tensor<2x64x1280xf16>) outs(%2220 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2222 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2221 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2223 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2222 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2224 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2219, %2223 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2225 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2224 : tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2226 = linalg.fill ins(%cst_694 : f16) outs(%2095 : tensor<2x64x1xf16>) -> tensor<2x64x1xf16>
%2227 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2225 : tensor<2x64x1280xf16>) outs(%2226 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2228 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2227 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2229 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2228 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x64x1xf16>
%2230 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2229 : tensor<2x64x1xf16>) outs(%2095 : tensor<2x64x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1xf16>
%2231 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2230 : tensor<2x64x1xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x64x1280xf16>
%2232 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2224, %2231 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2233 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2232, %cst_288 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2234 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2233, %cst_289 : tensor<2x64x1280xf16>, tensor<1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2235 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_290 : tensor<10240x1280xf16>) outs(%1492 : tensor<1280x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x10240xf16>
%2236 = tensor.collapse_shape %2234 [[0, 1], [2]] : tensor<2x64x1280xf16> into tensor<128x1280xf16>
%2237 = linalg.init_tensor [128, 10240] : tensor<128x10240xf16>
%2238 = linalg.fill ins(%cst_694 : f16) outs(%2237 : tensor<128x10240xf16>) -> tensor<128x10240xf16>
%2239 = linalg.matmul ins(%2236, %2235 : tensor<128x1280xf16>, tensor<1280x10240xf16>) outs(%2238 : tensor<128x10240xf16>) -> tensor<128x10240xf16>
%2240 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_291, %2239 : tensor<10240xf16>, tensor<128x10240xf16>) outs(%2237 : tensor<128x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<128x10240xf16>
%2241 = tensor.expand_shape %2240 [[0, 1], [2]] : tensor<128x10240xf16> into tensor<2x64x10240xf16>
%2242 = tensor.extract_slice %2241[0, 0, 0] [2, 64, 5120] [1, 1, 1] : tensor<2x64x10240xf16> to tensor<2x64x5120xf16>
%2243 = tensor.extract_slice %2241[0, 0, 5120] [2, 64, 5120] [1, 1, 1] : tensor<2x64x10240xf16> to tensor<2x64x5120xf16>
%2244 = linalg.init_tensor [2, 64, 5120] : tensor<2x64x5120xf16>
%2245 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2243 : tensor<2x64x5120xf16>) outs(%2244 : tensor<2x64x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x64x5120xf16>
%2246 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2242, %2245 : tensor<2x64x5120xf16>, tensor<2x64x5120xf16>) outs(%2244 : tensor<2x64x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x5120xf16>
%2247 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_292 : tensor<1280x5120xf16>) outs(%1505 : tensor<5120x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<5120x1280xf16>
%2248 = tensor.collapse_shape %2246 [[0, 1], [2]] : tensor<2x64x5120xf16> into tensor<128x5120xf16>
%2249 = linalg.fill ins(%cst_694 : f16) outs(%2114 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2250 = linalg.matmul ins(%2248, %2247 : tensor<128x5120xf16>, tensor<5120x1280xf16>) outs(%2249 : tensor<128x1280xf16>) -> tensor<128x1280xf16>
%2251 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_293, %2250 : tensor<1280xf16>, tensor<128x1280xf16>) outs(%2114 : tensor<128x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<128x1280xf16>
%2252 = tensor.expand_shape %2251 [[0, 1], [2]] : tensor<128x1280xf16> into tensor<2x64x1280xf16>
%2253 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2252, %2219 : tensor<2x64x1280xf16>, tensor<2x64x1280xf16>) outs(%2099 : tensor<2x64x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x64x1280xf16>
%2254 = tensor.expand_shape %2253 [[0], [1, 2], [3]] : tensor<2x64x1280xf16> into tensor<2x8x8x1280xf16>
%2255 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2254 : tensor<2x8x8x1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2256 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_295 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2257 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2255, %cst_294 : tensor<2x1280x8x8xf16>, tensor<1280x1280x1x1xf16>) outs(%2256 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2258 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2257, %2056 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2259 = tensor.collapse_shape %2258 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2260 = tensor.expand_shape %2259 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2261 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2262 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2261 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2263 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2262 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2264 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2260 : tensor<2x32x40x64xf16>) outs(%2263 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2265 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2264 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2266 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2267 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2265 : tensor<2x32x40x64xf64>) outs(%2266 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2268 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2267 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2269 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2265, %2268 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2270 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2269 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2271 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2272 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2270 : tensor<2x32x40x64xf64>) outs(%2271 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2273 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2272 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2274 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2273 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2275 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2276 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2264 : tensor<2x32x40x64xf32>) outs(%2275 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2277 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2276 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2278 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2274, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2279 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2278 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2280 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2260, %2277 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2281 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2280, %2279 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2282 = tensor.collapse_shape %2281 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2283 = tensor.expand_shape %2282 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2284 = tensor.expand_shape %cst_296 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2285 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2283, %2284 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2286 = tensor.expand_shape %cst_297 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2287 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2285, %2286 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2288 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2289 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2288 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2290 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2289 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2291 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2287 : tensor<2x1280x8x8xf32>) outs(%2290 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2292 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2291 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2293 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2292, %2291 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2294 = tensor.pad %2293 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2295 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_299 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2296 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2294, %cst_298 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2295 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2297 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2298 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2297, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2299 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_300 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2300 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2301 = linalg.matmul ins(%2298, %2299 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2300 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2302 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_301, %2301 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2303 = tensor.expand_shape %2302 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2304 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2296, %2303 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2305 = tensor.collapse_shape %2304 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2306 = tensor.expand_shape %2305 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2307 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2308 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2307 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2309 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2308 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2310 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2306 : tensor<2x32x40x64xf16>) outs(%2309 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2311 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2310 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2312 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2313 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2311 : tensor<2x32x40x64xf64>) outs(%2312 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2314 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2313 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2315 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2311, %2314 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2316 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2315 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2317 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2318 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2316 : tensor<2x32x40x64xf64>) outs(%2317 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2319 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2318 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2320 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2319 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2321 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2322 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2310 : tensor<2x32x40x64xf32>) outs(%2321 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2323 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2322 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2324 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2320, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2325 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2324 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2326 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2306, %2323 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2327 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2326, %2325 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2328 = tensor.collapse_shape %2327 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2329 = tensor.expand_shape %2328 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2330 = tensor.expand_shape %cst_302 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2331 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2329, %2330 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2332 = tensor.expand_shape %cst_303 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2333 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2331, %2332 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2334 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2335 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2334 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2336 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2335 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2337 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2333 : tensor<2x1280x8x8xf32>) outs(%2336 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2338 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2337 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2339 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2338, %2337 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2340 = tensor.pad %2339 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2341 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_305 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2342 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2340, %cst_304 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2341 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2343 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2258, %2342 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2344 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2343, %cst_5 : tensor<2x1280x8x8xf16>, tensor<i64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: i64, %arg5: f16):
%5200 = arith.sitofp %arg4 : i64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%2345 = linalg.init_tensor [2, 2560, 8, 8] : tensor<2x2560x8x8xf16>
%2346 = tensor.insert_slice %2344 into %2345[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2347 = tensor.insert_slice %1970 into %2346[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2348 = tensor.collapse_shape %2347 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%2349 = tensor.expand_shape %2348 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%2350 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2351 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2350 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2352 = linalg.init_tensor [2, 32, 80, 64] : tensor<2x32x80x64xf32>
%2353 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2351 : tensor<f32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x80x64xf32>
%2354 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2349 : tensor<2x32x80x64xf16>) outs(%2353 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2355 = linalg.init_tensor [2, 32, 80, 64] : tensor<2x32x80x64xf64>
%2356 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2354 : tensor<2x32x80x64xf32>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2357 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2358 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2356 : tensor<2x32x80x64xf64>) outs(%2357 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2359 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2358 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2360 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2356, %2359 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2361 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2360 : tensor<2x32x80x64xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2362 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2363 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2361 : tensor<2x32x80x64xf64>) outs(%2362 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2364 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2363 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2365 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2364 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2366 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2367 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2354 : tensor<2x32x80x64xf32>) outs(%2366 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2368 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2367 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_711 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2369 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2365, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2370 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2369 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2371 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2349, %2368 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x80x64xf32>
%2372 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2371, %2370 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2373 = tensor.collapse_shape %2372 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%2374 = tensor.expand_shape %2373 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%2375 = tensor.expand_shape %cst_306 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2376 = linalg.init_tensor [2, 2560, 8, 8] : tensor<2x2560x8x8xf32>
%2377 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2374, %2375 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2378 = tensor.expand_shape %cst_307 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2379 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2377, %2378 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2380 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2381 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2380 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2382 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2381 : tensor<f16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x2560x8x8xf16>
%2383 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2379 : tensor<2x2560x8x8xf32>) outs(%2382 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2384 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2383 : tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x2560x8x8xf16>
%2385 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2384, %2383 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2386 = tensor.pad %2385 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%2387 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_309 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2388 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2386, %cst_308 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%2387 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2389 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2390 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2389, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2391 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_310 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2392 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2393 = linalg.matmul ins(%2390, %2391 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2392 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2394 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_311, %2393 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2395 = tensor.expand_shape %2394 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2396 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2388, %2395 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2397 = tensor.collapse_shape %2396 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2398 = tensor.expand_shape %2397 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2399 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2400 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2399 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2401 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2400 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2402 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2398 : tensor<2x32x40x64xf16>) outs(%2401 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2403 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2402 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2404 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2405 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2403 : tensor<2x32x40x64xf64>) outs(%2404 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2406 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2405 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2407 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2403, %2406 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2408 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2407 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2409 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2410 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2408 : tensor<2x32x40x64xf64>) outs(%2409 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2411 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2410 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2412 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2411 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2413 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2414 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2402 : tensor<2x32x40x64xf32>) outs(%2413 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2415 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2414 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2416 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2412, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2417 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2416 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2418 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2398, %2415 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2419 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2418, %2417 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2420 = tensor.collapse_shape %2419 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2421 = tensor.expand_shape %2420 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2422 = tensor.expand_shape %cst_312 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2423 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2421, %2422 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2424 = tensor.expand_shape %cst_313 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2425 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2423, %2424 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2426 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2427 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2426 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2428 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2427 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2429 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2425 : tensor<2x1280x8x8xf32>) outs(%2428 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2430 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2429 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2431 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2430, %2429 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2432 = tensor.pad %2431 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2433 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_315 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2434 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2432, %cst_314 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2433 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2435 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_317 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2436 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2347, %cst_316 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2435 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2437 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2436, %2434 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2438 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2437, %cst_3 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%2439 = tensor.insert_slice %2438 into %2345[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2440 = tensor.insert_slice %1884 into %2439[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2441 = tensor.collapse_shape %2440 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%2442 = tensor.expand_shape %2441 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%2443 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2444 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2443 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2445 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2444 : tensor<f32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x80x64xf32>
%2446 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2442 : tensor<2x32x80x64xf16>) outs(%2445 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2447 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2446 : tensor<2x32x80x64xf32>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2448 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2449 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2447 : tensor<2x32x80x64xf64>) outs(%2448 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2450 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2449 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2451 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2447, %2450 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2452 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2451 : tensor<2x32x80x64xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2453 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2454 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2452 : tensor<2x32x80x64xf64>) outs(%2453 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2455 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2454 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2456 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2455 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2457 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2458 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2446 : tensor<2x32x80x64xf32>) outs(%2457 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2459 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2458 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_711 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2460 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2456, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2461 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2460 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2462 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2442, %2459 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x80x64xf32>
%2463 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2462, %2461 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2464 = tensor.collapse_shape %2463 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%2465 = tensor.expand_shape %2464 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%2466 = tensor.expand_shape %cst_318 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2467 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2465, %2466 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2468 = tensor.expand_shape %cst_319 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2469 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2467, %2468 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2470 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2471 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2470 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2472 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2471 : tensor<f16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x2560x8x8xf16>
%2473 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2469 : tensor<2x2560x8x8xf32>) outs(%2472 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2474 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2473 : tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x2560x8x8xf16>
%2475 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2474, %2473 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2476 = tensor.pad %2475 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%2477 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_321 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2478 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2476, %cst_320 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%2477 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2479 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2480 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2479, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2481 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_322 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2482 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2483 = linalg.matmul ins(%2480, %2481 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2482 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2484 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_323, %2483 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2485 = tensor.expand_shape %2484 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2486 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2478, %2485 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2487 = tensor.collapse_shape %2486 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2488 = tensor.expand_shape %2487 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2489 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2490 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2489 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2491 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2490 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2492 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2488 : tensor<2x32x40x64xf16>) outs(%2491 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2493 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2492 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2494 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2495 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2493 : tensor<2x32x40x64xf64>) outs(%2494 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2496 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2495 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2497 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2493, %2496 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2498 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2497 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2499 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2500 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2498 : tensor<2x32x40x64xf64>) outs(%2499 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2501 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2500 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2502 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2501 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2503 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2504 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2492 : tensor<2x32x40x64xf32>) outs(%2503 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2505 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2504 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2506 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2502, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2507 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2506 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2508 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2488, %2505 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2509 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2508, %2507 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2510 = tensor.collapse_shape %2509 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2511 = tensor.expand_shape %2510 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2512 = tensor.expand_shape %cst_324 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2513 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2511, %2512 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2514 = tensor.expand_shape %cst_325 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2515 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2513, %2514 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2516 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2517 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2516 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2518 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2517 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2519 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2515 : tensor<2x1280x8x8xf32>) outs(%2518 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2520 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2519 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2521 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2520, %2519 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2522 = tensor.pad %2521 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2523 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_327 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2524 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2522, %cst_326 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2523 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2525 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_329 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2526 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2440, %cst_328 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2525 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2527 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2526, %2524 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2528 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2527, %cst_3 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%2529 = tensor.insert_slice %2528 into %2345[0, 0, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2530 = tensor.insert_slice %1795 into %2529[0, 1280, 0, 0] [2, 1280, 8, 8] [1, 1, 1, 1] : tensor<2x1280x8x8xf16> into tensor<2x2560x8x8xf16>
%2531 = tensor.collapse_shape %2530 [[0], [1], [2, 3]] : tensor<2x2560x8x8xf16> into tensor<2x2560x64xf16>
%2532 = tensor.expand_shape %2531 [[0], [1, 2], [3]] : tensor<2x2560x64xf16> into tensor<2x32x80x64xf16>
%2533 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2534 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2533 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2535 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2534 : tensor<f32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x80x64xf32>
%2536 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2532 : tensor<2x32x80x64xf16>) outs(%2535 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2537 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2536 : tensor<2x32x80x64xf32>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2538 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2539 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2537 : tensor<2x32x80x64xf64>) outs(%2538 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2540 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2539 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2541 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2537, %2540 : tensor<2x32x80x64xf64>, tensor<2x32x1x1xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2542 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2541 : tensor<2x32x80x64xf64>) outs(%2355 : tensor<2x32x80x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x64xf64>
%2543 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2544 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2542 : tensor<2x32x80x64xf64>) outs(%2543 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2545 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2544 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_710 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2546 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2545 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2547 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2548 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2536 : tensor<2x32x80x64xf32>) outs(%2547 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2549 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2548 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_711 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2550 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2546, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2551 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2550 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2552 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2532, %2549 : tensor<2x32x80x64xf16>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x80x64xf32>
%2553 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2552, %2551 : tensor<2x32x80x64xf32>, tensor<2x32x1x1xf32>) outs(%2352 : tensor<2x32x80x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x64xf32>
%2554 = tensor.collapse_shape %2553 [[0], [1, 2], [3]] : tensor<2x32x80x64xf32> into tensor<2x2560x64xf32>
%2555 = tensor.expand_shape %2554 [[0], [1], [2, 3]] : tensor<2x2560x64xf32> into tensor<2x2560x8x8xf32>
%2556 = tensor.expand_shape %cst_330 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2557 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2555, %2556 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2558 = tensor.expand_shape %cst_331 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2559 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2557, %2558 : tensor<2x2560x8x8xf32>, tensor<2560x1x1xf16>) outs(%2376 : tensor<2x2560x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x8x8xf32>
%2560 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2561 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2560 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2562 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2561 : tensor<f16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x2560x8x8xf16>
%2563 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2559 : tensor<2x2560x8x8xf32>) outs(%2562 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2564 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2563 : tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x2560x8x8xf16>
%2565 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2564, %2563 : tensor<2x2560x8x8xf16>, tensor<2x2560x8x8xf16>) outs(%2345 : tensor<2x2560x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x2560x8x8xf16>
%2566 = tensor.pad %2565 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x2560x8x8xf16> to tensor<2x2560x10x10xf16>
%2567 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_333 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2568 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2566, %cst_332 : tensor<2x2560x10x10xf16>, tensor<1280x2560x3x3xf16>) outs(%2567 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2569 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2570 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2569, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2571 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_334 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2572 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2573 = linalg.matmul ins(%2570, %2571 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2572 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2574 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_335, %2573 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2575 = tensor.expand_shape %2574 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2576 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2568, %2575 : tensor<2x1280x8x8xf16>, tensor<2x1280x1x1xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2577 = tensor.collapse_shape %2576 [[0], [1], [2, 3]] : tensor<2x1280x8x8xf16> into tensor<2x1280x64xf16>
%2578 = tensor.expand_shape %2577 [[0], [1, 2], [3]] : tensor<2x1280x64xf16> into tensor<2x32x40x64xf16>
%2579 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2580 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2579 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2581 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2580 : tensor<f32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x64xf32>
%2582 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2578 : tensor<2x32x40x64xf16>) outs(%2581 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2583 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2582 : tensor<2x32x40x64xf32>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2584 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2585 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2583 : tensor<2x32x40x64xf64>) outs(%2584 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2586 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2585 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2587 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2583, %2586 : tensor<2x32x40x64xf64>, tensor<2x32x1x1xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2588 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2587 : tensor<2x32x40x64xf64>) outs(%1803 : tensor<2x32x40x64xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x64xf64>
%2589 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2590 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2588 : tensor<2x32x40x64xf64>) outs(%2589 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2591 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2590 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_713 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2592 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2591 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2593 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2594 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2582 : tensor<2x32x40x64xf32>) outs(%2593 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2595 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2594 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_714 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2596 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2592, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2597 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2596 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2598 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2578, %2595 : tensor<2x32x40x64xf16>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x64xf32>
%2599 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2598, %2597 : tensor<2x32x40x64xf32>, tensor<2x32x1x1xf32>) outs(%1800 : tensor<2x32x40x64xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x64xf32>
%2600 = tensor.collapse_shape %2599 [[0], [1, 2], [3]] : tensor<2x32x40x64xf32> into tensor<2x1280x64xf32>
%2601 = tensor.expand_shape %2600 [[0], [1], [2, 3]] : tensor<2x1280x64xf32> into tensor<2x1280x8x8xf32>
%2602 = tensor.expand_shape %cst_336 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2603 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2601, %2602 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2604 = tensor.expand_shape %cst_337 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2605 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2603, %2604 : tensor<2x1280x8x8xf32>, tensor<1280x1x1xf16>) outs(%1824 : tensor<2x1280x8x8xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x8x8xf32>
%2606 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2607 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2606 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2608 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2607 : tensor<f16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2609 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2605 : tensor<2x1280x8x8xf32>) outs(%2608 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2610 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2609 : tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x8x8xf16>
%2611 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2610, %2609 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2612 = tensor.pad %2611 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x8x8xf16> to tensor<2x1280x10x10xf16>
%2613 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_339 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2614 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2612, %cst_338 : tensor<2x1280x10x10xf16>, tensor<1280x1280x3x3xf16>) outs(%2613 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2615 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_341 : tensor<1280xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x8x8xf16>
%2616 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2530, %cst_340 : tensor<2x2560x8x8xf16>, tensor<1280x2560x1x1xf16>) outs(%2615 : tensor<2x1280x8x8xf16>) -> tensor<2x1280x8x8xf16>
%2617 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2616, %2614 : tensor<2x1280x8x8xf16>, tensor<2x1280x8x8xf16>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x8x8xf16>
%2618 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2617, %cst_3 : tensor<2x1280x8x8xf16>, tensor<f64>) outs(%1793 : tensor<2x1280x8x8xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x8x8xf16>
%2619 = linalg.generic {indexing_maps = [#map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16):
%5200 = linalg.index 0 : index
%5201 = linalg.index 1 : index
%5202 = linalg.index 2 : index
%5203 = linalg.index 3 : index
%5204 = arith.floordivsi %5202, %c2 : index
%5205 = arith.floordivsi %5203, %c2 : index
%5206 = tensor.extract %2618[%5200, %5201, %5204, %5205] : tensor<2x1280x8x8xf16>
linalg.yield %5206 : f16
} -> tensor<2x1280x16x16xf16>
%2620 = tensor.pad %2619 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2621 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_343 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2622 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2620, %cst_342 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2621 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2623 = linalg.init_tensor [2, 2560, 16, 16] : tensor<2x2560x16x16xf16>
%2624 = tensor.insert_slice %2622 into %2623[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%2625 = tensor.insert_slice %1791 into %2624[0, 1280, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%2626 = tensor.collapse_shape %2625 [[0], [1], [2, 3]] : tensor<2x2560x16x16xf16> into tensor<2x2560x256xf16>
%2627 = tensor.expand_shape %2626 [[0], [1, 2], [3]] : tensor<2x2560x256xf16> into tensor<2x32x80x256xf16>
%2628 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2629 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2628 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2630 = linalg.init_tensor [2, 32, 80, 256] : tensor<2x32x80x256xf32>
%2631 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2629 : tensor<f32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x80x256xf32>
%2632 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2627 : tensor<2x32x80x256xf16>) outs(%2631 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x256xf32>
%2633 = linalg.init_tensor [2, 32, 80, 256] : tensor<2x32x80x256xf64>
%2634 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2632 : tensor<2x32x80x256xf32>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2635 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2636 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2634 : tensor<2x32x80x256xf64>) outs(%2635 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2637 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2636 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2638 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2634, %2637 : tensor<2x32x80x256xf64>, tensor<2x32x1x1xf64>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2639 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2638 : tensor<2x32x80x256xf64>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2640 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2641 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2639 : tensor<2x32x80x256xf64>) outs(%2640 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2642 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2641 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2643 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2642 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2644 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2645 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2632 : tensor<2x32x80x256xf32>) outs(%2644 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2646 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2645 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2647 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2643, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2648 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2647 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2649 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2627, %2646 : tensor<2x32x80x256xf16>, tensor<2x32x1x1xf32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x80x256xf32>
%2650 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2649, %2648 : tensor<2x32x80x256xf32>, tensor<2x32x1x1xf32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x256xf32>
%2651 = tensor.collapse_shape %2650 [[0], [1, 2], [3]] : tensor<2x32x80x256xf32> into tensor<2x2560x256xf32>
%2652 = tensor.expand_shape %2651 [[0], [1], [2, 3]] : tensor<2x2560x256xf32> into tensor<2x2560x16x16xf32>
%2653 = tensor.expand_shape %cst_344 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2654 = linalg.init_tensor [2, 2560, 16, 16] : tensor<2x2560x16x16xf32>
%2655 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2652, %2653 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2654 : tensor<2x2560x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x16x16xf32>
%2656 = tensor.expand_shape %cst_345 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2657 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2655, %2656 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2654 : tensor<2x2560x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x16x16xf32>
%2658 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2659 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2658 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2660 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2659 : tensor<f16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x2560x16x16xf16>
%2661 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2657 : tensor<2x2560x16x16xf32>) outs(%2660 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x2560x16x16xf16>
%2662 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2661 : tensor<2x2560x16x16xf16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x2560x16x16xf16>
%2663 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2662, %2661 : tensor<2x2560x16x16xf16>, tensor<2x2560x16x16xf16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x2560x16x16xf16>
%2664 = tensor.pad %2663 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x2560x16x16xf16> to tensor<2x2560x18x18xf16>
%2665 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_347 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2666 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2664, %cst_346 : tensor<2x2560x18x18xf16>, tensor<1280x2560x3x3xf16>) outs(%2665 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2667 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2668 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2667, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2669 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_348 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2670 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2671 = linalg.matmul ins(%2668, %2669 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2670 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2672 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_349, %2671 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2673 = tensor.expand_shape %2672 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2674 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2666, %2673 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2675 = tensor.collapse_shape %2674 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%2676 = tensor.expand_shape %2675 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2677 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2678 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2677 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2679 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2678 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%2680 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2676 : tensor<2x32x40x256xf16>) outs(%2679 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2681 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2680 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2682 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2683 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2681 : tensor<2x32x40x256xf64>) outs(%2682 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2684 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2683 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2685 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2681, %2684 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2686 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2685 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2687 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2688 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2686 : tensor<2x32x40x256xf64>) outs(%2687 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2689 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2688 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2690 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2689 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2691 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2692 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2680 : tensor<2x32x40x256xf32>) outs(%2691 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2693 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2692 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2694 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2690, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2695 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2694 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2696 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2676, %2693 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%2697 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2696, %2695 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2698 = tensor.collapse_shape %2697 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%2699 = tensor.expand_shape %2698 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%2700 = tensor.expand_shape %cst_350 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2701 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2699, %2700 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2702 = tensor.expand_shape %cst_351 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2703 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2701, %2702 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2704 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2705 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2704 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2706 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2705 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2707 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2703 : tensor<2x1280x16x16xf32>) outs(%2706 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2708 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2707 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%2709 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2708, %2707 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2710 = tensor.pad %2709 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2711 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_353 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2712 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2710, %cst_352 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2711 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2713 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_355 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2714 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2625, %cst_354 : tensor<2x2560x16x16xf16>, tensor<1280x2560x1x1xf16>) outs(%2713 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2715 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2714, %2712 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2716 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2715, %cst_3 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x16x16xf16>
%2717 = tensor.collapse_shape %2716 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%2718 = tensor.expand_shape %2717 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2719 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2720 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2719 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2721 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2720 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%2722 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2718 : tensor<2x32x40x256xf16>) outs(%2721 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2723 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2722 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2724 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2725 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2723 : tensor<2x32x40x256xf64>) outs(%2724 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2726 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2725 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2727 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2723, %2726 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2728 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2727 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2729 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2730 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2728 : tensor<2x32x40x256xf64>) outs(%2729 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2731 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2730 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2732 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2731 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2733 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2734 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2722 : tensor<2x32x40x256xf32>) outs(%2733 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2735 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2734 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2736 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2732, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2737 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2736 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2738 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2718, %2735 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%2739 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2738, %2737 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2740 = tensor.collapse_shape %2739 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%2741 = tensor.expand_shape %2740 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%2742 = tensor.expand_shape %cst_356 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2743 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2741, %2742 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2744 = tensor.expand_shape %cst_357 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2745 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2743, %2744 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2746 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2747 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2746 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2748 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2747 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2749 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2745 : tensor<2x1280x16x16xf32>) outs(%2748 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2750 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_359 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2751 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2749, %cst_358 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2750 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2752 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2751 : tensor<2x1280x16x16xf16>) outs(%1345 : tensor<2x16x16x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x16x16x1280xf16>
%2753 = tensor.collapse_shape %2752 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%2754 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2755 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2753 : tensor<2x256x1280xf16>) outs(%2754 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2756 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2755 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2757 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2756 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2758 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2753, %2757 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2759 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2758 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2760 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2761 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2759 : tensor<2x256x1280xf16>) outs(%2760 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2762 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2761 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2763 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2762 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%2764 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2763 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2765 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2764 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2766 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2758, %2765 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2767 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2766, %cst_360 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2768 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2767, %cst_361 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2769 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_362 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2770 = tensor.collapse_shape %2768 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2771 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2772 = linalg.matmul ins(%2770, %2769 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2771 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2773 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_363 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2774 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2775 = linalg.matmul ins(%2770, %2773 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2774 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2776 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_364 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2777 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2778 = linalg.matmul ins(%2770, %2776 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2777 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2779 = tensor.expand_shape %2772 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2780 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2779 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%2781 = tensor.collapse_shape %2780 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2782 = tensor.expand_shape %2775 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2783 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2782 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%2784 = tensor.collapse_shape %2783 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2785 = tensor.expand_shape %2778 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2786 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2785 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%2787 = tensor.collapse_shape %2786 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2788 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2784 : tensor<16x256x160xf16>) outs(%1386 : tensor<16x160x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x256xf16>
%2789 = linalg.fill ins(%cst_694 : f16) outs(%1388 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2790 = linalg.batch_matmul ins(%2781, %2788 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%2789 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%2791 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2790, %cst : tensor<16x256x256xf16>, tensor<f64>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x256xf16>
%2792 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%2793 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2794:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2791 : tensor<16x256x256xf16>) outs(%2793, %2792 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%2795 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2791, %2794#0 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%2796 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2795 : tensor<16x256x256xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%2797 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2798 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2796 : tensor<16x256x256xf16>) outs(%2797 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%2799 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2796, %2798 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%2800 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2801 = linalg.batch_matmul ins(%2799, %2787 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%2800 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2802 = tensor.expand_shape %2801 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2803 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2802 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%2804 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_365 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2805 = tensor.collapse_shape %2803 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2806 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2807 = linalg.matmul ins(%2805, %2804 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2806 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2808 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_366, %2807 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%2809 = tensor.expand_shape %2808 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2810 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2809, %2753 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2811 = linalg.fill ins(%cst_694 : f16) outs(%1348 : 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(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2813 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2812 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2814 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2813 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2815 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2810, %2814 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2816 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2815 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2817 = linalg.fill ins(%cst_694 : f16) outs(%1348 : 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(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2819 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2818 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2820 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2819 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%2821 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2820 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2822 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2821 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2823 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2815, %2822 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2824 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2823, %cst_367 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2825 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2824, %cst_368 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2826 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_369 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2827 = tensor.collapse_shape %2825 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2828 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2829 = linalg.matmul ins(%2827, %2826 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2828 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2830 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_370 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%2831 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2832 = linalg.matmul ins(%271, %2830 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2831 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2833 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_371 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%2834 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2835 = linalg.matmul ins(%271, %2833 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%2834 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%2836 = tensor.expand_shape %2829 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%2837 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2836 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%2838 = tensor.collapse_shape %2837 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%2839 = tensor.expand_shape %2832 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2840 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2839 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%2841 = tensor.collapse_shape %2840 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2842 = tensor.expand_shape %2835 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%2843 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2842 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%2844 = tensor.collapse_shape %2843 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%2845 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2841 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%2846 = linalg.fill ins(%cst_694 : f16) outs(%1454 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2847 = linalg.batch_matmul ins(%2838, %2845 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%2846 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%2848 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2847, %cst : tensor<16x256x77xf16>, tensor<f64>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x77xf16>
%2849 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%2850 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2851:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2848 : tensor<16x256x77xf16>) outs(%2850, %2849 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%2852 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2848, %2851#0 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%2853 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2852 : tensor<16x256x77xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%2854 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%2855 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2853 : tensor<16x256x77xf16>) outs(%2854 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%2856 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2853, %2855 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%2857 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2858 = linalg.batch_matmul ins(%2856, %2844 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%2857 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%2859 = tensor.expand_shape %2858 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%2860 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2859 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%2861 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_372 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2862 = tensor.collapse_shape %2860 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%2863 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2864 = linalg.matmul ins(%2862, %2861 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%2863 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2865 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_373, %2864 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%2866 = tensor.expand_shape %2865 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2867 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2866, %2810 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2868 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2869 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2867 : tensor<2x256x1280xf16>) outs(%2868 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2870 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2869 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2871 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2870 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2872 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2867, %2871 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2873 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2872 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2874 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%2875 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%2873 : tensor<2x256x1280xf16>) outs(%2874 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2876 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2875 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2877 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2876 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%2878 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2877 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%2879 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2878 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%2880 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2872, %2879 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2881 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2880, %cst_374 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2882 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2881, %cst_375 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2883 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_376 : tensor<10240x1280xf16>) outs(%1492 : tensor<1280x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x10240xf16>
%2884 = tensor.collapse_shape %2882 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%2885 = linalg.fill ins(%cst_694 : f16) outs(%1495 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2886 = linalg.matmul ins(%2884, %2883 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%2885 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%2887 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_377, %2886 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1495 : tensor<512x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x10240xf16>
%2888 = tensor.expand_shape %2887 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%2889 = tensor.extract_slice %2888[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%2890 = tensor.extract_slice %2888[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%2891 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2890 : tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x256x5120xf16>
%2892 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2889, %2891 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x5120xf16>
%2893 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_378 : tensor<1280x5120xf16>) outs(%1505 : tensor<5120x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<5120x1280xf16>
%2894 = tensor.collapse_shape %2892 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%2895 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2896 = linalg.matmul ins(%2894, %2893 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%2895 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%2897 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_379, %2896 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%2898 = tensor.expand_shape %2897 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%2899 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%2898, %2867 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%2900 = tensor.expand_shape %2899 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%2901 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2900 : tensor<2x16x16x1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2902 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_381 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2903 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2901, %cst_380 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%2902 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2904 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2903, %2716 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2905 = tensor.insert_slice %2904 into %2623[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%2906 = tensor.insert_slice %1517 into %2905[0, 1280, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x2560x16x16xf16>
%2907 = tensor.collapse_shape %2906 [[0], [1], [2, 3]] : tensor<2x2560x16x16xf16> into tensor<2x2560x256xf16>
%2908 = tensor.expand_shape %2907 [[0], [1, 2], [3]] : tensor<2x2560x256xf16> into tensor<2x32x80x256xf16>
%2909 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2910 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2909 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2911 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2910 : tensor<f32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x80x256xf32>
%2912 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2908 : tensor<2x32x80x256xf16>) outs(%2911 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x256xf32>
%2913 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2912 : tensor<2x32x80x256xf32>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2914 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2915 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2913 : tensor<2x32x80x256xf64>) outs(%2914 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2916 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2915 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2917 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2913, %2916 : tensor<2x32x80x256xf64>, tensor<2x32x1x1xf64>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2918 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2917 : tensor<2x32x80x256xf64>) outs(%2633 : tensor<2x32x80x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x80x256xf64>
%2919 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2920 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2918 : tensor<2x32x80x256xf64>) outs(%2919 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2921 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2920 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_707 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2922 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2921 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2923 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2924 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2912 : tensor<2x32x80x256xf32>) outs(%2923 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2925 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2924 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_708 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2926 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2922, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2927 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2926 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2928 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2908, %2925 : tensor<2x32x80x256xf16>, tensor<2x32x1x1xf32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x80x256xf32>
%2929 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2928, %2927 : tensor<2x32x80x256xf32>, tensor<2x32x1x1xf32>) outs(%2630 : tensor<2x32x80x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x80x256xf32>
%2930 = tensor.collapse_shape %2929 [[0], [1, 2], [3]] : tensor<2x32x80x256xf32> into tensor<2x2560x256xf32>
%2931 = tensor.expand_shape %2930 [[0], [1], [2, 3]] : tensor<2x2560x256xf32> into tensor<2x2560x16x16xf32>
%2932 = tensor.expand_shape %cst_382 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2933 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2931, %2932 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2654 : tensor<2x2560x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x16x16xf32>
%2934 = tensor.expand_shape %cst_383 [[0, 1, 2]] : tensor<2560xf16> into tensor<2560x1x1xf16>
%2935 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2933, %2934 : tensor<2x2560x16x16xf32>, tensor<2560x1x1xf16>) outs(%2654 : tensor<2x2560x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x2560x16x16xf32>
%2936 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2937 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2936 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2938 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2937 : tensor<f16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x2560x16x16xf16>
%2939 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2935 : tensor<2x2560x16x16xf32>) outs(%2938 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x2560x16x16xf16>
%2940 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2939 : tensor<2x2560x16x16xf16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x2560x16x16xf16>
%2941 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2940, %2939 : tensor<2x2560x16x16xf16>, tensor<2x2560x16x16xf16>) outs(%2623 : tensor<2x2560x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x2560x16x16xf16>
%2942 = tensor.pad %2941 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x2560x16x16xf16> to tensor<2x2560x18x18xf16>
%2943 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_385 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2944 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2942, %cst_384 : tensor<2x2560x18x18xf16>, tensor<1280x2560x3x3xf16>) outs(%2943 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2945 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%2946 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%2945, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2947 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_386 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%2948 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2949 = linalg.matmul ins(%2946, %2947 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%2948 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%2950 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_387, %2949 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%2951 = tensor.expand_shape %2950 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%2952 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2944, %2951 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2953 = tensor.collapse_shape %2952 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%2954 = tensor.expand_shape %2953 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2955 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2956 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2955 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2957 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2956 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%2958 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2954 : tensor<2x32x40x256xf16>) outs(%2957 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2959 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2958 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2960 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2961 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2959 : tensor<2x32x40x256xf64>) outs(%2960 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2962 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2961 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2963 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2959, %2962 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2964 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2963 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%2965 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%2966 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2964 : tensor<2x32x40x256xf64>) outs(%2965 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2967 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2966 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%2968 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2967 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2969 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%2970 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%2958 : tensor<2x32x40x256xf32>) outs(%2969 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2971 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2970 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2972 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2968, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%2973 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2972 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%2974 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2954, %2971 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%2975 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2974, %2973 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%2976 = tensor.collapse_shape %2975 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%2977 = tensor.expand_shape %2976 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%2978 = tensor.expand_shape %cst_388 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2979 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2977, %2978 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2980 = tensor.expand_shape %cst_389 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%2981 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2979, %2980 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%2982 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2983 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2982 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%2984 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2983 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2985 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2981 : tensor<2x1280x16x16xf32>) outs(%2984 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2986 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2985 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%2987 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2986, %2985 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2988 = tensor.pad %2987 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%2989 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_391 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2990 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2988, %cst_390 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%2989 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2991 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_393 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%2992 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%2906, %cst_392 : tensor<2x2560x16x16xf16>, tensor<1280x2560x1x1xf16>) outs(%2991 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%2993 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2992, %2990 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%2994 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2993, %cst_3 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x16x16xf16>
%2995 = tensor.collapse_shape %2994 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%2996 = tensor.expand_shape %2995 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%2997 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%2998 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%2997 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%2999 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2998 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%3000 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2996 : tensor<2x32x40x256xf16>) outs(%2999 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3001 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3000 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3002 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3003 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3001 : tensor<2x32x40x256xf64>) outs(%3002 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3004 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3003 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3005 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3001, %3004 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3006 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3005 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3007 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3008 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3006 : tensor<2x32x40x256xf64>) outs(%3007 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3009 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3008 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3010 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3009 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3011 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%3012 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3000 : tensor<2x32x40x256xf32>) outs(%3011 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3013 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3012 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3014 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3010, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%3015 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3014 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3016 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%2996, %3013 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%3017 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3016, %3015 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3018 = tensor.collapse_shape %3017 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%3019 = tensor.expand_shape %3018 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%3020 = tensor.expand_shape %cst_394 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3021 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3019, %3020 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3022 = tensor.expand_shape %cst_395 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3023 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3021, %3022 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3024 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3025 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3024 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%3026 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3025 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3027 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3023 : tensor<2x1280x16x16xf32>) outs(%3026 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3028 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_397 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3029 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3027, %cst_396 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%3028 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3030 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3029 : tensor<2x1280x16x16xf16>) outs(%1345 : tensor<2x16x16x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x16x16x1280xf16>
%3031 = tensor.collapse_shape %3030 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%3032 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3033 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3031 : tensor<2x256x1280xf16>) outs(%3032 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3034 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3033 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3035 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3034 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3036 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3031, %3035 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3037 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3036 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3038 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3039 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3037 : tensor<2x256x1280xf16>) outs(%3038 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3040 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3039 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3041 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3040 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%3042 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3041 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3043 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3042 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3044 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3036, %3043 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3045 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3044, %cst_398 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3046 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3045, %cst_399 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3047 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_400 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3048 = tensor.collapse_shape %3046 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%3049 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3050 = linalg.matmul ins(%3048, %3047 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3049 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3051 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_401 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3052 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3053 = linalg.matmul ins(%3048, %3051 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3052 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3054 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_402 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3055 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3056 = linalg.matmul ins(%3048, %3054 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3055 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3057 = tensor.expand_shape %3050 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3058 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3057 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3059 = tensor.collapse_shape %3058 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3060 = tensor.expand_shape %3053 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3061 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3060 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3062 = tensor.collapse_shape %3061 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3063 = tensor.expand_shape %3056 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3064 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3063 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3065 = tensor.collapse_shape %3064 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3066 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3062 : tensor<16x256x160xf16>) outs(%1386 : tensor<16x160x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x256xf16>
%3067 = linalg.fill ins(%cst_694 : f16) outs(%1388 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%3068 = linalg.batch_matmul ins(%3059, %3066 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%3067 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%3069 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3068, %cst : tensor<16x256x256xf16>, tensor<f64>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x256xf16>
%3070 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%3071 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3072:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3069 : tensor<16x256x256xf16>) outs(%3071, %3070 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%3073 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3069, %3072#0 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3074 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3073 : tensor<16x256x256xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3075 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3076 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3074 : tensor<16x256x256xf16>) outs(%3075 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%3077 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3074, %3076 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3078 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3079 = linalg.batch_matmul ins(%3077, %3065 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%3078 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3080 = tensor.expand_shape %3079 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%3081 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3080 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%3082 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_403 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3083 = tensor.collapse_shape %3081 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%3084 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3085 = linalg.matmul ins(%3083, %3082 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3084 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3086 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_404, %3085 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%3087 = tensor.expand_shape %3086 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%3088 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3087, %3031 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3089 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3090 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3088 : tensor<2x256x1280xf16>) outs(%3089 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3091 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3090 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3092 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3091 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3093 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3088, %3092 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3094 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3093 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3095 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3096 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3094 : tensor<2x256x1280xf16>) outs(%3095 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3097 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3096 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3098 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3097 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%3099 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3098 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3100 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3099 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3101 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3093, %3100 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3102 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3101, %cst_405 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3103 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3102, %cst_406 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3104 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_407 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3105 = tensor.collapse_shape %3103 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%3106 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3107 = linalg.matmul ins(%3105, %3104 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3106 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3108 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_408 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%3109 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3110 = linalg.matmul ins(%271, %3108 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%3109 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3111 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_409 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%3112 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3113 = linalg.matmul ins(%271, %3111 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%3112 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3114 = tensor.expand_shape %3107 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3115 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3114 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3116 = tensor.collapse_shape %3115 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3117 = tensor.expand_shape %3110 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%3118 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3117 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%3119 = tensor.collapse_shape %3118 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%3120 = tensor.expand_shape %3113 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%3121 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3120 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%3122 = tensor.collapse_shape %3121 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%3123 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3119 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%3124 = linalg.fill ins(%cst_694 : f16) outs(%1454 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%3125 = linalg.batch_matmul ins(%3116, %3123 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%3124 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%3126 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3125, %cst : tensor<16x256x77xf16>, tensor<f64>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x77xf16>
%3127 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%3128 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3129:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3126 : tensor<16x256x77xf16>) outs(%3128, %3127 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%3130 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3126, %3129#0 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3131 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3130 : tensor<16x256x77xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3132 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3133 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3131 : tensor<16x256x77xf16>) outs(%3132 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%3134 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3131, %3133 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3135 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3136 = linalg.batch_matmul ins(%3134, %3122 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%3135 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3137 = tensor.expand_shape %3136 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%3138 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3137 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%3139 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_410 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3140 = tensor.collapse_shape %3138 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%3141 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3142 = linalg.matmul ins(%3140, %3139 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3141 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3143 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_411, %3142 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%3144 = tensor.expand_shape %3143 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%3145 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3144, %3088 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3146 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3147 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3145 : tensor<2x256x1280xf16>) outs(%3146 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3148 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3147 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3149 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3148 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3150 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3145, %3149 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3151 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3150 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3152 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3153 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3151 : tensor<2x256x1280xf16>) outs(%3152 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3154 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3153 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3155 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3154 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%3156 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3155 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3157 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3156 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3158 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3150, %3157 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3159 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3158, %cst_412 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3160 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3159, %cst_413 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3161 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_414 : tensor<10240x1280xf16>) outs(%1492 : tensor<1280x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x10240xf16>
%3162 = tensor.collapse_shape %3160 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%3163 = linalg.fill ins(%cst_694 : f16) outs(%1495 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%3164 = linalg.matmul ins(%3162, %3161 : tensor<512x1280xf16>, tensor<1280x10240xf16>) outs(%3163 : tensor<512x10240xf16>) -> tensor<512x10240xf16>
%3165 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_415, %3164 : tensor<10240xf16>, tensor<512x10240xf16>) outs(%1495 : tensor<512x10240xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x10240xf16>
%3166 = tensor.expand_shape %3165 [[0, 1], [2]] : tensor<512x10240xf16> into tensor<2x256x10240xf16>
%3167 = tensor.extract_slice %3166[0, 0, 0] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%3168 = tensor.extract_slice %3166[0, 0, 5120] [2, 256, 5120] [1, 1, 1] : tensor<2x256x10240xf16> to tensor<2x256x5120xf16>
%3169 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3168 : tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.sqrt %cst_697 : f16
%5201 = arith.divf %arg3, %5200 : f16
%5202 = math.erf %5201 : f16
%5203 = arith.addf %5202, %cst_695 : f16
%5204 = arith.mulf %5203, %cst_698 : f16
%5205 = arith.mulf %arg3, %5204 : f16
linalg.yield %5205 : f16
} -> tensor<2x256x5120xf16>
%3170 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3167, %3169 : tensor<2x256x5120xf16>, tensor<2x256x5120xf16>) outs(%1502 : tensor<2x256x5120xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x5120xf16>
%3171 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_416 : tensor<1280x5120xf16>) outs(%1505 : tensor<5120x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<5120x1280xf16>
%3172 = tensor.collapse_shape %3170 [[0, 1], [2]] : tensor<2x256x5120xf16> into tensor<512x5120xf16>
%3173 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3174 = linalg.matmul ins(%3172, %3171 : tensor<512x5120xf16>, tensor<5120x1280xf16>) outs(%3173 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3175 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_417, %3174 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%3176 = tensor.expand_shape %3175 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%3177 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3176, %3145 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3178 = tensor.expand_shape %3177 [[0], [1, 2], [3]] : tensor<2x256x1280xf16> into tensor<2x16x16x1280xf16>
%3179 = linalg.generic {indexing_maps = [#map11, #map22], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3178 : tensor<2x16x16x1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3180 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_419 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3181 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3179, %cst_418 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%3180 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3182 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3181, %2994 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3183 = linalg.init_tensor [2, 1920, 16, 16] : tensor<2x1920x16x16xf16>
%3184 = tensor.insert_slice %3182 into %3183[0, 0, 0, 0] [2, 1280, 16, 16] [1, 1, 1, 1] : tensor<2x1280x16x16xf16> into tensor<2x1920x16x16xf16>
%3185 = tensor.insert_slice %1214 into %3184[0, 1280, 0, 0] [2, 640, 16, 16] [1, 1, 1, 1] : tensor<2x640x16x16xf16> into tensor<2x1920x16x16xf16>
%3186 = tensor.collapse_shape %3185 [[0], [1], [2, 3]] : tensor<2x1920x16x16xf16> into tensor<2x1920x256xf16>
%3187 = tensor.expand_shape %3186 [[0], [1, 2], [3]] : tensor<2x1920x256xf16> into tensor<2x32x60x256xf16>
%3188 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3189 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3188 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%3190 = linalg.init_tensor [2, 32, 60, 256] : tensor<2x32x60x256xf32>
%3191 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3189 : tensor<f32>) outs(%3190 : tensor<2x32x60x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x60x256xf32>
%3192 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3187 : tensor<2x32x60x256xf16>) outs(%3191 : tensor<2x32x60x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x60x256xf32>
%3193 = linalg.init_tensor [2, 32, 60, 256] : tensor<2x32x60x256xf64>
%3194 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3192 : tensor<2x32x60x256xf32>) outs(%3193 : tensor<2x32x60x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x60x256xf64>
%3195 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3196 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3194 : tensor<2x32x60x256xf64>) outs(%3195 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3197 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3196 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_715 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3198 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3194, %3197 : tensor<2x32x60x256xf64>, tensor<2x32x1x1xf64>) outs(%3193 : tensor<2x32x60x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x60x256xf64>
%3199 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3198 : tensor<2x32x60x256xf64>) outs(%3193 : tensor<2x32x60x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x60x256xf64>
%3200 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3201 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3199 : tensor<2x32x60x256xf64>) outs(%3200 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3202 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3201 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_715 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3203 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3202 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3204 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%3205 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3192 : tensor<2x32x60x256xf32>) outs(%3204 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3206 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3205 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_716 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3207 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3203, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%3208 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3207 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3209 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3187, %3206 : tensor<2x32x60x256xf16>, tensor<2x32x1x1xf32>) outs(%3190 : tensor<2x32x60x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x60x256xf32>
%3210 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3209, %3208 : tensor<2x32x60x256xf32>, tensor<2x32x1x1xf32>) outs(%3190 : tensor<2x32x60x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x60x256xf32>
%3211 = tensor.collapse_shape %3210 [[0], [1, 2], [3]] : tensor<2x32x60x256xf32> into tensor<2x1920x256xf32>
%3212 = tensor.expand_shape %3211 [[0], [1], [2, 3]] : tensor<2x1920x256xf32> into tensor<2x1920x16x16xf32>
%3213 = tensor.expand_shape %cst_420 [[0, 1, 2]] : tensor<1920xf16> into tensor<1920x1x1xf16>
%3214 = linalg.init_tensor [2, 1920, 16, 16] : tensor<2x1920x16x16xf32>
%3215 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3212, %3213 : tensor<2x1920x16x16xf32>, tensor<1920x1x1xf16>) outs(%3214 : tensor<2x1920x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1920x16x16xf32>
%3216 = tensor.expand_shape %cst_421 [[0, 1, 2]] : tensor<1920xf16> into tensor<1920x1x1xf16>
%3217 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3215, %3216 : tensor<2x1920x16x16xf32>, tensor<1920x1x1xf16>) outs(%3214 : tensor<2x1920x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1920x16x16xf32>
%3218 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3219 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3218 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%3220 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3219 : tensor<f16>) outs(%3183 : tensor<2x1920x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1920x16x16xf16>
%3221 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3217 : tensor<2x1920x16x16xf32>) outs(%3220 : tensor<2x1920x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1920x16x16xf16>
%3222 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3221 : tensor<2x1920x16x16xf16>) outs(%3183 : tensor<2x1920x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1920x16x16xf16>
%3223 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3222, %3221 : tensor<2x1920x16x16xf16>, tensor<2x1920x16x16xf16>) outs(%3183 : tensor<2x1920x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1920x16x16xf16>
%3224 = tensor.pad %3223 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1920x16x16xf16> to tensor<2x1920x18x18xf16>
%3225 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_423 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3226 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3224, %cst_422 : tensor<2x1920x18x18xf16>, tensor<1280x1920x3x3xf16>) outs(%3225 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3227 = linalg.generic {indexing_maps = [#map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%47 : tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280xf16>
%3228 = linalg.generic {indexing_maps = [#map5, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%3227, %47 : tensor<2x1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%3229 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_424 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3230 = linalg.fill ins(%cst_694 : f16) outs(%37 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%3231 = linalg.matmul ins(%3228, %3229 : tensor<2x1280xf16>, tensor<1280x1280xf16>) outs(%3230 : tensor<2x1280xf16>) -> tensor<2x1280xf16>
%3232 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_425, %3231 : tensor<1280xf16>, tensor<2x1280xf16>) outs(%37 : tensor<2x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280xf16>
%3233 = tensor.expand_shape %3232 [[0], [1, 2, 3]] : tensor<2x1280xf16> into tensor<2x1280x1x1xf16>
%3234 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3226, %3233 : tensor<2x1280x16x16xf16>, tensor<2x1280x1x1xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3235 = tensor.collapse_shape %3234 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%3236 = tensor.expand_shape %3235 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%3237 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3238 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3237 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%3239 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3238 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%3240 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3236 : tensor<2x32x40x256xf16>) outs(%3239 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3241 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3240 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3242 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3243 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3241 : tensor<2x32x40x256xf64>) outs(%3242 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3244 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3243 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3245 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3241, %3244 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3246 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3245 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3247 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3248 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3246 : tensor<2x32x40x256xf64>) outs(%3247 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3249 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3248 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3250 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3249 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3251 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%3252 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3240 : tensor<2x32x40x256xf32>) outs(%3251 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3253 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3252 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3254 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3250, %cst_4 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%3255 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3254 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3256 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3236, %3253 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%3257 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3256, %3255 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3258 = tensor.collapse_shape %3257 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%3259 = tensor.expand_shape %3258 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%3260 = tensor.expand_shape %cst_426 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3261 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3259, %3260 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3262 = tensor.expand_shape %cst_427 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3263 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3261, %3262 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3264 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3265 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3264 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%3266 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3265 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3267 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3263 : tensor<2x1280x16x16xf32>) outs(%3266 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3268 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3267 : tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.negf %arg3 : f16
%5201 = math.exp %5200 : f16
%5202 = arith.addf %5201, %cst_695 : f16
%5203 = arith.divf %cst_695, %5202 : f16
linalg.yield %5203 : f16
} -> tensor<2x1280x16x16xf16>
%3269 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3268, %3267 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3270 = tensor.pad %3269 low[0, 0, 1, 1] high[0, 0, 1, 1] {
^bb0(%arg3: index, %arg4: index, %arg5: index, %arg6: index):
tensor.yield %cst_694 : f16
} : tensor<2x1280x16x16xf16> to tensor<2x1280x18x18xf16>
%3271 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_429 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3272 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3270, %cst_428 : tensor<2x1280x18x18xf16>, tensor<1280x1280x3x3xf16>) outs(%3271 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3273 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_431 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3274 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3185, %cst_430 : tensor<2x1920x16x16xf16>, tensor<1280x1920x1x1xf16>) outs(%3273 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3275 = linalg.generic {indexing_maps = [#map11, #map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3274, %3272 : tensor<2x1280x16x16xf16>, tensor<2x1280x16x16xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3276 = linalg.generic {indexing_maps = [#map11, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3275, %cst_3 : tensor<2x1280x16x16xf16>, tensor<f64>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.divf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x1280x16x16xf16>
%3277 = tensor.collapse_shape %3276 [[0], [1], [2, 3]] : tensor<2x1280x16x16xf16> into tensor<2x1280x256xf16>
%3278 = tensor.expand_shape %3277 [[0], [1, 2], [3]] : tensor<2x1280x256xf16> into tensor<2x32x40x256xf16>
%3279 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3280 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3279 : tensor<f64>) outs(%10 : tensor<f32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<f32>
%3281 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3280 : tensor<f32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32):
linalg.yield %arg3 : f32
} -> tensor<2x32x40x256xf32>
%3282 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3278 : tensor<2x32x40x256xf16>) outs(%3281 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32):
%5200 = arith.extf %arg3 : f16 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3283 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3282 : tensor<2x32x40x256xf32>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f32, %arg4: f64):
%5200 = arith.extf %arg3 : f32 to f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3284 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3285 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3283 : tensor<2x32x40x256xf64>) outs(%3284 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3286 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3285 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3287 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3283, %3286 : tensor<2x32x40x256xf64>, tensor<2x32x1x1xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64, %arg5: f64):
%5200 = arith.subf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3288 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3287 : tensor<2x32x40x256xf64>) outs(%1272 : tensor<2x32x40x256xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.mulf %arg3, %arg3 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x40x256xf64>
%3289 = linalg.fill ins(%cst_699 : f64) outs(%61 : tensor<2x32x1x1xf64>) -> tensor<2x32x1x1xf64>
%3290 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3288 : tensor<2x32x40x256xf64>) outs(%3289 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.addf %arg3, %arg4 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3291 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3290 : tensor<2x32x1x1xf64>) outs(%61 : tensor<2x32x1x1xf64>) {
^bb0(%arg3: f64, %arg4: f64):
%5200 = arith.divf %arg3, %cst_705 : f64
linalg.yield %5200 : f64
} -> tensor<2x32x1x1xf64>
%3292 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3291 : tensor<2x32x1x1xf64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f64, %arg4: f32):
%5200 = arith.truncf %arg3 : f64 to f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3293 = linalg.fill ins(%cst_701 : f32) outs(%70 : tensor<2x32x1x1xf32>) -> tensor<2x32x1x1xf32>
%3294 = linalg.generic {indexing_maps = [#map11, #map13], iterator_types = ["parallel", "parallel", "reduction", "reduction"]} ins(%3282 : tensor<2x32x40x256xf32>) outs(%3293 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.addf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3295 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3294 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = arith.divf %arg3, %cst_706 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3296 = linalg.generic {indexing_maps = [#map13, #map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3292, %cst_2 : tensor<2x32x1x1xf32>, tensor<f64>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f64, %arg5: f32):
%5200 = arith.truncf %arg4 : f64 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x1x1xf32>
%3297 = linalg.generic {indexing_maps = [#map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3296 : tensor<2x32x1x1xf32>) outs(%70 : tensor<2x32x1x1xf32>) {
^bb0(%arg3: f32, %arg4: f32):
%5200 = math.rsqrt %arg3 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x1x1xf32>
%3298 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3278, %3295 : tensor<2x32x40x256xf16>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f16, %arg4: f32, %arg5: f32):
%5200 = arith.extf %arg3 : f16 to f32
%5201 = arith.subf %5200, %arg4 : f32
linalg.yield %5201 : f32
} -> tensor<2x32x40x256xf32>
%3299 = linalg.generic {indexing_maps = [#map11, #map13, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3298, %3297 : tensor<2x32x40x256xf32>, tensor<2x32x1x1xf32>) outs(%1269 : tensor<2x32x40x256xf32>) {
^bb0(%arg3: f32, %arg4: f32, %arg5: f32):
%5200 = arith.mulf %arg3, %arg4 : f32
linalg.yield %5200 : f32
} -> tensor<2x32x40x256xf32>
%3300 = tensor.collapse_shape %3299 [[0], [1, 2], [3]] : tensor<2x32x40x256xf32> into tensor<2x1280x256xf32>
%3301 = tensor.expand_shape %3300 [[0], [1], [2, 3]] : tensor<2x1280x256xf32> into tensor<2x1280x16x16xf32>
%3302 = tensor.expand_shape %cst_432 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3303 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3301, %3302 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.mulf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3304 = tensor.expand_shape %cst_433 [[0, 1, 2]] : tensor<1280xf16> into tensor<1280x1x1xf16>
%3305 = linalg.generic {indexing_maps = [#map11, #map14, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3303, %3304 : tensor<2x1280x16x16xf32>, tensor<1280x1x1xf16>) outs(%1293 : tensor<2x1280x16x16xf32>) {
^bb0(%arg3: f32, %arg4: f16, %arg5: f32):
%5200 = arith.extf %arg4 : f16 to f32
%5201 = arith.addf %arg3, %5200 : f32
linalg.yield %5201 : f32
} -> tensor<2x1280x16x16xf32>
%3306 = linalg.fill ins(%cst_699 : f64) outs(%8 : tensor<f64>) -> tensor<f64>
%3307 = linalg.generic {indexing_maps = [#map3, #map3], iterator_types = []} ins(%3306 : tensor<f64>) outs(%30 : tensor<f16>) {
^bb0(%arg3: f64, %arg4: f16):
%5200 = arith.truncf %arg3 : f64 to f16
linalg.yield %5200 : f16
} -> tensor<f16>
%3308 = linalg.generic {indexing_maps = [#map12, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3307 : tensor<f16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3309 = linalg.generic {indexing_maps = [#map11, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3305 : tensor<2x1280x16x16xf32>) outs(%3308 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f32, %arg4: f16):
%5200 = arith.truncf %arg3 : f32 to f16
linalg.yield %5200 : f16
} -> tensor<2x1280x16x16xf16>
%3310 = linalg.generic {indexing_maps = [#map10, #map11], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%cst_435 : tensor<1280xf16>) outs(%1254 : tensor<2x1280x16x16xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x1280x16x16xf16>
%3311 = linalg.conv_2d_nchw_fchw {dilations = dense<1> : vector<2xi64>, strides = dense<1> : vector<2xi64>} ins(%3309, %cst_434 : tensor<2x1280x16x16xf16>, tensor<1280x1280x1x1xf16>) outs(%3310 : tensor<2x1280x16x16xf16>) -> tensor<2x1280x16x16xf16>
%3312 = linalg.generic {indexing_maps = [#map11, #map15], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3311 : tensor<2x1280x16x16xf16>) outs(%1345 : tensor<2x16x16x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x16x16x1280xf16>
%3313 = tensor.collapse_shape %3312 [[0], [1, 2], [3]] : tensor<2x16x16x1280xf16> into tensor<2x256x1280xf16>
%3314 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3315 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3313 : tensor<2x256x1280xf16>) outs(%3314 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3316 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3315 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3317 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3316 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3318 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3313, %3317 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3319 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3318 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3320 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3321 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3319 : tensor<2x256x1280xf16>) outs(%3320 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3322 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3321 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3323 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3322 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%3324 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3323 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3325 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3324 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3326 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3318, %3325 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3327 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3326, %cst_436 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3328 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3327, %cst_437 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3329 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_438 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3330 = tensor.collapse_shape %3328 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%3331 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3332 = linalg.matmul ins(%3330, %3329 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3331 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3333 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_439 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3334 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3335 = linalg.matmul ins(%3330, %3333 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3334 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3336 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_440 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3337 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3338 = linalg.matmul ins(%3330, %3336 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3337 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3339 = tensor.expand_shape %3332 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3340 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3339 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3341 = tensor.collapse_shape %3340 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3342 = tensor.expand_shape %3335 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3343 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3342 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3344 = tensor.collapse_shape %3343 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3345 = tensor.expand_shape %3338 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3346 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3345 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3347 = tensor.collapse_shape %3346 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3348 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3344 : tensor<16x256x160xf16>) outs(%1386 : tensor<16x160x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x256xf16>
%3349 = linalg.fill ins(%cst_694 : f16) outs(%1388 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%3350 = linalg.batch_matmul ins(%3341, %3348 : tensor<16x256x160xf16>, tensor<16x160x256xf16>) outs(%3349 : tensor<16x256x256xf16>) -> tensor<16x256x256xf16>
%3351 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3350, %cst : tensor<16x256x256xf16>, tensor<f64>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x256xf16>
%3352 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%3353 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3354:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3351 : tensor<16x256x256xf16>) outs(%3353, %3352 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%3355 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3351, %3354#0 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3356 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3355 : tensor<16x256x256xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3357 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3358 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3356 : tensor<16x256x256xf16>) outs(%3357 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%3359 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3356, %3358 : tensor<16x256x256xf16>, tensor<16x256x1xf16>) outs(%1388 : tensor<16x256x256xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x256xf16>
%3360 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3361 = linalg.batch_matmul ins(%3359, %3347 : tensor<16x256x256xf16>, tensor<16x256x160xf16>) outs(%3360 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3362 = tensor.expand_shape %3361 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%3363 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3362 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%3364 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_441 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3365 = tensor.collapse_shape %3363 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%3366 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3367 = linalg.matmul ins(%3365, %3364 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3366 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3368 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_442, %3367 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%3369 = tensor.expand_shape %3368 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%3370 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3369, %3313 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3371 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3372 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3370 : tensor<2x256x1280xf16>) outs(%3371 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3373 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3372 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3374 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3373 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3375 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3370, %3374 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3376 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3375 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3377 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3378 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3376 : tensor<2x256x1280xf16>) outs(%3377 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3379 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3378 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3380 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3379 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.truncf %cst_700 : f64 to f16
%5201 = arith.addf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<2x256x1xf16>
%3381 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3380 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.rsqrt %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3382 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3381 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3383 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3375, %3382 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3384 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3383, %cst_443 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.mulf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3385 = linalg.generic {indexing_maps = [#map16, #map18, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3384, %cst_444 : tensor<2x256x1280xf16>, tensor<1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3386 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_445 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3387 = tensor.collapse_shape %3385 [[0, 1], [2]] : tensor<2x256x1280xf16> into tensor<512x1280xf16>
%3388 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3389 = linalg.matmul ins(%3387, %3386 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3388 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3390 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_446 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%3391 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3392 = linalg.matmul ins(%271, %3390 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%3391 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3393 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_447 : tensor<1280x768xf16>) outs(%1434 : tensor<768x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<768x1280xf16>
%3394 = linalg.fill ins(%cst_694 : f16) outs(%1436 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3395 = linalg.matmul ins(%271, %3393 : tensor<154x768xf16>, tensor<768x1280xf16>) outs(%3394 : tensor<154x1280xf16>) -> tensor<154x1280xf16>
%3396 = tensor.expand_shape %3389 [[0, 1], [2, 3]] : tensor<512x1280xf16> into tensor<2x256x8x160xf16>
%3397 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3396 : tensor<2x256x8x160xf16>) outs(%1377 : tensor<2x8x256x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x256x160xf16>
%3398 = tensor.collapse_shape %3397 [[0, 1], [2], [3]] : tensor<2x8x256x160xf16> into tensor<16x256x160xf16>
%3399 = tensor.expand_shape %3392 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%3400 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3399 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%3401 = tensor.collapse_shape %3400 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%3402 = tensor.expand_shape %3395 [[0, 1], [2, 3]] : tensor<154x1280xf16> into tensor<2x77x8x160xf16>
%3403 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3402 : tensor<2x77x8x160xf16>) outs(%1446 : tensor<2x8x77x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x8x77x160xf16>
%3404 = tensor.collapse_shape %3403 [[0, 1], [2], [3]] : tensor<2x8x77x160xf16> into tensor<16x77x160xf16>
%3405 = linalg.generic {indexing_maps = [#map16, #map20], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3401 : tensor<16x77x160xf16>) outs(%1452 : tensor<16x160x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<16x160x77xf16>
%3406 = linalg.fill ins(%cst_694 : f16) outs(%1454 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%3407 = linalg.batch_matmul ins(%3398, %3405 : tensor<16x256x160xf16>, tensor<16x160x77xf16>) outs(%3406 : tensor<16x256x77xf16>) -> tensor<16x256x77xf16>
%3408 = linalg.generic {indexing_maps = [#map16, #map21, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3407, %cst : tensor<16x256x77xf16>, tensor<f64>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f64, %arg5: f16):
%5200 = arith.truncf %arg4 : f64 to f16
%5201 = arith.mulf %arg3, %5200 : f16
linalg.yield %5201 : f16
} -> tensor<16x256x77xf16>
%3409 = linalg.fill ins(%c0_i64 : i64) outs(%1392 : tensor<16x256x1xi64>) -> tensor<16x256x1xi64>
%3410 = linalg.fill ins(%cst_696 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3411:2 = linalg.generic {indexing_maps = [#map16, #map17, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3408 : tensor<16x256x77xf16>) outs(%3410, %3409 : tensor<16x256x1xf16>, tensor<16x256x1xi64>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: i64):
%5200 = linalg.index 2 : index
%5201 = arith.index_cast %5200 : index to i64
%5202 = arith.cmpf ogt, %arg3, %arg4 : f16
%5203 = arith.select %5202, %arg3, %arg4 : f16
%5204 = arith.select %5202, %5201, %arg5 : i64
linalg.yield %5203, %5204 : f16, i64
} -> (tensor<16x256x1xf16>, tensor<16x256x1xi64>)
%3412 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3408, %3411#0 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3413 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3412 : tensor<16x256x77xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = math.exp %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3414 = linalg.fill ins(%cst_694 : f16) outs(%1394 : tensor<16x256x1xf16>) -> tensor<16x256x1xf16>
%3415 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3413 : tensor<16x256x77xf16>) outs(%3414 : tensor<16x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x1xf16>
%3416 = linalg.generic {indexing_maps = [#map16, #map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3413, %3415 : tensor<16x256x77xf16>, tensor<16x256x1xf16>) outs(%1454 : tensor<16x256x77xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.divf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<16x256x77xf16>
%3417 = linalg.fill ins(%cst_694 : f16) outs(%1402 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3418 = linalg.batch_matmul ins(%3416, %3404 : tensor<16x256x77xf16>, tensor<16x77x160xf16>) outs(%3417 : tensor<16x256x160xf16>) -> tensor<16x256x160xf16>
%3419 = tensor.expand_shape %3418 [[0, 1], [2], [3]] : tensor<16x256x160xf16> into tensor<2x8x256x160xf16>
%3420 = linalg.generic {indexing_maps = [#map11, #map19], iterator_types = ["parallel", "parallel", "parallel", "parallel"]} ins(%3419 : tensor<2x8x256x160xf16>) outs(%1406 : tensor<2x256x8x160xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x8x160xf16>
%3421 = linalg.generic {indexing_maps = [#map5, #map8], iterator_types = ["parallel", "parallel"]} ins(%cst_448 : tensor<1280x1280xf16>) outs(%43 : tensor<1280x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<1280x1280xf16>
%3422 = tensor.collapse_shape %3420 [[0, 1], [2, 3]] : tensor<2x256x8x160xf16> into tensor<512x1280xf16>
%3423 = linalg.fill ins(%cst_694 : f16) outs(%1367 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3424 = linalg.matmul ins(%3422, %3421 : tensor<512x1280xf16>, tensor<1280x1280xf16>) outs(%3423 : tensor<512x1280xf16>) -> tensor<512x1280xf16>
%3425 = linalg.generic {indexing_maps = [#map9, #map5, #map5], iterator_types = ["parallel", "parallel"]} ins(%cst_449, %3424 : tensor<1280xf16>, tensor<512x1280xf16>) outs(%1367 : tensor<512x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<512x1280xf16>
%3426 = tensor.expand_shape %3425 [[0, 1], [2]] : tensor<512x1280xf16> into tensor<2x256x1280xf16>
%3427 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3426, %3370 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3428 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3429 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3427 : tensor<2x256x1280xf16>) outs(%3428 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3430 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3429 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.divf %arg3, %cst_712 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3431 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3430 : tensor<2x256x1xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
linalg.yield %arg3 : f16
} -> tensor<2x256x1280xf16>
%3432 = linalg.generic {indexing_maps = [#map16, #map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3427, %3431 : tensor<2x256x1280xf16>, tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16, %arg5: f16):
%5200 = arith.subf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3433 = linalg.generic {indexing_maps = [#map16, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3432 : tensor<2x256x1280xf16>) outs(%1352 : tensor<2x256x1280xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.mulf %arg3, %arg3 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1280xf16>
%3434 = linalg.fill ins(%cst_694 : f16) outs(%1348 : tensor<2x256x1xf16>) -> tensor<2x256x1xf16>
%3435 = linalg.generic {indexing_maps = [#map16, #map17], iterator_types = ["parallel", "parallel", "reduction"]} ins(%3433 : tensor<2x256x1280xf16>) outs(%3434 : tensor<2x256x1xf16>) {
^bb0(%arg3: f16, %arg4: f16):
%5200 = arith.addf %arg3, %arg4 : f16
linalg.yield %5200 : f16
} -> tensor<2x256x1xf16>
%3436 = linalg.generic {indexing_maps = [#map17, #map16], iterator_types = ["parallel", "parallel", "parallel"]} ins(%3435 : tensor<2x256x1xf16>) outs(%1348 : tensor<2x256x1xf16>) {
^b
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment