transformer.txt

def @main(%input1: Tensor[(20, 32, 256), float32], %input0: Tensor[(10, 32, 256), float32], hash="4f4d033066b8edfd") -> Tensor[(20, 32, 256), float16] {
  %221 = fn (%p0175: Tensor[(20, 32, 256), float32], Primitive=1, hash="351853b89f5901d4") -> Tensor[(20, 32, 256), float16] {
    cast(%p0175, dtype="float16") /* ty=Tensor[(20, 32, 256), float16] */
  };
  %222 = %221(%input1) /* ty=Tensor[(20, 32, 256), float16] */;
  %223 = fn (%p0174: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0174, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %224 = %223(%222) /* ty=Tensor[(640, 256), float16] */;
  %225 = fn (%p0173: Tensor[(640, 256), float16], %p1120: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p0173, %p1120, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %226 = %225(%224, meta[relay.Constant][0] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %227 = fn (%p0172: Tensor[(640, 768), float16], %p1119: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %220 = reshape(%p0172, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%220, %p1119) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %228 = %227(%226, meta[relay.Constant][1] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %229 = fn (%p0171: Tensor[(20, 32, 768), float16], %p1118: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %217 = strided_slice(%p0171, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %218 = multiply(%217, %p1118) /* ty=Tensor[(20, 32, 256), float16] */;
    %219 = reshape(%218, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%219, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %232 = fn (%p0176: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %230 = strided_slice(%p0176, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %231 = reshape(%230, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%231, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %233 = %229(%228, meta[relay.Constant][2] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %234 = %232(%228) /* ty=Tensor[(256, 20, 32), float16] */;
  %235 = fn (%p0170: Tensor[(256, 20, 32), float16], %p1117: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %216 = nn.batch_matmul(%p0170, %p1117, meta[relay.attrs.BatchMatmulAttrs][23]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%216, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %236 = %235(%233, %234) /* ty=Tensor[(256, 20, 20), float32] */;
  %237 = fn (%p0169: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p0169) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %238 = %237(%236) /* ty=Tensor[(256, 20, 20), float32] */;
  %239 = fn (%p0168: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p0168, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %242 = fn (%p0177: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %240 = strided_slice(%p0177, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %241 = reshape(%240, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%241, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %243 = %239(%238) /* ty=Tensor[(256, 20, 20), float16] */;
  %244 = %242(%228) /* ty=Tensor[(256, 32, 20), float16] */;
  %245 = fn (%p0167: Tensor[(256, 20, 20), float16], %p1116: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p0167, %p1116, meta[relay.attrs.BatchMatmulAttrs][22]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %246 = %245(%243, %244) /* ty=Tensor[(256, 20, 32), float16] */;
  %247 = fn (%p0166: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %215 = transpose(%p0166, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%215, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %248 = %247(%246) /* ty=Tensor[(640, 256), float16] */;
  %249 = fn (%p0165: Tensor[(640, 256), float16], %p1115: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0165, %p1115, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %250 = %249(%248, meta[relay.Constant][3] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %251 = fn (%p0164: Tensor[(640, 256), float16], %p1114: Tensor[(256), float16], %p242: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %213 = reshape(%p0164, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %214 = add(%213, %p1114) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p242, %214) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %252 = %251(%250, meta[relay.Constant][4] /* ty=Tensor[(256), float16] */, %222) /* ty=Tensor[(20, 32, 256), float16] */;
  %253 = fn (%p0178: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0178, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %254 = %253(%252) /* ty=Tensor[(20, 32, 1), float16] */;
  %255 = fn (%p0179: Tensor[(20, 32, 256), float16], %p1121: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0179, %p1121, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %256 = %255(%252, %254) /* ty=Tensor[(20, 32, 1), float16] */;
  %257 = fn (%p0163: Tensor[(20, 32, 256), float16], %p1113: Tensor[(20, 32, 1), float16], %p241: Tensor[(20, 32, 1), float16], %p318: float16, %p418: Tensor[(256), float16], %p518: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %208 = add(%p241, %p318) /* ty=Tensor[(20, 32, 1), float16] */;
    %209 = subtract(%p0163, %p1113) /* ty=Tensor[(20, 32, 256), float16] */;
    %210 = sqrt(%208) /* ty=Tensor[(20, 32, 1), float16] */;
    %211 = divide(%209, %210) /* ty=Tensor[(20, 32, 256), float16] */;
    %212 = multiply(%211, %p418) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%212, %p518) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %258 = %257(%252, %254, %256, meta[relay.Constant][5] /* ty=float16 */, meta[relay.Constant][6] /* ty=Tensor[(256), float16] */, meta[relay.Constant][7] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %259 = fn (%p0162: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0162, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %260 = %259(%258) /* ty=Tensor[(640, 256), float16] */;
  %261 = fn (%p0161: Tensor[(640, 256), float16], %p1112: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0161, %p1112, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %262 = %261(%260, meta[relay.Constant][8] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %263 = fn (%p0160: Tensor[(640, 256), float16], %p1111: Tensor[(256), float16], %p240: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %204 = reshape(%p0160, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %205 = add(%204, %p1111) /* ty=Tensor[(20, 32, 256), float16] */;
    %206 = multiply(%205, %p240) /* ty=Tensor[(20, 32, 256), float16] */;
    %207 = reshape(%206, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%207, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %411 = fn (%p0292: Tensor[(10, 32, 256), float32], Primitive=1, hash="5c41c973fe44e241") -> Tensor[(10, 32, 256), float16] {
    cast(%p0292, dtype="float16") /* ty=Tensor[(10, 32, 256), float16] */
  };
  %412 = %411(%input0) /* ty=Tensor[(10, 32, 256), float16] */;
  %413 = fn (%p0291: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0291, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %414 = %413(%412) /* ty=Tensor[(320, 256), float16] */;
  %415 = fn (%p0290: Tensor[(320, 256), float16], %p1202: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0290, %p1202, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %416 = %415(%414, meta[relay.Constant][11] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %417 = fn (%p0289: Tensor[(320, 768), float16], %p1201: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %410 = reshape(%p0289, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%410, %p1201) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %418 = %417(%416, meta[relay.Constant][12] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %419 = fn (%p0288: Tensor[(10, 32, 768), float16], %p1200: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %407 = strided_slice(%p0288, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %408 = multiply(%407, %p1200) /* ty=Tensor[(10, 32, 256), float16] */;
    %409 = reshape(%408, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%409, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %422 = fn (%p0293: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %420 = strided_slice(%p0293, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %421 = reshape(%420, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%421, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %423 = %419(%418, meta[relay.Constant][13] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %424 = %422(%418) /* ty=Tensor[(256, 10, 32), float16] */;
  %425 = fn (%p0287: Tensor[(256, 10, 32), float16], %p1199: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %406 = nn.batch_matmul(%p0287, %p1199, meta[relay.attrs.BatchMatmulAttrs][35]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%406, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %426 = %425(%423, %424) /* ty=Tensor[(256, 10, 10), float32] */;
  %427 = fn (%p0286: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0286) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %428 = %427(%426) /* ty=Tensor[(256, 10, 10), float32] */;
  %429 = fn (%p0285: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0285, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %432 = fn (%p0294: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %430 = strided_slice(%p0294, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %431 = reshape(%430, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%431, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %433 = %429(%428) /* ty=Tensor[(256, 10, 10), float16] */;
  %434 = %432(%418) /* ty=Tensor[(256, 32, 10), float16] */;
  %435 = fn (%p0284: Tensor[(256, 10, 10), float16], %p1198: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0284, %p1198, meta[relay.attrs.BatchMatmulAttrs][34]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %436 = %435(%433, %434) /* ty=Tensor[(256, 10, 32), float16] */;
  %437 = fn (%p0283: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %405 = transpose(%p0283, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%405, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %438 = %437(%436) /* ty=Tensor[(320, 256), float16] */;
  %439 = fn (%p0282: Tensor[(320, 256), float16], %p1197: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0282, %p1197, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %440 = %439(%438, meta[relay.Constant][14] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %441 = fn (%p0281: Tensor[(320, 256), float16], %p1196: Tensor[(256), float16], %p267: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %403 = reshape(%p0281, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %404 = add(%403, %p1196) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p267, %404) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %442 = %441(%440, meta[relay.Constant][15] /* ty=Tensor[(256), float16] */, %412) /* ty=Tensor[(10, 32, 256), float16] */;
  %443 = fn (%p0295: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0295, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %444 = %443(%442) /* ty=Tensor[(10, 32, 1), float16] */;
  %445 = fn (%p0296: Tensor[(10, 32, 256), float16], %p1203: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0296, %p1203, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %446 = %445(%442, %444) /* ty=Tensor[(10, 32, 1), float16] */;
  %447 = fn (%p0280: Tensor[(10, 32, 256), float16], %p1195: Tensor[(10, 32, 1), float16], %p266: Tensor[(10, 32, 1), float16], %p331: float16, %p431: Tensor[(256), float16], %p531: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %398 = add(%p266, %p331) /* ty=Tensor[(10, 32, 1), float16] */;
    %399 = subtract(%p0280, %p1195) /* ty=Tensor[(10, 32, 256), float16] */;
    %400 = sqrt(%398) /* ty=Tensor[(10, 32, 1), float16] */;
    %401 = divide(%399, %400) /* ty=Tensor[(10, 32, 256), float16] */;
    %402 = multiply(%401, %p431) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%402, %p531) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %448 = %447(%442, %444, %446, meta[relay.Constant][16] /* ty=float16 */, meta[relay.Constant][17] /* ty=Tensor[(256), float16] */, meta[relay.Constant][18] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %449 = fn (%p0279: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0279, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %450 = %449(%448) /* ty=Tensor[(320, 256), float16] */;
  %451 = fn (%p0278: Tensor[(320, 256), float16], %p1194: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0278, %p1194, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %452 = %451(%450, meta[relay.Constant][19] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %453 = fn (%p0277: Tensor[(320, 2048), float16], %p1193: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %395 = reshape(%p0277, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %396 = add(%395, %p1193) /* ty=Tensor[(10, 32, 2048), float16] */;
    %397 = nn.relu(%396) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%397, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %454 = %453(%452, meta[relay.Constant][20] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %455 = fn (%p0276: Tensor[(320, 2048), float16], %p1192: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0276, %p1192, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %456 = %455(%454, meta[relay.Constant][21] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %457 = fn (%p0275: Tensor[(320, 256), float16], %p1191: Tensor[(256), float16], %p265: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %393 = reshape(%p0275, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %394 = add(%393, %p1191) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p265, %394) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %458 = %457(%456, meta[relay.Constant][22] /* ty=Tensor[(256), float16] */, %448) /* ty=Tensor[(10, 32, 256), float16] */;
  %459 = fn (%p0297: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0297, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %460 = %459(%458) /* ty=Tensor[(10, 32, 1), float16] */;
  %461 = fn (%p0298: Tensor[(10, 32, 256), float16], %p1204: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0298, %p1204, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %462 = %461(%458, %460) /* ty=Tensor[(10, 32, 1), float16] */;
  %463 = fn (%p0274: Tensor[(10, 32, 256), float16], %p1190: Tensor[(10, 32, 1), float16], %p264: Tensor[(10, 32, 1), float16], %p330: float16, %p430: Tensor[(256), float16], %p530: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %388 = add(%p264, %p330) /* ty=Tensor[(10, 32, 1), float16] */;
    %389 = subtract(%p0274, %p1190) /* ty=Tensor[(10, 32, 256), float16] */;
    %390 = sqrt(%388) /* ty=Tensor[(10, 32, 1), float16] */;
    %391 = divide(%389, %390) /* ty=Tensor[(10, 32, 256), float16] */;
    %392 = multiply(%391, %p430) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%392, %p530) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %464 = %463(%458, %460, %462, meta[relay.Constant][23] /* ty=float16 */, meta[relay.Constant][24] /* ty=Tensor[(256), float16] */, meta[relay.Constant][25] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %465 = fn (%p0273: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0273, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %466 = %465(%464) /* ty=Tensor[(320, 256), float16] */;
  %467 = fn (%p0272: Tensor[(320, 256), float16], %p1189: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0272, %p1189, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %468 = %467(%466, meta[relay.Constant][26] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %469 = fn (%p0271: Tensor[(320, 768), float16], %p1188: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %387 = reshape(%p0271, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%387, %p1188) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %470 = %469(%468, meta[relay.Constant][27] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %471 = fn (%p0270: Tensor[(10, 32, 768), float16], %p1187: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %384 = strided_slice(%p0270, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %385 = multiply(%384, %p1187) /* ty=Tensor[(10, 32, 256), float16] */;
    %386 = reshape(%385, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%386, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %474 = fn (%p0299: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %472 = strided_slice(%p0299, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %473 = reshape(%472, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%473, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %475 = %471(%470, meta[relay.Constant][28] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %476 = %474(%470) /* ty=Tensor[(256, 10, 32), float16] */;
  %477 = fn (%p0269: Tensor[(256, 10, 32), float16], %p1186: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %383 = nn.batch_matmul(%p0269, %p1186, meta[relay.attrs.BatchMatmulAttrs][33]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%383, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %478 = %477(%475, %476) /* ty=Tensor[(256, 10, 10), float32] */;
  %479 = fn (%p0268: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0268) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %480 = %479(%478) /* ty=Tensor[(256, 10, 10), float32] */;
  %481 = fn (%p0267: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0267, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %484 = fn (%p0300: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %482 = strided_slice(%p0300, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %483 = reshape(%482, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%483, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %485 = %481(%480) /* ty=Tensor[(256, 10, 10), float16] */;
  %486 = %484(%470) /* ty=Tensor[(256, 32, 10), float16] */;
  %487 = fn (%p0266: Tensor[(256, 10, 10), float16], %p1185: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0266, %p1185, meta[relay.attrs.BatchMatmulAttrs][32]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %488 = %487(%485, %486) /* ty=Tensor[(256, 10, 32), float16] */;
  %489 = fn (%p0265: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %382 = transpose(%p0265, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%382, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %490 = %489(%488) /* ty=Tensor[(320, 256), float16] */;
  %491 = fn (%p0264: Tensor[(320, 256), float16], %p1184: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0264, %p1184, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %492 = %491(%490, meta[relay.Constant][29] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %493 = fn (%p0263: Tensor[(320, 256), float16], %p1183: Tensor[(256), float16], %p263: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %380 = reshape(%p0263, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %381 = add(%380, %p1183) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p263, %381) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %494 = %493(%492, meta[relay.Constant][30] /* ty=Tensor[(256), float16] */, %464) /* ty=Tensor[(10, 32, 256), float16] */;
  %495 = fn (%p0301: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0301, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %496 = %495(%494) /* ty=Tensor[(10, 32, 1), float16] */;
  %497 = fn (%p0302: Tensor[(10, 32, 256), float16], %p1205: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0302, %p1205, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %498 = %497(%494, %496) /* ty=Tensor[(10, 32, 1), float16] */;
  %499 = fn (%p0262: Tensor[(10, 32, 256), float16], %p1182: Tensor[(10, 32, 1), float16], %p262: Tensor[(10, 32, 1), float16], %p329: float16, %p429: Tensor[(256), float16], %p529: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %375 = add(%p262, %p329) /* ty=Tensor[(10, 32, 1), float16] */;
    %376 = subtract(%p0262, %p1182) /* ty=Tensor[(10, 32, 256), float16] */;
    %377 = sqrt(%375) /* ty=Tensor[(10, 32, 1), float16] */;
    %378 = divide(%376, %377) /* ty=Tensor[(10, 32, 256), float16] */;
    %379 = multiply(%378, %p429) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%379, %p529) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %500 = %499(%494, %496, %498, meta[relay.Constant][31] /* ty=float16 */, meta[relay.Constant][32] /* ty=Tensor[(256), float16] */, meta[relay.Constant][33] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %501 = fn (%p0261: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0261, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %502 = %501(%500) /* ty=Tensor[(320, 256), float16] */;
  %503 = fn (%p0260: Tensor[(320, 256), float16], %p1181: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0260, %p1181, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %504 = %503(%502, meta[relay.Constant][34] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %505 = fn (%p0259: Tensor[(320, 2048), float16], %p1180: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %372 = reshape(%p0259, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %373 = add(%372, %p1180) /* ty=Tensor[(10, 32, 2048), float16] */;
    %374 = nn.relu(%373) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%374, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %506 = %505(%504, meta[relay.Constant][35] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %507 = fn (%p0258: Tensor[(320, 2048), float16], %p1179: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0258, %p1179, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %508 = %507(%506, meta[relay.Constant][36] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %509 = fn (%p0257: Tensor[(320, 256), float16], %p1178: Tensor[(256), float16], %p261: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %370 = reshape(%p0257, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %371 = add(%370, %p1178) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p261, %371) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %510 = %509(%508, meta[relay.Constant][37] /* ty=Tensor[(256), float16] */, %500) /* ty=Tensor[(10, 32, 256), float16] */;
  %511 = fn (%p0303: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0303, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %512 = %511(%510) /* ty=Tensor[(10, 32, 1), float16] */;
  %513 = fn (%p0304: Tensor[(10, 32, 256), float16], %p1206: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0304, %p1206, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %514 = %513(%510, %512) /* ty=Tensor[(10, 32, 1), float16] */;
  %515 = fn (%p0256: Tensor[(10, 32, 256), float16], %p1177: Tensor[(10, 32, 1), float16], %p260: Tensor[(10, 32, 1), float16], %p328: float16, %p428: Tensor[(256), float16], %p528: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %365 = add(%p260, %p328) /* ty=Tensor[(10, 32, 1), float16] */;
    %366 = subtract(%p0256, %p1177) /* ty=Tensor[(10, 32, 256), float16] */;
    %367 = sqrt(%365) /* ty=Tensor[(10, 32, 1), float16] */;
    %368 = divide(%366, %367) /* ty=Tensor[(10, 32, 256), float16] */;
    %369 = multiply(%368, %p428) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%369, %p528) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %516 = %515(%510, %512, %514, meta[relay.Constant][38] /* ty=float16 */, meta[relay.Constant][39] /* ty=Tensor[(256), float16] */, meta[relay.Constant][40] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %517 = fn (%p0255: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0255, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %518 = %517(%516) /* ty=Tensor[(320, 256), float16] */;
  %519 = fn (%p0254: Tensor[(320, 256), float16], %p1176: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0254, %p1176, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %520 = %519(%518, meta[relay.Constant][41] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %521 = fn (%p0253: Tensor[(320, 768), float16], %p1175: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %364 = reshape(%p0253, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%364, %p1175) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %522 = %521(%520, meta[relay.Constant][42] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %523 = fn (%p0252: Tensor[(10, 32, 768), float16], %p1174: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %361 = strided_slice(%p0252, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %362 = multiply(%361, %p1174) /* ty=Tensor[(10, 32, 256), float16] */;
    %363 = reshape(%362, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%363, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %526 = fn (%p0305: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %524 = strided_slice(%p0305, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %525 = reshape(%524, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%525, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %527 = %523(%522, meta[relay.Constant][43] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %528 = %526(%522) /* ty=Tensor[(256, 10, 32), float16] */;
  %529 = fn (%p0251: Tensor[(256, 10, 32), float16], %p1173: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %360 = nn.batch_matmul(%p0251, %p1173, meta[relay.attrs.BatchMatmulAttrs][31]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%360, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %530 = %529(%527, %528) /* ty=Tensor[(256, 10, 10), float32] */;
  %531 = fn (%p0250: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0250) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %532 = %531(%530) /* ty=Tensor[(256, 10, 10), float32] */;
  %533 = fn (%p0249: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0249, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %536 = fn (%p0306: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %534 = strided_slice(%p0306, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %535 = reshape(%534, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%535, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %537 = %533(%532) /* ty=Tensor[(256, 10, 10), float16] */;
  %538 = %536(%522) /* ty=Tensor[(256, 32, 10), float16] */;
  %539 = fn (%p0248: Tensor[(256, 10, 10), float16], %p1172: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0248, %p1172, meta[relay.attrs.BatchMatmulAttrs][30]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %540 = %539(%537, %538) /* ty=Tensor[(256, 10, 32), float16] */;
  %541 = fn (%p0247: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %359 = transpose(%p0247, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%359, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %542 = %541(%540) /* ty=Tensor[(320, 256), float16] */;
  %543 = fn (%p0246: Tensor[(320, 256), float16], %p1171: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0246, %p1171, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %544 = %543(%542, meta[relay.Constant][44] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %545 = fn (%p0245: Tensor[(320, 256), float16], %p1170: Tensor[(256), float16], %p259: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %357 = reshape(%p0245, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %358 = add(%357, %p1170) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p259, %358) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %546 = %545(%544, meta[relay.Constant][45] /* ty=Tensor[(256), float16] */, %516) /* ty=Tensor[(10, 32, 256), float16] */;
  %547 = fn (%p0307: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0307, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %548 = %547(%546) /* ty=Tensor[(10, 32, 1), float16] */;
  %549 = fn (%p0308: Tensor[(10, 32, 256), float16], %p1207: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0308, %p1207, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %550 = %549(%546, %548) /* ty=Tensor[(10, 32, 1), float16] */;
  %551 = fn (%p0244: Tensor[(10, 32, 256), float16], %p1169: Tensor[(10, 32, 1), float16], %p258: Tensor[(10, 32, 1), float16], %p327: float16, %p427: Tensor[(256), float16], %p527: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %352 = add(%p258, %p327) /* ty=Tensor[(10, 32, 1), float16] */;
    %353 = subtract(%p0244, %p1169) /* ty=Tensor[(10, 32, 256), float16] */;
    %354 = sqrt(%352) /* ty=Tensor[(10, 32, 1), float16] */;
    %355 = divide(%353, %354) /* ty=Tensor[(10, 32, 256), float16] */;
    %356 = multiply(%355, %p427) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%356, %p527) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %552 = %551(%546, %548, %550, meta[relay.Constant][46] /* ty=float16 */, meta[relay.Constant][47] /* ty=Tensor[(256), float16] */, meta[relay.Constant][48] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %553 = fn (%p0243: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0243, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %554 = %553(%552) /* ty=Tensor[(320, 256), float16] */;
  %555 = fn (%p0242: Tensor[(320, 256), float16], %p1168: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0242, %p1168, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %556 = %555(%554, meta[relay.Constant][49] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %557 = fn (%p0241: Tensor[(320, 2048), float16], %p1167: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %349 = reshape(%p0241, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %350 = add(%349, %p1167) /* ty=Tensor[(10, 32, 2048), float16] */;
    %351 = nn.relu(%350) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%351, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %558 = %557(%556, meta[relay.Constant][50] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %559 = fn (%p0240: Tensor[(320, 2048), float16], %p1166: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0240, %p1166, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %560 = %559(%558, meta[relay.Constant][51] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %561 = fn (%p0239: Tensor[(320, 256), float16], %p1165: Tensor[(256), float16], %p257: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %347 = reshape(%p0239, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %348 = add(%347, %p1165) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p257, %348) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %562 = %561(%560, meta[relay.Constant][52] /* ty=Tensor[(256), float16] */, %552) /* ty=Tensor[(10, 32, 256), float16] */;
  %563 = fn (%p0309: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0309, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %564 = %563(%562) /* ty=Tensor[(10, 32, 1), float16] */;
  %565 = fn (%p0310: Tensor[(10, 32, 256), float16], %p1208: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0310, %p1208, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %566 = %565(%562, %564) /* ty=Tensor[(10, 32, 1), float16] */;
  %567 = fn (%p0238: Tensor[(10, 32, 256), float16], %p1164: Tensor[(10, 32, 1), float16], %p256: Tensor[(10, 32, 1), float16], %p326: float16, %p426: Tensor[(256), float16], %p526: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %342 = add(%p256, %p326) /* ty=Tensor[(10, 32, 1), float16] */;
    %343 = subtract(%p0238, %p1164) /* ty=Tensor[(10, 32, 256), float16] */;
    %344 = sqrt(%342) /* ty=Tensor[(10, 32, 1), float16] */;
    %345 = divide(%343, %344) /* ty=Tensor[(10, 32, 256), float16] */;
    %346 = multiply(%345, %p426) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%346, %p526) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %568 = %567(%562, %564, %566, meta[relay.Constant][53] /* ty=float16 */, meta[relay.Constant][54] /* ty=Tensor[(256), float16] */, meta[relay.Constant][55] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %569 = fn (%p0237: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0237, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %570 = %569(%568) /* ty=Tensor[(320, 256), float16] */;
  %571 = fn (%p0236: Tensor[(320, 256), float16], %p1163: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0236, %p1163, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %572 = %571(%570, meta[relay.Constant][56] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %573 = fn (%p0235: Tensor[(320, 768), float16], %p1162: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %341 = reshape(%p0235, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%341, %p1162) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %574 = %573(%572, meta[relay.Constant][57] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %575 = fn (%p0234: Tensor[(10, 32, 768), float16], %p1161: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %338 = strided_slice(%p0234, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %339 = multiply(%338, %p1161) /* ty=Tensor[(10, 32, 256), float16] */;
    %340 = reshape(%339, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%340, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %578 = fn (%p0311: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %576 = strided_slice(%p0311, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %577 = reshape(%576, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%577, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %579 = %575(%574, meta[relay.Constant][58] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %580 = %578(%574) /* ty=Tensor[(256, 10, 32), float16] */;
  %581 = fn (%p0233: Tensor[(256, 10, 32), float16], %p1160: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %337 = nn.batch_matmul(%p0233, %p1160, meta[relay.attrs.BatchMatmulAttrs][29]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%337, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %582 = %581(%579, %580) /* ty=Tensor[(256, 10, 10), float32] */;
  %583 = fn (%p0232: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0232) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %584 = %583(%582) /* ty=Tensor[(256, 10, 10), float32] */;
  %585 = fn (%p0231: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0231, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %588 = fn (%p0312: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %586 = strided_slice(%p0312, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %587 = reshape(%586, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%587, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %589 = %585(%584) /* ty=Tensor[(256, 10, 10), float16] */;
  %590 = %588(%574) /* ty=Tensor[(256, 32, 10), float16] */;
  %591 = fn (%p0230: Tensor[(256, 10, 10), float16], %p1159: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0230, %p1159, meta[relay.attrs.BatchMatmulAttrs][28]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %592 = %591(%589, %590) /* ty=Tensor[(256, 10, 32), float16] */;
  %593 = fn (%p0229: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %336 = transpose(%p0229, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%336, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %594 = %593(%592) /* ty=Tensor[(320, 256), float16] */;
  %595 = fn (%p0228: Tensor[(320, 256), float16], %p1158: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0228, %p1158, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %596 = %595(%594, meta[relay.Constant][59] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %597 = fn (%p0227: Tensor[(320, 256), float16], %p1157: Tensor[(256), float16], %p255: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %334 = reshape(%p0227, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %335 = add(%334, %p1157) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p255, %335) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %598 = %597(%596, meta[relay.Constant][60] /* ty=Tensor[(256), float16] */, %568) /* ty=Tensor[(10, 32, 256), float16] */;
  %599 = fn (%p0313: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0313, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %600 = %599(%598) /* ty=Tensor[(10, 32, 1), float16] */;
  %601 = fn (%p0314: Tensor[(10, 32, 256), float16], %p1209: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0314, %p1209, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %602 = %601(%598, %600) /* ty=Tensor[(10, 32, 1), float16] */;
  %603 = fn (%p0226: Tensor[(10, 32, 256), float16], %p1156: Tensor[(10, 32, 1), float16], %p254: Tensor[(10, 32, 1), float16], %p325: float16, %p425: Tensor[(256), float16], %p525: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %329 = add(%p254, %p325) /* ty=Tensor[(10, 32, 1), float16] */;
    %330 = subtract(%p0226, %p1156) /* ty=Tensor[(10, 32, 256), float16] */;
    %331 = sqrt(%329) /* ty=Tensor[(10, 32, 1), float16] */;
    %332 = divide(%330, %331) /* ty=Tensor[(10, 32, 256), float16] */;
    %333 = multiply(%332, %p425) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%333, %p525) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %604 = %603(%598, %600, %602, meta[relay.Constant][61] /* ty=float16 */, meta[relay.Constant][62] /* ty=Tensor[(256), float16] */, meta[relay.Constant][63] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %605 = fn (%p0225: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0225, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %606 = %605(%604) /* ty=Tensor[(320, 256), float16] */;
  %607 = fn (%p0224: Tensor[(320, 256), float16], %p1155: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0224, %p1155, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %608 = %607(%606, meta[relay.Constant][64] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %609 = fn (%p0223: Tensor[(320, 2048), float16], %p1154: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %326 = reshape(%p0223, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %327 = add(%326, %p1154) /* ty=Tensor[(10, 32, 2048), float16] */;
    %328 = nn.relu(%327) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%328, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %610 = %609(%608, meta[relay.Constant][65] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %611 = fn (%p0222: Tensor[(320, 2048), float16], %p1153: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0222, %p1153, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %612 = %611(%610, meta[relay.Constant][66] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %613 = fn (%p0221: Tensor[(320, 256), float16], %p1152: Tensor[(256), float16], %p253: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %324 = reshape(%p0221, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %325 = add(%324, %p1152) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p253, %325) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %614 = %613(%612, meta[relay.Constant][67] /* ty=Tensor[(256), float16] */, %604) /* ty=Tensor[(10, 32, 256), float16] */;
  %615 = fn (%p0315: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0315, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %616 = %615(%614) /* ty=Tensor[(10, 32, 1), float16] */;
  %617 = fn (%p0316: Tensor[(10, 32, 256), float16], %p1210: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0316, %p1210, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %618 = %617(%614, %616) /* ty=Tensor[(10, 32, 1), float16] */;
  %619 = fn (%p0220: Tensor[(10, 32, 256), float16], %p1151: Tensor[(10, 32, 1), float16], %p252: Tensor[(10, 32, 1), float16], %p324: float16, %p424: Tensor[(256), float16], %p524: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %319 = add(%p252, %p324) /* ty=Tensor[(10, 32, 1), float16] */;
    %320 = subtract(%p0220, %p1151) /* ty=Tensor[(10, 32, 256), float16] */;
    %321 = sqrt(%319) /* ty=Tensor[(10, 32, 1), float16] */;
    %322 = divide(%320, %321) /* ty=Tensor[(10, 32, 256), float16] */;
    %323 = multiply(%322, %p424) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%323, %p524) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %620 = %619(%614, %616, %618, meta[relay.Constant][68] /* ty=float16 */, meta[relay.Constant][69] /* ty=Tensor[(256), float16] */, meta[relay.Constant][70] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %621 = fn (%p0219: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0219, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %622 = %621(%620) /* ty=Tensor[(320, 256), float16] */;
  %623 = fn (%p0218: Tensor[(320, 256), float16], %p1150: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0218, %p1150, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %624 = %623(%622, meta[relay.Constant][71] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %625 = fn (%p0217: Tensor[(320, 768), float16], %p1149: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %318 = reshape(%p0217, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%318, %p1149) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %626 = %625(%624, meta[relay.Constant][72] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %627 = fn (%p0216: Tensor[(10, 32, 768), float16], %p1148: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %315 = strided_slice(%p0216, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %316 = multiply(%315, %p1148) /* ty=Tensor[(10, 32, 256), float16] */;
    %317 = reshape(%316, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%317, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %630 = fn (%p0317: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %628 = strided_slice(%p0317, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %629 = reshape(%628, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%629, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %631 = %627(%626, meta[relay.Constant][73] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %632 = %630(%626) /* ty=Tensor[(256, 10, 32), float16] */;
  %633 = fn (%p0215: Tensor[(256, 10, 32), float16], %p1147: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %314 = nn.batch_matmul(%p0215, %p1147, meta[relay.attrs.BatchMatmulAttrs][27]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%314, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %634 = %633(%631, %632) /* ty=Tensor[(256, 10, 10), float32] */;
  %635 = fn (%p0214: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0214) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %636 = %635(%634) /* ty=Tensor[(256, 10, 10), float32] */;
  %637 = fn (%p0213: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0213, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %640 = fn (%p0318: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %638 = strided_slice(%p0318, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %639 = reshape(%638, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%639, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %641 = %637(%636) /* ty=Tensor[(256, 10, 10), float16] */;
  %642 = %640(%626) /* ty=Tensor[(256, 32, 10), float16] */;
  %643 = fn (%p0212: Tensor[(256, 10, 10), float16], %p1146: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0212, %p1146, meta[relay.attrs.BatchMatmulAttrs][26]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %644 = %643(%641, %642) /* ty=Tensor[(256, 10, 32), float16] */;
  %645 = fn (%p0211: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %313 = transpose(%p0211, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%313, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %646 = %645(%644) /* ty=Tensor[(320, 256), float16] */;
  %647 = fn (%p0210: Tensor[(320, 256), float16], %p1145: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0210, %p1145, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %648 = %647(%646, meta[relay.Constant][74] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %649 = fn (%p0209: Tensor[(320, 256), float16], %p1144: Tensor[(256), float16], %p251: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %311 = reshape(%p0209, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %312 = add(%311, %p1144) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p251, %312) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %650 = %649(%648, meta[relay.Constant][75] /* ty=Tensor[(256), float16] */, %620) /* ty=Tensor[(10, 32, 256), float16] */;
  %651 = fn (%p0319: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0319, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %652 = %651(%650) /* ty=Tensor[(10, 32, 1), float16] */;
  %653 = fn (%p0320: Tensor[(10, 32, 256), float16], %p1211: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0320, %p1211, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %654 = %653(%650, %652) /* ty=Tensor[(10, 32, 1), float16] */;
  %655 = fn (%p0208: Tensor[(10, 32, 256), float16], %p1143: Tensor[(10, 32, 1), float16], %p250: Tensor[(10, 32, 1), float16], %p323: float16, %p423: Tensor[(256), float16], %p523: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %306 = add(%p250, %p323) /* ty=Tensor[(10, 32, 1), float16] */;
    %307 = subtract(%p0208, %p1143) /* ty=Tensor[(10, 32, 256), float16] */;
    %308 = sqrt(%306) /* ty=Tensor[(10, 32, 1), float16] */;
    %309 = divide(%307, %308) /* ty=Tensor[(10, 32, 256), float16] */;
    %310 = multiply(%309, %p423) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%310, %p523) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %656 = %655(%650, %652, %654, meta[relay.Constant][76] /* ty=float16 */, meta[relay.Constant][77] /* ty=Tensor[(256), float16] */, meta[relay.Constant][78] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %657 = fn (%p0207: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0207, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %658 = %657(%656) /* ty=Tensor[(320, 256), float16] */;
  %659 = fn (%p0206: Tensor[(320, 256), float16], %p1142: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0206, %p1142, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %660 = %659(%658, meta[relay.Constant][79] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %661 = fn (%p0205: Tensor[(320, 2048), float16], %p1141: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %303 = reshape(%p0205, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %304 = add(%303, %p1141) /* ty=Tensor[(10, 32, 2048), float16] */;
    %305 = nn.relu(%304) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%305, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %662 = %661(%660, meta[relay.Constant][80] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %663 = fn (%p0204: Tensor[(320, 2048), float16], %p1140: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0204, %p1140, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %664 = %663(%662, meta[relay.Constant][81] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %665 = fn (%p0203: Tensor[(320, 256), float16], %p1139: Tensor[(256), float16], %p249: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %301 = reshape(%p0203, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %302 = add(%301, %p1139) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p249, %302) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %666 = %665(%664, meta[relay.Constant][82] /* ty=Tensor[(256), float16] */, %656) /* ty=Tensor[(10, 32, 256), float16] */;
  %667 = fn (%p0321: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0321, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %668 = %667(%666) /* ty=Tensor[(10, 32, 1), float16] */;
  %669 = fn (%p0322: Tensor[(10, 32, 256), float16], %p1212: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0322, %p1212, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %670 = %669(%666, %668) /* ty=Tensor[(10, 32, 1), float16] */;
  %671 = fn (%p0202: Tensor[(10, 32, 256), float16], %p1138: Tensor[(10, 32, 1), float16], %p248: Tensor[(10, 32, 1), float16], %p322: float16, %p422: Tensor[(256), float16], %p522: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %296 = add(%p248, %p322) /* ty=Tensor[(10, 32, 1), float16] */;
    %297 = subtract(%p0202, %p1138) /* ty=Tensor[(10, 32, 256), float16] */;
    %298 = sqrt(%296) /* ty=Tensor[(10, 32, 1), float16] */;
    %299 = divide(%297, %298) /* ty=Tensor[(10, 32, 256), float16] */;
    %300 = multiply(%299, %p422) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%300, %p522) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %672 = %671(%666, %668, %670, meta[relay.Constant][83] /* ty=float16 */, meta[relay.Constant][84] /* ty=Tensor[(256), float16] */, meta[relay.Constant][85] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %673 = fn (%p0201: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0201, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %674 = %673(%672) /* ty=Tensor[(320, 256), float16] */;
  %675 = fn (%p0200: Tensor[(320, 256), float16], %p1137: Tensor[(768, 256), float16], Primitive=1, hash="9b1c25a290f73b25") -> Tensor[(320, 768), float16] {
    nn.dense(%p0200, %p1137, units=None, out_dtype="float16") /* ty=Tensor[(320, 768), float16] */
  };
  %676 = %675(%674, meta[relay.Constant][86] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(320, 768), float16] */;
  %677 = fn (%p0199: Tensor[(320, 768), float16], %p1136: Tensor[(768), float16], Primitive=1, hash="bca76b09cd6d8599") -> Tensor[(10, 32, 768), float16] {
    %295 = reshape(%p0199, newshape=[10, 32, 768]) /* ty=Tensor[(10, 32, 768), float16] */;
    add(%295, %p1136) /* ty=Tensor[(10, 32, 768), float16] */
  };
  %678 = %677(%676, meta[relay.Constant][87] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(10, 32, 768), float16] */;
  %679 = fn (%p0198: Tensor[(10, 32, 768), float16], %p1135: float16, Primitive=1, hash="31fc8a801194d3f7") -> Tensor[(256, 10, 32), float16] {
    %292 = strided_slice(%p0198, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %293 = multiply(%292, %p1135) /* ty=Tensor[(10, 32, 256), float16] */;
    %294 = reshape(%293, newshape=[10, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%294, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %682 = fn (%p0323: Tensor[(10, 32, 768), float16], Primitive=1, hash="31c1964ae3513fb6") -> Tensor[(256, 10, 32), float16] {
    %680 = strided_slice(%p0323, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %681 = reshape(%680, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%681, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %683 = %679(%678, meta[relay.Constant][88] /* ty=float16 */) /* ty=Tensor[(256, 10, 32), float16] */;
  %684 = %682(%678) /* ty=Tensor[(256, 10, 32), float16] */;
  %685 = fn (%p0197: Tensor[(256, 10, 32), float16], %p1134: Tensor[(256, 10, 32), float16], Primitive=1, hash="4fa411acb4b2e313") -> Tensor[(256, 10, 10), float32] {
    %291 = nn.batch_matmul(%p0197, %p1134, meta[relay.attrs.BatchMatmulAttrs][25]) /* ty=Tensor[(256, 10, 10), float16] */;
    cast(%291, dtype="float32") /* ty=Tensor[(256, 10, 10), float32] */
  };
  %686 = %685(%683, %684) /* ty=Tensor[(256, 10, 10), float32] */;
  %687 = fn (%p0196: Tensor[(256, 10, 10), float32], Primitive=1, hash="7feb65b24638b2a4") -> Tensor[(256, 10, 10), float32] {
    nn.softmax(%p0196) /* ty=Tensor[(256, 10, 10), float32] */
  };
  %688 = %687(%686) /* ty=Tensor[(256, 10, 10), float32] */;
  %689 = fn (%p0195: Tensor[(256, 10, 10), float32], Primitive=1, hash="e44f17003a41d38f") -> Tensor[(256, 10, 10), float16] {
    cast(%p0195, dtype="float16") /* ty=Tensor[(256, 10, 10), float16] */
  };
  %692 = fn (%p0324: Tensor[(10, 32, 768), float16], Primitive=1, hash="c3f1046aeccef45d") -> Tensor[(256, 32, 10), float16] {
    %690 = strided_slice(%p0324, begin=[0, 0, 512], end=[10, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %691 = reshape(%690, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%691, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %693 = %689(%688) /* ty=Tensor[(256, 10, 10), float16] */;
  %694 = %692(%678) /* ty=Tensor[(256, 32, 10), float16] */;
  %695 = fn (%p0194: Tensor[(256, 10, 10), float16], %p1133: Tensor[(256, 32, 10), float16], Primitive=1, hash="ffff77a508e686b5") -> Tensor[(256, 10, 32), float16] {
    nn.batch_matmul(%p0194, %p1133, meta[relay.attrs.BatchMatmulAttrs][24]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %696 = %695(%693, %694) /* ty=Tensor[(256, 10, 32), float16] */;
  %697 = fn (%p0193: Tensor[(256, 10, 32), float16], Primitive=1, hash="fd0a1aa3e51b1b23") -> Tensor[(320, 256), float16] {
    %290 = transpose(%p0193, axes=[1, 0, 2]) /* ty=Tensor[(10, 256, 32), float16] */;
    reshape(%290, newshape=[320, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %698 = %697(%696) /* ty=Tensor[(320, 256), float16] */;
  %699 = fn (%p0192: Tensor[(320, 256), float16], %p1132: Tensor[(256, 256), float16], Primitive=1, hash="6c129fac027f5197") -> Tensor[(320, 256), float16] {
    nn.dense(%p0192, %p1132, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %700 = %699(%698, meta[relay.Constant][89] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %701 = fn (%p0191: Tensor[(320, 256), float16], %p1131: Tensor[(256), float16], %p247: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %288 = reshape(%p0191, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %289 = add(%288, %p1131) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p247, %289) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %702 = %701(%700, meta[relay.Constant][90] /* ty=Tensor[(256), float16] */, %672) /* ty=Tensor[(10, 32, 256), float16] */;
  %703 = fn (%p0325: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0325, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %704 = %703(%702) /* ty=Tensor[(10, 32, 1), float16] */;
  %705 = fn (%p0326: Tensor[(10, 32, 256), float16], %p1213: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0326, %p1213, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %706 = %705(%702, %704) /* ty=Tensor[(10, 32, 1), float16] */;
  %707 = fn (%p0190: Tensor[(10, 32, 256), float16], %p1130: Tensor[(10, 32, 1), float16], %p246: Tensor[(10, 32, 1), float16], %p321: float16, %p421: Tensor[(256), float16], %p521: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %283 = add(%p246, %p321) /* ty=Tensor[(10, 32, 1), float16] */;
    %284 = subtract(%p0190, %p1130) /* ty=Tensor[(10, 32, 256), float16] */;
    %285 = sqrt(%283) /* ty=Tensor[(10, 32, 1), float16] */;
    %286 = divide(%284, %285) /* ty=Tensor[(10, 32, 256), float16] */;
    %287 = multiply(%286, %p421) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%287, %p521) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %708 = %707(%702, %704, %706, meta[relay.Constant][91] /* ty=float16 */, meta[relay.Constant][92] /* ty=Tensor[(256), float16] */, meta[relay.Constant][93] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %709 = fn (%p0189: Tensor[(10, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="a4c00811aef00ed4") -> Tensor[(320, 256), float16] {
    reshape(%p0189, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %710 = %709(%708) /* ty=Tensor[(320, 256), float16] */;
  %711 = fn (%p0188: Tensor[(320, 256), float16], %p1129: Tensor[(2048, 256), float16], Primitive=1, hash="faf510b8992ffda3") -> Tensor[(320, 2048), float16] {
    nn.dense(%p0188, %p1129, units=None, out_dtype="float16") /* ty=Tensor[(320, 2048), float16] */
  };
  %712 = %711(%710, meta[relay.Constant][94] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %713 = fn (%p0187: Tensor[(320, 2048), float16], %p1128: Tensor[(2048), float16], Primitive=1, hash="c2b5261f77353abc") -> Tensor[(320, 2048), float16] {
    %280 = reshape(%p0187, newshape=[10, 32, 2048]) /* ty=Tensor[(10, 32, 2048), float16] */;
    %281 = add(%280, %p1128) /* ty=Tensor[(10, 32, 2048), float16] */;
    %282 = nn.relu(%281) /* ty=Tensor[(10, 32, 2048), float16] */;
    reshape(%282, newshape=[-1, 2048]) /* ty=Tensor[(320, 2048), float16] */
  };
  %714 = %713(%712, meta[relay.Constant][95] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(320, 2048), float16] */;
  %715 = fn (%p0186: Tensor[(320, 2048), float16], %p1127: Tensor[(256, 2048), float16], Primitive=1, hash="59fdab42767162c4") -> Tensor[(320, 256), float16] {
    nn.dense(%p0186, %p1127, units=None, out_dtype="float16") /* ty=Tensor[(320, 256), float16] */
  };
  %716 = %715(%714, meta[relay.Constant][96] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %717 = fn (%p0185: Tensor[(320, 256), float16], %p1126: Tensor[(256), float16], %p245: Tensor[(10, 32, 256), float16], Primitive=1, hash="386a7a2c2b736060") -> Tensor[(10, 32, 256), float16] {
    %278 = reshape(%p0185, newshape=[10, 32, 256]) /* ty=Tensor[(10, 32, 256), float16] */;
    %279 = add(%278, %p1126) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%p245, %279) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %718 = %717(%716, meta[relay.Constant][97] /* ty=Tensor[(256), float16] */, %708) /* ty=Tensor[(10, 32, 256), float16] */;
  %719 = fn (%p0327: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0327, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %720 = %719(%718) /* ty=Tensor[(10, 32, 1), float16] */;
  %721 = fn (%p0328: Tensor[(10, 32, 256), float16], %p1214: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0328, %p1214, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %722 = %721(%718, %720) /* ty=Tensor[(10, 32, 1), float16] */;
  %723 = fn (%p0184: Tensor[(10, 32, 256), float16], %p1125: Tensor[(10, 32, 1), float16], %p244: Tensor[(10, 32, 1), float16], %p320: float16, %p420: Tensor[(256), float16], %p520: Tensor[(256), float16], Primitive=1, hash="8edfc8ae9a8aa1d2") -> Tensor[(10, 32, 256), float16] {
    %273 = add(%p244, %p320) /* ty=Tensor[(10, 32, 1), float16] */;
    %274 = subtract(%p0184, %p1125) /* ty=Tensor[(10, 32, 256), float16] */;
    %275 = sqrt(%273) /* ty=Tensor[(10, 32, 1), float16] */;
    %276 = divide(%274, %275) /* ty=Tensor[(10, 32, 256), float16] */;
    %277 = multiply(%276, %p420) /* ty=Tensor[(10, 32, 256), float16] */;
    add(%277, %p520) /* ty=Tensor[(10, 32, 256), float16] */
  };
  %724 = %723(%718, %720, %722, meta[relay.Constant][98] /* ty=float16 */, meta[relay.Constant][99] /* ty=Tensor[(256), float16] */, meta[relay.Constant][100] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(10, 32, 256), float16] */;
  %725 = fn (%p0329: Tensor[(10, 32, 256), float16], Primitive=1, hash="504937aaa17a3d12") -> Tensor[(10, 32, 1), float16] {
    mean(%p0329, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %726 = %725(%724) /* ty=Tensor[(10, 32, 1), float16] */;
  %727 = fn (%p0330: Tensor[(10, 32, 256), float16], %p1215: Tensor[(10, 32, 1), float16], Primitive=1, hash="a8864002561d16c4") -> Tensor[(10, 32, 1), float16] {
    variance(%p0330, %p1215, axis=[-1], keepdims=True) /* ty=Tensor[(10, 32, 1), float16] */
  };
  %728 = %727(%724, %726) /* ty=Tensor[(10, 32, 1), float16] */;
  %729 = fn (%p0183: Tensor[(10, 32, 256), float16], %p1124: Tensor[(10, 32, 1), float16], %p243: Tensor[(10, 32, 1), float16], %p319: float16, %p419: Tensor[(256), float16], %p519: Tensor[(256), float16], Primitive=1, hash="f7337f224a3e0b1d") -> Tensor[(320, 256), float16] {
    %267 = add(%p243, %p319) /* ty=Tensor[(10, 32, 1), float16] */;
    %268 = subtract(%p0183, %p1124) /* ty=Tensor[(10, 32, 256), float16] */;
    %269 = sqrt(%267) /* ty=Tensor[(10, 32, 1), float16] */;
    %270 = divide(%268, %269) /* ty=Tensor[(10, 32, 256), float16] */;
    %271 = multiply(%270, %p419) /* ty=Tensor[(10, 32, 256), float16] */;
    %272 = add(%271, %p519) /* ty=Tensor[(10, 32, 256), float16] */;
    reshape(%272, newshape=[-1, 256]) /* ty=Tensor[(320, 256), float16] */
  };
  %730 = %729(%724, %726, %728, meta[relay.Constant][101] /* ty=float16 */, meta[relay.Constant][102] /* ty=Tensor[(256), float16] */, meta[relay.Constant][103] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(320, 256), float16] */;
  %731 = fn (%p0182: Tensor[(320, 256), float16], %p1123: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0182, %p1123, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %732 = %731(%730, meta[relay.Constant][104] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %733 = fn (%p0181: Tensor[(320, 512), float16], %p1122: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %266 = reshape(%p0181, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%266, %p1122) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %734 = %733(%732, meta[relay.Constant][105] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %735 = fn (%p0180: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %264 = strided_slice(%p0180, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %265 = reshape(%264, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%265, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %736 = %263(%262, meta[relay.Constant][9] /* ty=Tensor[(256), float16] */, meta[relay.Constant][10] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %737 = %735(%734) /* ty=Tensor[(256, 10, 32), float16] */;
  %738 = fn (%p0159: Tensor[(256, 20, 32), float16], %p1110: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %203 = nn.batch_matmul(%p0159, %p1110, meta[relay.attrs.BatchMatmulAttrs][21]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%203, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %739 = %738(%736, %737) /* ty=Tensor[(256, 20, 10), float32] */;
  %740 = fn (%p0158: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p0158) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %741 = %740(%739) /* ty=Tensor[(256, 20, 10), float32] */;
  %742 = fn (%p0157: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p0157, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %745 = fn (%p0331: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %743 = strided_slice(%p0331, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %744 = reshape(%743, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%744, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %746 = %742(%741) /* ty=Tensor[(256, 20, 10), float16] */;
  %747 = %745(%734) /* ty=Tensor[(256, 32, 10), float16] */;
  %748 = fn (%p0156: Tensor[(256, 20, 10), float16], %p1109: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p0156, %p1109, meta[relay.attrs.BatchMatmulAttrs][20]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %749 = %748(%746, %747) /* ty=Tensor[(256, 20, 32), float16] */;
  %750 = fn (%p0155: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %202 = transpose(%p0155, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%202, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %751 = %750(%749) /* ty=Tensor[(640, 256), float16] */;
  %752 = fn (%p0154: Tensor[(640, 256), float16], %p1108: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0154, %p1108, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %753 = %752(%751, meta[relay.Constant][106] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %754 = fn (%p0153: Tensor[(640, 256), float16], %p1107: Tensor[(256), float16], %p239: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %200 = reshape(%p0153, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %201 = add(%200, %p1107) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p239, %201) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %755 = %754(%753, meta[relay.Constant][107] /* ty=Tensor[(256), float16] */, %258) /* ty=Tensor[(20, 32, 256), float16] */;
  %756 = fn (%p0332: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0332, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %757 = %756(%755) /* ty=Tensor[(20, 32, 1), float16] */;
  %758 = fn (%p0333: Tensor[(20, 32, 256), float16], %p1216: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0333, %p1216, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %759 = %758(%755, %757) /* ty=Tensor[(20, 32, 1), float16] */;
  %760 = fn (%p0152: Tensor[(20, 32, 256), float16], %p1106: Tensor[(20, 32, 1), float16], %p238: Tensor[(20, 32, 1), float16], %p317: float16, %p417: Tensor[(256), float16], %p517: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %195 = add(%p238, %p317) /* ty=Tensor[(20, 32, 1), float16] */;
    %196 = subtract(%p0152, %p1106) /* ty=Tensor[(20, 32, 256), float16] */;
    %197 = sqrt(%195) /* ty=Tensor[(20, 32, 1), float16] */;
    %198 = divide(%196, %197) /* ty=Tensor[(20, 32, 256), float16] */;
    %199 = multiply(%198, %p417) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%199, %p517) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %761 = %760(%755, %757, %759, meta[relay.Constant][108] /* ty=float16 */, meta[relay.Constant][109] /* ty=Tensor[(256), float16] */, meta[relay.Constant][110] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %762 = fn (%p0151: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0151, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %763 = %762(%761) /* ty=Tensor[(640, 256), float16] */;
  %764 = fn (%p0150: Tensor[(640, 256), float16], %p1105: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p0150, %p1105, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %765 = %764(%763, meta[relay.Constant][111] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %766 = fn (%p0149: Tensor[(640, 2048), float16], %p1104: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %192 = reshape(%p0149, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %193 = add(%192, %p1104) /* ty=Tensor[(20, 32, 2048), float16] */;
    %194 = nn.relu(%193) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%194, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %767 = %766(%765, meta[relay.Constant][112] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %768 = fn (%p0148: Tensor[(640, 2048), float16], %p1103: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p0148, %p1103, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %769 = %768(%767, meta[relay.Constant][113] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %770 = fn (%p0147: Tensor[(640, 256), float16], %p1102: Tensor[(256), float16], %p237: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %190 = reshape(%p0147, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %191 = add(%190, %p1102) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p237, %191) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %771 = %770(%769, meta[relay.Constant][114] /* ty=Tensor[(256), float16] */, %761) /* ty=Tensor[(20, 32, 256), float16] */;
  %772 = fn (%p0334: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0334, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %773 = %772(%771) /* ty=Tensor[(20, 32, 1), float16] */;
  %774 = fn (%p0335: Tensor[(20, 32, 256), float16], %p1217: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0335, %p1217, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %775 = %774(%771, %773) /* ty=Tensor[(20, 32, 1), float16] */;
  %776 = fn (%p0146: Tensor[(20, 32, 256), float16], %p1101: Tensor[(20, 32, 1), float16], %p236: Tensor[(20, 32, 1), float16], %p316: float16, %p416: Tensor[(256), float16], %p516: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %185 = add(%p236, %p316) /* ty=Tensor[(20, 32, 1), float16] */;
    %186 = subtract(%p0146, %p1101) /* ty=Tensor[(20, 32, 256), float16] */;
    %187 = sqrt(%185) /* ty=Tensor[(20, 32, 1), float16] */;
    %188 = divide(%186, %187) /* ty=Tensor[(20, 32, 256), float16] */;
    %189 = multiply(%188, %p416) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%189, %p516) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %777 = %776(%771, %773, %775, meta[relay.Constant][115] /* ty=float16 */, meta[relay.Constant][116] /* ty=Tensor[(256), float16] */, meta[relay.Constant][117] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %778 = fn (%p0145: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0145, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %779 = %778(%777) /* ty=Tensor[(640, 256), float16] */;
  %780 = fn (%p0144: Tensor[(640, 256), float16], %p1100: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p0144, %p1100, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %781 = %780(%779, meta[relay.Constant][118] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %782 = fn (%p0143: Tensor[(640, 768), float16], %p199: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %184 = reshape(%p0143, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%184, %p199) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %783 = %782(%781, meta[relay.Constant][119] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %784 = fn (%p0142: Tensor[(20, 32, 768), float16], %p198: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %181 = strided_slice(%p0142, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %182 = multiply(%181, %p198) /* ty=Tensor[(20, 32, 256), float16] */;
    %183 = reshape(%182, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%183, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %787 = fn (%p0336: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %785 = strided_slice(%p0336, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %786 = reshape(%785, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%786, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %788 = %784(%783, meta[relay.Constant][120] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %789 = %787(%783) /* ty=Tensor[(256, 20, 32), float16] */;
  %790 = fn (%p0141: Tensor[(256, 20, 32), float16], %p197: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %180 = nn.batch_matmul(%p0141, %p197, meta[relay.attrs.BatchMatmulAttrs][19]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%180, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %791 = %790(%788, %789) /* ty=Tensor[(256, 20, 20), float32] */;
  %792 = fn (%p0140: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p0140) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %793 = %792(%791) /* ty=Tensor[(256, 20, 20), float32] */;
  %794 = fn (%p0139: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p0139, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %797 = fn (%p0337: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %795 = strided_slice(%p0337, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %796 = reshape(%795, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%796, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %798 = %794(%793) /* ty=Tensor[(256, 20, 20), float16] */;
  %799 = %797(%783) /* ty=Tensor[(256, 32, 20), float16] */;
  %800 = fn (%p0138: Tensor[(256, 20, 20), float16], %p196: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p0138, %p196, meta[relay.attrs.BatchMatmulAttrs][18]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %801 = %800(%798, %799) /* ty=Tensor[(256, 20, 32), float16] */;
  %802 = fn (%p0137: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %179 = transpose(%p0137, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%179, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %803 = %802(%801) /* ty=Tensor[(640, 256), float16] */;
  %804 = fn (%p0136: Tensor[(640, 256), float16], %p195: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0136, %p195, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %805 = %804(%803, meta[relay.Constant][121] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %806 = fn (%p0135: Tensor[(640, 256), float16], %p194: Tensor[(256), float16], %p235: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %177 = reshape(%p0135, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %178 = add(%177, %p194) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p235, %178) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %807 = %806(%805, meta[relay.Constant][122] /* ty=Tensor[(256), float16] */, %777) /* ty=Tensor[(20, 32, 256), float16] */;
  %808 = fn (%p0338: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0338, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %809 = %808(%807) /* ty=Tensor[(20, 32, 1), float16] */;
  %810 = fn (%p0339: Tensor[(20, 32, 256), float16], %p1218: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0339, %p1218, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %811 = %810(%807, %809) /* ty=Tensor[(20, 32, 1), float16] */;
  %812 = fn (%p0134: Tensor[(20, 32, 256), float16], %p193: Tensor[(20, 32, 1), float16], %p234: Tensor[(20, 32, 1), float16], %p315: float16, %p415: Tensor[(256), float16], %p515: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %172 = add(%p234, %p315) /* ty=Tensor[(20, 32, 1), float16] */;
    %173 = subtract(%p0134, %p193) /* ty=Tensor[(20, 32, 256), float16] */;
    %174 = sqrt(%172) /* ty=Tensor[(20, 32, 1), float16] */;
    %175 = divide(%173, %174) /* ty=Tensor[(20, 32, 256), float16] */;
    %176 = multiply(%175, %p415) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%176, %p515) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %813 = %812(%807, %809, %811, meta[relay.Constant][123] /* ty=float16 */, meta[relay.Constant][124] /* ty=Tensor[(256), float16] */, meta[relay.Constant][125] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %814 = fn (%p0133: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0133, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %815 = %814(%813) /* ty=Tensor[(640, 256), float16] */;
  %816 = fn (%p0132: Tensor[(640, 256), float16], %p192: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0132, %p192, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %817 = %816(%815, meta[relay.Constant][126] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %818 = fn (%p0131: Tensor[(640, 256), float16], %p191: Tensor[(256), float16], %p233: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %168 = reshape(%p0131, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %169 = add(%168, %p191) /* ty=Tensor[(20, 32, 256), float16] */;
    %170 = multiply(%169, %p233) /* ty=Tensor[(20, 32, 256), float16] */;
    %171 = reshape(%170, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%171, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %822 = fn (%p0342: Tensor[(320, 256), float16], %p1220: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0342, %p1220, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %823 = %822(%730, meta[relay.Constant][129] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %824 = fn (%p0341: Tensor[(320, 512), float16], %p1219: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %821 = reshape(%p0341, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%821, %p1219) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %825 = %824(%823, meta[relay.Constant][130] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %826 = fn (%p0340: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %819 = strided_slice(%p0340, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %820 = reshape(%819, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%820, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %827 = %818(%817, meta[relay.Constant][127] /* ty=Tensor[(256), float16] */, meta[relay.Constant][128] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %828 = %826(%825) /* ty=Tensor[(256, 10, 32), float16] */;
  %829 = fn (%p0130: Tensor[(256, 20, 32), float16], %p190: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %167 = nn.batch_matmul(%p0130, %p190, meta[relay.attrs.BatchMatmulAttrs][17]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%167, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %830 = %829(%827, %828) /* ty=Tensor[(256, 20, 10), float32] */;
  %831 = fn (%p0129: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p0129) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %832 = %831(%830) /* ty=Tensor[(256, 20, 10), float32] */;
  %833 = fn (%p0128: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p0128, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %836 = fn (%p0343: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %834 = strided_slice(%p0343, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %835 = reshape(%834, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%835, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %837 = %833(%832) /* ty=Tensor[(256, 20, 10), float16] */;
  %838 = %836(%825) /* ty=Tensor[(256, 32, 10), float16] */;
  %839 = fn (%p0127: Tensor[(256, 20, 10), float16], %p189: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p0127, %p189, meta[relay.attrs.BatchMatmulAttrs][16]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %840 = %839(%837, %838) /* ty=Tensor[(256, 20, 32), float16] */;
  %841 = fn (%p0126: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %166 = transpose(%p0126, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%166, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %842 = %841(%840) /* ty=Tensor[(640, 256), float16] */;
  %843 = fn (%p0125: Tensor[(640, 256), float16], %p188: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0125, %p188, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %844 = %843(%842, meta[relay.Constant][131] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %845 = fn (%p0124: Tensor[(640, 256), float16], %p187: Tensor[(256), float16], %p232: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %164 = reshape(%p0124, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %165 = add(%164, %p187) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p232, %165) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %846 = %845(%844, meta[relay.Constant][132] /* ty=Tensor[(256), float16] */, %813) /* ty=Tensor[(20, 32, 256), float16] */;
  %847 = fn (%p0344: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0344, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %848 = %847(%846) /* ty=Tensor[(20, 32, 1), float16] */;
  %849 = fn (%p0345: Tensor[(20, 32, 256), float16], %p1221: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0345, %p1221, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %850 = %849(%846, %848) /* ty=Tensor[(20, 32, 1), float16] */;
  %851 = fn (%p0123: Tensor[(20, 32, 256), float16], %p186: Tensor[(20, 32, 1), float16], %p231: Tensor[(20, 32, 1), float16], %p314: float16, %p414: Tensor[(256), float16], %p514: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %159 = add(%p231, %p314) /* ty=Tensor[(20, 32, 1), float16] */;
    %160 = subtract(%p0123, %p186) /* ty=Tensor[(20, 32, 256), float16] */;
    %161 = sqrt(%159) /* ty=Tensor[(20, 32, 1), float16] */;
    %162 = divide(%160, %161) /* ty=Tensor[(20, 32, 256), float16] */;
    %163 = multiply(%162, %p414) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%163, %p514) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %852 = %851(%846, %848, %850, meta[relay.Constant][133] /* ty=float16 */, meta[relay.Constant][134] /* ty=Tensor[(256), float16] */, meta[relay.Constant][135] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %853 = fn (%p0122: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0122, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %854 = %853(%852) /* ty=Tensor[(640, 256), float16] */;
  %855 = fn (%p0121: Tensor[(640, 256), float16], %p185: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p0121, %p185, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %856 = %855(%854, meta[relay.Constant][136] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %857 = fn (%p0120: Tensor[(640, 2048), float16], %p184: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %156 = reshape(%p0120, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %157 = add(%156, %p184) /* ty=Tensor[(20, 32, 2048), float16] */;
    %158 = nn.relu(%157) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%158, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %858 = %857(%856, meta[relay.Constant][137] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %859 = fn (%p0119: Tensor[(640, 2048), float16], %p183: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p0119, %p183, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %860 = %859(%858, meta[relay.Constant][138] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %861 = fn (%p0118: Tensor[(640, 256), float16], %p182: Tensor[(256), float16], %p230: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %154 = reshape(%p0118, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %155 = add(%154, %p182) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p230, %155) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %862 = %861(%860, meta[relay.Constant][139] /* ty=Tensor[(256), float16] */, %852) /* ty=Tensor[(20, 32, 256), float16] */;
  %863 = fn (%p0346: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0346, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %864 = %863(%862) /* ty=Tensor[(20, 32, 1), float16] */;
  %865 = fn (%p0347: Tensor[(20, 32, 256), float16], %p1222: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0347, %p1222, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %866 = %865(%862, %864) /* ty=Tensor[(20, 32, 1), float16] */;
  %867 = fn (%p0117: Tensor[(20, 32, 256), float16], %p181: Tensor[(20, 32, 1), float16], %p229: Tensor[(20, 32, 1), float16], %p313: float16, %p413: Tensor[(256), float16], %p513: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %149 = add(%p229, %p313) /* ty=Tensor[(20, 32, 1), float16] */;
    %150 = subtract(%p0117, %p181) /* ty=Tensor[(20, 32, 256), float16] */;
    %151 = sqrt(%149) /* ty=Tensor[(20, 32, 1), float16] */;
    %152 = divide(%150, %151) /* ty=Tensor[(20, 32, 256), float16] */;
    %153 = multiply(%152, %p413) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%153, %p513) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %868 = %867(%862, %864, %866, meta[relay.Constant][140] /* ty=float16 */, meta[relay.Constant][141] /* ty=Tensor[(256), float16] */, meta[relay.Constant][142] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %869 = fn (%p0116: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0116, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %870 = %869(%868) /* ty=Tensor[(640, 256), float16] */;
  %871 = fn (%p0115: Tensor[(640, 256), float16], %p180: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p0115, %p180, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %872 = %871(%870, meta[relay.Constant][143] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %873 = fn (%p0114: Tensor[(640, 768), float16], %p179: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %148 = reshape(%p0114, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%148, %p179) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %874 = %873(%872, meta[relay.Constant][144] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %875 = fn (%p0113: Tensor[(20, 32, 768), float16], %p178: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %145 = strided_slice(%p0113, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %146 = multiply(%145, %p178) /* ty=Tensor[(20, 32, 256), float16] */;
    %147 = reshape(%146, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%147, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %878 = fn (%p0348: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %876 = strided_slice(%p0348, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %877 = reshape(%876, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%877, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %879 = %875(%874, meta[relay.Constant][145] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %880 = %878(%874) /* ty=Tensor[(256, 20, 32), float16] */;
  %881 = fn (%p0112: Tensor[(256, 20, 32), float16], %p177: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %144 = nn.batch_matmul(%p0112, %p177, meta[relay.attrs.BatchMatmulAttrs][15]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%144, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %882 = %881(%879, %880) /* ty=Tensor[(256, 20, 20), float32] */;
  %883 = fn (%p0111: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p0111) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %884 = %883(%882) /* ty=Tensor[(256, 20, 20), float32] */;
  %885 = fn (%p0110: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p0110, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %888 = fn (%p0349: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %886 = strided_slice(%p0349, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %887 = reshape(%886, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%887, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %889 = %885(%884) /* ty=Tensor[(256, 20, 20), float16] */;
  %890 = %888(%874) /* ty=Tensor[(256, 32, 20), float16] */;
  %891 = fn (%p0109: Tensor[(256, 20, 20), float16], %p176: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p0109, %p176, meta[relay.attrs.BatchMatmulAttrs][14]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %892 = %891(%889, %890) /* ty=Tensor[(256, 20, 32), float16] */;
  %893 = fn (%p0108: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %143 = transpose(%p0108, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%143, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %894 = %893(%892) /* ty=Tensor[(640, 256), float16] */;
  %895 = fn (%p0107: Tensor[(640, 256), float16], %p175: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0107, %p175, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %896 = %895(%894, meta[relay.Constant][146] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %897 = fn (%p0106: Tensor[(640, 256), float16], %p174: Tensor[(256), float16], %p228: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %141 = reshape(%p0106, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %142 = add(%141, %p174) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p228, %142) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %898 = %897(%896, meta[relay.Constant][147] /* ty=Tensor[(256), float16] */, %868) /* ty=Tensor[(20, 32, 256), float16] */;
  %899 = fn (%p0350: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0350, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %900 = %899(%898) /* ty=Tensor[(20, 32, 1), float16] */;
  %901 = fn (%p0351: Tensor[(20, 32, 256), float16], %p1223: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0351, %p1223, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %902 = %901(%898, %900) /* ty=Tensor[(20, 32, 1), float16] */;
  %903 = fn (%p0105: Tensor[(20, 32, 256), float16], %p173: Tensor[(20, 32, 1), float16], %p227: Tensor[(20, 32, 1), float16], %p312: float16, %p412: Tensor[(256), float16], %p512: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %136 = add(%p227, %p312) /* ty=Tensor[(20, 32, 1), float16] */;
    %137 = subtract(%p0105, %p173) /* ty=Tensor[(20, 32, 256), float16] */;
    %138 = sqrt(%136) /* ty=Tensor[(20, 32, 1), float16] */;
    %139 = divide(%137, %138) /* ty=Tensor[(20, 32, 256), float16] */;
    %140 = multiply(%139, %p412) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%140, %p512) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %904 = %903(%898, %900, %902, meta[relay.Constant][148] /* ty=float16 */, meta[relay.Constant][149] /* ty=Tensor[(256), float16] */, meta[relay.Constant][150] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %905 = fn (%p0104: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p0104, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %906 = %905(%904) /* ty=Tensor[(640, 256), float16] */;
  %907 = fn (%p0103: Tensor[(640, 256), float16], %p172: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p0103, %p172, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %908 = %907(%906, meta[relay.Constant][151] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %909 = fn (%p0102: Tensor[(640, 256), float16], %p171: Tensor[(256), float16], %p226: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %132 = reshape(%p0102, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %133 = add(%132, %p171) /* ty=Tensor[(20, 32, 256), float16] */;
    %134 = multiply(%133, %p226) /* ty=Tensor[(20, 32, 256), float16] */;
    %135 = reshape(%134, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%135, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %913 = fn (%p0354: Tensor[(320, 256), float16], %p1225: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0354, %p1225, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %914 = %913(%730, meta[relay.Constant][154] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %915 = fn (%p0353: Tensor[(320, 512), float16], %p1224: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %912 = reshape(%p0353, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%912, %p1224) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %916 = %915(%914, meta[relay.Constant][155] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %917 = fn (%p0352: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %910 = strided_slice(%p0352, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %911 = reshape(%910, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%911, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %918 = %909(%908, meta[relay.Constant][152] /* ty=Tensor[(256), float16] */, meta[relay.Constant][153] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %919 = %917(%916) /* ty=Tensor[(256, 10, 32), float16] */;
  %920 = fn (%p0101: Tensor[(256, 20, 32), float16], %p170: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %131 = nn.batch_matmul(%p0101, %p170, meta[relay.attrs.BatchMatmulAttrs][13]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%131, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %921 = %920(%918, %919) /* ty=Tensor[(256, 20, 10), float32] */;
  %922 = fn (%p0100: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p0100) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %923 = %922(%921) /* ty=Tensor[(256, 20, 10), float32] */;
  %924 = fn (%p099: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p099, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %927 = fn (%p0355: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %925 = strided_slice(%p0355, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %926 = reshape(%925, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%926, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %928 = %924(%923) /* ty=Tensor[(256, 20, 10), float16] */;
  %929 = %927(%916) /* ty=Tensor[(256, 32, 10), float16] */;
  %930 = fn (%p098: Tensor[(256, 20, 10), float16], %p169: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p098, %p169, meta[relay.attrs.BatchMatmulAttrs][12]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %931 = %930(%928, %929) /* ty=Tensor[(256, 20, 32), float16] */;
  %932 = fn (%p097: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %130 = transpose(%p097, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%130, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %933 = %932(%931) /* ty=Tensor[(640, 256), float16] */;
  %934 = fn (%p096: Tensor[(640, 256), float16], %p168: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p096, %p168, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %935 = %934(%933, meta[relay.Constant][156] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %936 = fn (%p095: Tensor[(640, 256), float16], %p167: Tensor[(256), float16], %p225: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %128 = reshape(%p095, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %129 = add(%128, %p167) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p225, %129) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %937 = %936(%935, meta[relay.Constant][157] /* ty=Tensor[(256), float16] */, %904) /* ty=Tensor[(20, 32, 256), float16] */;
  %938 = fn (%p0356: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0356, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %939 = %938(%937) /* ty=Tensor[(20, 32, 1), float16] */;
  %940 = fn (%p0357: Tensor[(20, 32, 256), float16], %p1226: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0357, %p1226, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %941 = %940(%937, %939) /* ty=Tensor[(20, 32, 1), float16] */;
  %942 = fn (%p094: Tensor[(20, 32, 256), float16], %p166: Tensor[(20, 32, 1), float16], %p224: Tensor[(20, 32, 1), float16], %p311: float16, %p411: Tensor[(256), float16], %p511: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %123 = add(%p224, %p311) /* ty=Tensor[(20, 32, 1), float16] */;
    %124 = subtract(%p094, %p166) /* ty=Tensor[(20, 32, 256), float16] */;
    %125 = sqrt(%123) /* ty=Tensor[(20, 32, 1), float16] */;
    %126 = divide(%124, %125) /* ty=Tensor[(20, 32, 256), float16] */;
    %127 = multiply(%126, %p411) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%127, %p511) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %943 = %942(%937, %939, %941, meta[relay.Constant][158] /* ty=float16 */, meta[relay.Constant][159] /* ty=Tensor[(256), float16] */, meta[relay.Constant][160] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %944 = fn (%p093: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p093, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %945 = %944(%943) /* ty=Tensor[(640, 256), float16] */;
  %946 = fn (%p092: Tensor[(640, 256), float16], %p165: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p092, %p165, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %947 = %946(%945, meta[relay.Constant][161] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %948 = fn (%p091: Tensor[(640, 2048), float16], %p164: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %120 = reshape(%p091, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %121 = add(%120, %p164) /* ty=Tensor[(20, 32, 2048), float16] */;
    %122 = nn.relu(%121) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%122, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %949 = %948(%947, meta[relay.Constant][162] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %950 = fn (%p090: Tensor[(640, 2048), float16], %p163: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p090, %p163, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %951 = %950(%949, meta[relay.Constant][163] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %952 = fn (%p089: Tensor[(640, 256), float16], %p162: Tensor[(256), float16], %p223: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %118 = reshape(%p089, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %119 = add(%118, %p162) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p223, %119) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %953 = %952(%951, meta[relay.Constant][164] /* ty=Tensor[(256), float16] */, %943) /* ty=Tensor[(20, 32, 256), float16] */;
  %954 = fn (%p0358: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0358, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %955 = %954(%953) /* ty=Tensor[(20, 32, 1), float16] */;
  %956 = fn (%p0359: Tensor[(20, 32, 256), float16], %p1227: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0359, %p1227, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %957 = %956(%953, %955) /* ty=Tensor[(20, 32, 1), float16] */;
  %958 = fn (%p088: Tensor[(20, 32, 256), float16], %p161: Tensor[(20, 32, 1), float16], %p222: Tensor[(20, 32, 1), float16], %p310: float16, %p410: Tensor[(256), float16], %p510: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %113 = add(%p222, %p310) /* ty=Tensor[(20, 32, 1), float16] */;
    %114 = subtract(%p088, %p161) /* ty=Tensor[(20, 32, 256), float16] */;
    %115 = sqrt(%113) /* ty=Tensor[(20, 32, 1), float16] */;
    %116 = divide(%114, %115) /* ty=Tensor[(20, 32, 256), float16] */;
    %117 = multiply(%116, %p410) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%117, %p510) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %959 = %958(%953, %955, %957, meta[relay.Constant][165] /* ty=float16 */, meta[relay.Constant][166] /* ty=Tensor[(256), float16] */, meta[relay.Constant][167] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %960 = fn (%p087: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p087, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %961 = %960(%959) /* ty=Tensor[(640, 256), float16] */;
  %962 = fn (%p086: Tensor[(640, 256), float16], %p160: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p086, %p160, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %963 = %962(%961, meta[relay.Constant][168] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %964 = fn (%p085: Tensor[(640, 768), float16], %p159: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %112 = reshape(%p085, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%112, %p159) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %965 = %964(%963, meta[relay.Constant][169] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %966 = fn (%p084: Tensor[(20, 32, 768), float16], %p158: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %109 = strided_slice(%p084, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %110 = multiply(%109, %p158) /* ty=Tensor[(20, 32, 256), float16] */;
    %111 = reshape(%110, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%111, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %969 = fn (%p0360: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %967 = strided_slice(%p0360, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %968 = reshape(%967, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%968, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %970 = %966(%965, meta[relay.Constant][170] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %971 = %969(%965) /* ty=Tensor[(256, 20, 32), float16] */;
  %972 = fn (%p083: Tensor[(256, 20, 32), float16], %p157: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %108 = nn.batch_matmul(%p083, %p157, meta[relay.attrs.BatchMatmulAttrs][11]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%108, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %973 = %972(%970, %971) /* ty=Tensor[(256, 20, 20), float32] */;
  %974 = fn (%p082: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p082) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %975 = %974(%973) /* ty=Tensor[(256, 20, 20), float32] */;
  %976 = fn (%p081: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p081, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %979 = fn (%p0361: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %977 = strided_slice(%p0361, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %978 = reshape(%977, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%978, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %980 = %976(%975) /* ty=Tensor[(256, 20, 20), float16] */;
  %981 = %979(%965) /* ty=Tensor[(256, 32, 20), float16] */;
  %982 = fn (%p080: Tensor[(256, 20, 20), float16], %p156: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p080, %p156, meta[relay.attrs.BatchMatmulAttrs][10]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %983 = %982(%980, %981) /* ty=Tensor[(256, 20, 32), float16] */;
  %984 = fn (%p079: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %107 = transpose(%p079, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%107, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %985 = %984(%983) /* ty=Tensor[(640, 256), float16] */;
  %986 = fn (%p078: Tensor[(640, 256), float16], %p155: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p078, %p155, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %987 = %986(%985, meta[relay.Constant][171] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %988 = fn (%p077: Tensor[(640, 256), float16], %p154: Tensor[(256), float16], %p221: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %105 = reshape(%p077, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %106 = add(%105, %p154) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p221, %106) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %989 = %988(%987, meta[relay.Constant][172] /* ty=Tensor[(256), float16] */, %959) /* ty=Tensor[(20, 32, 256), float16] */;
  %990 = fn (%p0362: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0362, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %991 = %990(%989) /* ty=Tensor[(20, 32, 1), float16] */;
  %992 = fn (%p0363: Tensor[(20, 32, 256), float16], %p1228: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0363, %p1228, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %993 = %992(%989, %991) /* ty=Tensor[(20, 32, 1), float16] */;
  %994 = fn (%p076: Tensor[(20, 32, 256), float16], %p153: Tensor[(20, 32, 1), float16], %p220: Tensor[(20, 32, 1), float16], %p39: float16, %p49: Tensor[(256), float16], %p59: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %100 = add(%p220, %p39) /* ty=Tensor[(20, 32, 1), float16] */;
    %101 = subtract(%p076, %p153) /* ty=Tensor[(20, 32, 256), float16] */;
    %102 = sqrt(%100) /* ty=Tensor[(20, 32, 1), float16] */;
    %103 = divide(%101, %102) /* ty=Tensor[(20, 32, 256), float16] */;
    %104 = multiply(%103, %p49) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%104, %p59) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %995 = %994(%989, %991, %993, meta[relay.Constant][173] /* ty=float16 */, meta[relay.Constant][174] /* ty=Tensor[(256), float16] */, meta[relay.Constant][175] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %996 = fn (%p075: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p075, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %997 = %996(%995) /* ty=Tensor[(640, 256), float16] */;
  %998 = fn (%p074: Tensor[(640, 256), float16], %p152: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p074, %p152, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %999 = %998(%997, meta[relay.Constant][176] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1000 = fn (%p073: Tensor[(640, 256), float16], %p151: Tensor[(256), float16], %p219: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %96 = reshape(%p073, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %97 = add(%96, %p151) /* ty=Tensor[(20, 32, 256), float16] */;
    %98 = multiply(%97, %p219) /* ty=Tensor[(20, 32, 256), float16] */;
    %99 = reshape(%98, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%99, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1004 = fn (%p0366: Tensor[(320, 256), float16], %p1230: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0366, %p1230, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %1005 = %1004(%730, meta[relay.Constant][179] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %1006 = fn (%p0365: Tensor[(320, 512), float16], %p1229: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %1003 = reshape(%p0365, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%1003, %p1229) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %1007 = %1006(%1005, meta[relay.Constant][180] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %1008 = fn (%p0364: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %1001 = strided_slice(%p0364, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1002 = reshape(%1001, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1002, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %1009 = %1000(%999, meta[relay.Constant][177] /* ty=Tensor[(256), float16] */, meta[relay.Constant][178] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %1010 = %1008(%1007) /* ty=Tensor[(256, 10, 32), float16] */;
  %1011 = fn (%p072: Tensor[(256, 20, 32), float16], %p150: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %95 = nn.batch_matmul(%p072, %p150, meta[relay.attrs.BatchMatmulAttrs][9]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%95, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1012 = %1011(%1009, %1010) /* ty=Tensor[(256, 20, 10), float32] */;
  %1013 = fn (%p071: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p071) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1014 = %1013(%1012) /* ty=Tensor[(256, 20, 10), float32] */;
  %1015 = fn (%p070: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p070, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %1018 = fn (%p0367: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %1016 = strided_slice(%p0367, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1017 = reshape(%1016, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1017, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %1019 = %1015(%1014) /* ty=Tensor[(256, 20, 10), float16] */;
  %1020 = %1018(%1007) /* ty=Tensor[(256, 32, 10), float16] */;
  %1021 = fn (%p069: Tensor[(256, 20, 10), float16], %p149: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p069, %p149, meta[relay.attrs.BatchMatmulAttrs][8]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1022 = %1021(%1019, %1020) /* ty=Tensor[(256, 20, 32), float16] */;
  %1023 = fn (%p068: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %94 = transpose(%p068, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%94, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1024 = %1023(%1022) /* ty=Tensor[(640, 256), float16] */;
  %1025 = fn (%p067: Tensor[(640, 256), float16], %p148: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p067, %p148, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1026 = %1025(%1024, meta[relay.Constant][181] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1027 = fn (%p066: Tensor[(640, 256), float16], %p147: Tensor[(256), float16], %p218: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %92 = reshape(%p066, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %93 = add(%92, %p147) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p218, %93) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1028 = %1027(%1026, meta[relay.Constant][182] /* ty=Tensor[(256), float16] */, %995) /* ty=Tensor[(20, 32, 256), float16] */;
  %1029 = fn (%p0368: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0368, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1030 = %1029(%1028) /* ty=Tensor[(20, 32, 1), float16] */;
  %1031 = fn (%p0369: Tensor[(20, 32, 256), float16], %p1231: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0369, %p1231, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1032 = %1031(%1028, %1030) /* ty=Tensor[(20, 32, 1), float16] */;
  %1033 = fn (%p065: Tensor[(20, 32, 256), float16], %p146: Tensor[(20, 32, 1), float16], %p217: Tensor[(20, 32, 1), float16], %p38: float16, %p48: Tensor[(256), float16], %p58: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %87 = add(%p217, %p38) /* ty=Tensor[(20, 32, 1), float16] */;
    %88 = subtract(%p065, %p146) /* ty=Tensor[(20, 32, 256), float16] */;
    %89 = sqrt(%87) /* ty=Tensor[(20, 32, 1), float16] */;
    %90 = divide(%88, %89) /* ty=Tensor[(20, 32, 256), float16] */;
    %91 = multiply(%90, %p48) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%91, %p58) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1034 = %1033(%1028, %1030, %1032, meta[relay.Constant][183] /* ty=float16 */, meta[relay.Constant][184] /* ty=Tensor[(256), float16] */, meta[relay.Constant][185] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1035 = fn (%p064: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p064, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1036 = %1035(%1034) /* ty=Tensor[(640, 256), float16] */;
  %1037 = fn (%p063: Tensor[(640, 256), float16], %p145: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p063, %p145, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %1038 = %1037(%1036, meta[relay.Constant][186] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1039 = fn (%p062: Tensor[(640, 2048), float16], %p144: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %84 = reshape(%p062, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %85 = add(%84, %p144) /* ty=Tensor[(20, 32, 2048), float16] */;
    %86 = nn.relu(%85) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%86, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %1040 = %1039(%1038, meta[relay.Constant][187] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1041 = fn (%p061: Tensor[(640, 2048), float16], %p143: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p061, %p143, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1042 = %1041(%1040, meta[relay.Constant][188] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1043 = fn (%p060: Tensor[(640, 256), float16], %p142: Tensor[(256), float16], %p216: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %82 = reshape(%p060, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %83 = add(%82, %p142) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p216, %83) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1044 = %1043(%1042, meta[relay.Constant][189] /* ty=Tensor[(256), float16] */, %1034) /* ty=Tensor[(20, 32, 256), float16] */;
  %1045 = fn (%p0370: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0370, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1046 = %1045(%1044) /* ty=Tensor[(20, 32, 1), float16] */;
  %1047 = fn (%p0371: Tensor[(20, 32, 256), float16], %p1232: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0371, %p1232, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1048 = %1047(%1044, %1046) /* ty=Tensor[(20, 32, 1), float16] */;
  %1049 = fn (%p059: Tensor[(20, 32, 256), float16], %p141: Tensor[(20, 32, 1), float16], %p215: Tensor[(20, 32, 1), float16], %p37: float16, %p47: Tensor[(256), float16], %p57: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %77 = add(%p215, %p37) /* ty=Tensor[(20, 32, 1), float16] */;
    %78 = subtract(%p059, %p141) /* ty=Tensor[(20, 32, 256), float16] */;
    %79 = sqrt(%77) /* ty=Tensor[(20, 32, 1), float16] */;
    %80 = divide(%78, %79) /* ty=Tensor[(20, 32, 256), float16] */;
    %81 = multiply(%80, %p47) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%81, %p57) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1050 = %1049(%1044, %1046, %1048, meta[relay.Constant][190] /* ty=float16 */, meta[relay.Constant][191] /* ty=Tensor[(256), float16] */, meta[relay.Constant][192] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1051 = fn (%p058: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p058, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1052 = %1051(%1050) /* ty=Tensor[(640, 256), float16] */;
  %1053 = fn (%p057: Tensor[(640, 256), float16], %p140: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p057, %p140, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %1054 = %1053(%1052, meta[relay.Constant][193] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %1055 = fn (%p056: Tensor[(640, 768), float16], %p139: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %76 = reshape(%p056, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%76, %p139) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %1056 = %1055(%1054, meta[relay.Constant][194] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %1057 = fn (%p055: Tensor[(20, 32, 768), float16], %p138: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %73 = strided_slice(%p055, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %74 = multiply(%73, %p138) /* ty=Tensor[(20, 32, 256), float16] */;
    %75 = reshape(%74, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%75, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1060 = fn (%p0372: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %1058 = strided_slice(%p0372, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %1059 = reshape(%1058, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%1059, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1061 = %1057(%1056, meta[relay.Constant][195] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %1062 = %1060(%1056) /* ty=Tensor[(256, 20, 32), float16] */;
  %1063 = fn (%p054: Tensor[(256, 20, 32), float16], %p137: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %72 = nn.batch_matmul(%p054, %p137, meta[relay.attrs.BatchMatmulAttrs][7]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%72, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %1064 = %1063(%1061, %1062) /* ty=Tensor[(256, 20, 20), float32] */;
  %1065 = fn (%p053: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p053) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %1066 = %1065(%1064) /* ty=Tensor[(256, 20, 20), float32] */;
  %1067 = fn (%p052: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p052, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %1070 = fn (%p0373: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %1068 = strided_slice(%p0373, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %1069 = reshape(%1068, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%1069, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %1071 = %1067(%1066) /* ty=Tensor[(256, 20, 20), float16] */;
  %1072 = %1070(%1056) /* ty=Tensor[(256, 32, 20), float16] */;
  %1073 = fn (%p051: Tensor[(256, 20, 20), float16], %p136: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p051, %p136, meta[relay.attrs.BatchMatmulAttrs][6]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1074 = %1073(%1071, %1072) /* ty=Tensor[(256, 20, 32), float16] */;
  %1075 = fn (%p050: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %71 = transpose(%p050, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%71, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1076 = %1075(%1074) /* ty=Tensor[(640, 256), float16] */;
  %1077 = fn (%p049: Tensor[(640, 256), float16], %p135: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p049, %p135, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1078 = %1077(%1076, meta[relay.Constant][196] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1079 = fn (%p048: Tensor[(640, 256), float16], %p134: Tensor[(256), float16], %p214: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %69 = reshape(%p048, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %70 = add(%69, %p134) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p214, %70) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1080 = %1079(%1078, meta[relay.Constant][197] /* ty=Tensor[(256), float16] */, %1050) /* ty=Tensor[(20, 32, 256), float16] */;
  %1081 = fn (%p0374: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0374, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1082 = %1081(%1080) /* ty=Tensor[(20, 32, 1), float16] */;
  %1083 = fn (%p0375: Tensor[(20, 32, 256), float16], %p1233: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0375, %p1233, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1084 = %1083(%1080, %1082) /* ty=Tensor[(20, 32, 1), float16] */;
  %1085 = fn (%p047: Tensor[(20, 32, 256), float16], %p133: Tensor[(20, 32, 1), float16], %p213: Tensor[(20, 32, 1), float16], %p36: float16, %p46: Tensor[(256), float16], %p56: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %64 = add(%p213, %p36) /* ty=Tensor[(20, 32, 1), float16] */;
    %65 = subtract(%p047, %p133) /* ty=Tensor[(20, 32, 256), float16] */;
    %66 = sqrt(%64) /* ty=Tensor[(20, 32, 1), float16] */;
    %67 = divide(%65, %66) /* ty=Tensor[(20, 32, 256), float16] */;
    %68 = multiply(%67, %p46) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%68, %p56) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1086 = %1085(%1080, %1082, %1084, meta[relay.Constant][198] /* ty=float16 */, meta[relay.Constant][199] /* ty=Tensor[(256), float16] */, meta[relay.Constant][200] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1087 = fn (%p046: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p046, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1088 = %1087(%1086) /* ty=Tensor[(640, 256), float16] */;
  %1089 = fn (%p045: Tensor[(640, 256), float16], %p132: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p045, %p132, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1090 = %1089(%1088, meta[relay.Constant][201] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1091 = fn (%p044: Tensor[(640, 256), float16], %p131: Tensor[(256), float16], %p212: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %60 = reshape(%p044, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %61 = add(%60, %p131) /* ty=Tensor[(20, 32, 256), float16] */;
    %62 = multiply(%61, %p212) /* ty=Tensor[(20, 32, 256), float16] */;
    %63 = reshape(%62, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%63, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1095 = fn (%p0378: Tensor[(320, 256), float16], %p1235: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0378, %p1235, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %1096 = %1095(%730, meta[relay.Constant][204] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %1097 = fn (%p0377: Tensor[(320, 512), float16], %p1234: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %1094 = reshape(%p0377, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%1094, %p1234) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %1098 = %1097(%1096, meta[relay.Constant][205] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %1099 = fn (%p0376: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %1092 = strided_slice(%p0376, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1093 = reshape(%1092, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1093, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %1100 = %1091(%1090, meta[relay.Constant][202] /* ty=Tensor[(256), float16] */, meta[relay.Constant][203] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %1101 = %1099(%1098) /* ty=Tensor[(256, 10, 32), float16] */;
  %1102 = fn (%p043: Tensor[(256, 20, 32), float16], %p130: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %59 = nn.batch_matmul(%p043, %p130, meta[relay.attrs.BatchMatmulAttrs][5]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%59, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1103 = %1102(%1100, %1101) /* ty=Tensor[(256, 20, 10), float32] */;
  %1104 = fn (%p042: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p042) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1105 = %1104(%1103) /* ty=Tensor[(256, 20, 10), float32] */;
  %1106 = fn (%p041: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p041, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %1109 = fn (%p0379: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %1107 = strided_slice(%p0379, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1108 = reshape(%1107, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1108, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %1110 = %1106(%1105) /* ty=Tensor[(256, 20, 10), float16] */;
  %1111 = %1109(%1098) /* ty=Tensor[(256, 32, 10), float16] */;
  %1112 = fn (%p040: Tensor[(256, 20, 10), float16], %p129: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p040, %p129, meta[relay.attrs.BatchMatmulAttrs][4]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1113 = %1112(%1110, %1111) /* ty=Tensor[(256, 20, 32), float16] */;
  %1114 = fn (%p039: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %58 = transpose(%p039, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%58, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1115 = %1114(%1113) /* ty=Tensor[(640, 256), float16] */;
  %1116 = fn (%p038: Tensor[(640, 256), float16], %p128: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p038, %p128, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1117 = %1116(%1115, meta[relay.Constant][206] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1118 = fn (%p037: Tensor[(640, 256), float16], %p127: Tensor[(256), float16], %p211: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %56 = reshape(%p037, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %57 = add(%56, %p127) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p211, %57) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1119 = %1118(%1117, meta[relay.Constant][207] /* ty=Tensor[(256), float16] */, %1086) /* ty=Tensor[(20, 32, 256), float16] */;
  %1120 = fn (%p0380: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0380, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1121 = %1120(%1119) /* ty=Tensor[(20, 32, 1), float16] */;
  %1122 = fn (%p0381: Tensor[(20, 32, 256), float16], %p1236: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0381, %p1236, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1123 = %1122(%1119, %1121) /* ty=Tensor[(20, 32, 1), float16] */;
  %1124 = fn (%p036: Tensor[(20, 32, 256), float16], %p126: Tensor[(20, 32, 1), float16], %p210: Tensor[(20, 32, 1), float16], %p35: float16, %p45: Tensor[(256), float16], %p55: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %51 = add(%p210, %p35) /* ty=Tensor[(20, 32, 1), float16] */;
    %52 = subtract(%p036, %p126) /* ty=Tensor[(20, 32, 256), float16] */;
    %53 = sqrt(%51) /* ty=Tensor[(20, 32, 1), float16] */;
    %54 = divide(%52, %53) /* ty=Tensor[(20, 32, 256), float16] */;
    %55 = multiply(%54, %p45) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%55, %p55) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1125 = %1124(%1119, %1121, %1123, meta[relay.Constant][208] /* ty=float16 */, meta[relay.Constant][209] /* ty=Tensor[(256), float16] */, meta[relay.Constant][210] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1126 = fn (%p035: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p035, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1127 = %1126(%1125) /* ty=Tensor[(640, 256), float16] */;
  %1128 = fn (%p034: Tensor[(640, 256), float16], %p125: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p034, %p125, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %1129 = %1128(%1127, meta[relay.Constant][211] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1130 = fn (%p033: Tensor[(640, 2048), float16], %p124: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %48 = reshape(%p033, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %49 = add(%48, %p124) /* ty=Tensor[(20, 32, 2048), float16] */;
    %50 = nn.relu(%49) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%50, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %1131 = %1130(%1129, meta[relay.Constant][212] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1132 = fn (%p032: Tensor[(640, 2048), float16], %p123: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p032, %p123, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1133 = %1132(%1131, meta[relay.Constant][213] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1134 = fn (%p031: Tensor[(640, 256), float16], %p122: Tensor[(256), float16], %p29: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %46 = reshape(%p031, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %47 = add(%46, %p122) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p29, %47) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1135 = %1134(%1133, meta[relay.Constant][214] /* ty=Tensor[(256), float16] */, %1125) /* ty=Tensor[(20, 32, 256), float16] */;
  %1136 = fn (%p0382: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0382, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1137 = %1136(%1135) /* ty=Tensor[(20, 32, 1), float16] */;
  %1138 = fn (%p0383: Tensor[(20, 32, 256), float16], %p1237: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0383, %p1237, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1139 = %1138(%1135, %1137) /* ty=Tensor[(20, 32, 1), float16] */;
  %1140 = fn (%p030: Tensor[(20, 32, 256), float16], %p121: Tensor[(20, 32, 1), float16], %p28: Tensor[(20, 32, 1), float16], %p34: float16, %p44: Tensor[(256), float16], %p54: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %41 = add(%p28, %p34) /* ty=Tensor[(20, 32, 1), float16] */;
    %42 = subtract(%p030, %p121) /* ty=Tensor[(20, 32, 256), float16] */;
    %43 = sqrt(%41) /* ty=Tensor[(20, 32, 1), float16] */;
    %44 = divide(%42, %43) /* ty=Tensor[(20, 32, 256), float16] */;
    %45 = multiply(%44, %p44) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%45, %p54) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1141 = %1140(%1135, %1137, %1139, meta[relay.Constant][215] /* ty=float16 */, meta[relay.Constant][216] /* ty=Tensor[(256), float16] */, meta[relay.Constant][217] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1142 = fn (%p029: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p029, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1143 = %1142(%1141) /* ty=Tensor[(640, 256), float16] */;
  %1144 = fn (%p028: Tensor[(640, 256), float16], %p120: Tensor[(768, 256), float16], Primitive=1, hash="04ac05d167ecdbf3") -> Tensor[(640, 768), float16] {
    nn.dense(%p028, %p120, units=None, out_dtype="float16") /* ty=Tensor[(640, 768), float16] */
  };
  %1145 = %1144(%1143, meta[relay.Constant][218] /* ty=Tensor[(768, 256), float16] */) /* ty=Tensor[(640, 768), float16] */;
  %1146 = fn (%p027: Tensor[(640, 768), float16], %p119: Tensor[(768), float16], Primitive=1, hash="80c014aaf7cfccf1") -> Tensor[(20, 32, 768), float16] {
    %40 = reshape(%p027, newshape=[20, 32, 768]) /* ty=Tensor[(20, 32, 768), float16] */;
    add(%40, %p119) /* ty=Tensor[(20, 32, 768), float16] */
  };
  %1147 = %1146(%1145, meta[relay.Constant][219] /* ty=Tensor[(768), float16] */) /* ty=Tensor[(20, 32, 768), float16] */;
  %1148 = fn (%p026: Tensor[(20, 32, 768), float16], %p118: float16, Primitive=1, hash="de4101e462bb9a7f") -> Tensor[(256, 20, 32), float16] {
    %37 = strided_slice(%p026, begin=[0, 0, 0], end=[20, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %38 = multiply(%37, %p118) /* ty=Tensor[(20, 32, 256), float16] */;
    %39 = reshape(%38, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%39, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1151 = fn (%p0384: Tensor[(20, 32, 768), float16], Primitive=1, hash="4badd8bfe25e53d2") -> Tensor[(256, 20, 32), float16] {
    %1149 = strided_slice(%p0384, begin=[0, 0, 256], end=[20, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %1150 = reshape(%1149, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%1150, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1152 = %1148(%1147, meta[relay.Constant][220] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %1153 = %1151(%1147) /* ty=Tensor[(256, 20, 32), float16] */;
  %1154 = fn (%p025: Tensor[(256, 20, 32), float16], %p117: Tensor[(256, 20, 32), float16], Primitive=1, hash="975bad0d9f5301da") -> Tensor[(256, 20, 20), float32] {
    %36 = nn.batch_matmul(%p025, %p117, meta[relay.attrs.BatchMatmulAttrs][3]) /* ty=Tensor[(256, 20, 20), float16] */;
    cast(%36, dtype="float32") /* ty=Tensor[(256, 20, 20), float32] */
  };
  %1155 = %1154(%1152, %1153) /* ty=Tensor[(256, 20, 20), float32] */;
  %1156 = fn (%p024: Tensor[(256, 20, 20), float32], Primitive=1, hash="985d00da8c548640") -> Tensor[(256, 20, 20), float32] {
    nn.softmax(%p024) /* ty=Tensor[(256, 20, 20), float32] */
  };
  %1157 = %1156(%1155) /* ty=Tensor[(256, 20, 20), float32] */;
  %1158 = fn (%p023: Tensor[(256, 20, 20), float32], Primitive=1, hash="bdfe29b20dca652d") -> Tensor[(256, 20, 20), float16] {
    cast(%p023, dtype="float16") /* ty=Tensor[(256, 20, 20), float16] */
  };
  %1161 = fn (%p0385: Tensor[(20, 32, 768), float16], Primitive=1, hash="92510a0b36460620") -> Tensor[(256, 32, 20), float16] {
    %1159 = strided_slice(%p0385, begin=[0, 0, 512], end=[20, 32, 768], strides=[1, 1, 1], axes=None) /* ty=Tensor[(20, 32, 256), float16] */;
    %1160 = reshape(%1159, newshape=[-1, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%1160, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 20), float16] */
  };
  %1162 = %1158(%1157) /* ty=Tensor[(256, 20, 20), float16] */;
  %1163 = %1161(%1147) /* ty=Tensor[(256, 32, 20), float16] */;
  %1164 = fn (%p022: Tensor[(256, 20, 20), float16], %p116: Tensor[(256, 32, 20), float16], Primitive=1, hash="82265f1da2c6dc13") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p022, %p116, meta[relay.attrs.BatchMatmulAttrs][2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1165 = %1164(%1162, %1163) /* ty=Tensor[(256, 20, 32), float16] */;
  %1166 = fn (%p021: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %35 = transpose(%p021, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%35, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1167 = %1166(%1165) /* ty=Tensor[(640, 256), float16] */;
  %1168 = fn (%p020: Tensor[(640, 256), float16], %p115: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p020, %p115, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1169 = %1168(%1167, meta[relay.Constant][221] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1170 = fn (%p019: Tensor[(640, 256), float16], %p114: Tensor[(256), float16], %p27: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %33 = reshape(%p019, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %34 = add(%33, %p114) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p27, %34) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1171 = %1170(%1169, meta[relay.Constant][222] /* ty=Tensor[(256), float16] */, %1141) /* ty=Tensor[(20, 32, 256), float16] */;
  %1172 = fn (%p0386: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0386, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1173 = %1172(%1171) /* ty=Tensor[(20, 32, 1), float16] */;
  %1174 = fn (%p0387: Tensor[(20, 32, 256), float16], %p1238: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0387, %p1238, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1175 = %1174(%1171, %1173) /* ty=Tensor[(20, 32, 1), float16] */;
  %1176 = fn (%p018: Tensor[(20, 32, 256), float16], %p113: Tensor[(20, 32, 1), float16], %p26: Tensor[(20, 32, 1), float16], %p33: float16, %p43: Tensor[(256), float16], %p53: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %28 = add(%p26, %p33) /* ty=Tensor[(20, 32, 1), float16] */;
    %29 = subtract(%p018, %p113) /* ty=Tensor[(20, 32, 256), float16] */;
    %30 = sqrt(%28) /* ty=Tensor[(20, 32, 1), float16] */;
    %31 = divide(%29, %30) /* ty=Tensor[(20, 32, 256), float16] */;
    %32 = multiply(%31, %p43) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%32, %p53) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1177 = %1176(%1171, %1173, %1175, meta[relay.Constant][223] /* ty=float16 */, meta[relay.Constant][224] /* ty=Tensor[(256), float16] */, meta[relay.Constant][225] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1178 = fn (%p017: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p017, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1179 = %1178(%1177) /* ty=Tensor[(640, 256), float16] */;
  %1180 = fn (%p016: Tensor[(640, 256), float16], %p112: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p016, %p112, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1181 = %1180(%1179, meta[relay.Constant][226] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1182 = fn (%p015: Tensor[(640, 256), float16], %p111: Tensor[(256), float16], %p25: float16, Primitive=1, hash="d3fcebc92dc4e5b0") -> Tensor[(256, 20, 32), float16] {
    %24 = reshape(%p015, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %25 = add(%24, %p111) /* ty=Tensor[(20, 32, 256), float16] */;
    %26 = multiply(%25, %p25) /* ty=Tensor[(20, 32, 256), float16] */;
    %27 = reshape(%26, newshape=[20, 256, 32]) /* ty=Tensor[(20, 256, 32), float16] */;
    transpose(%27, axes=[1, 0, 2]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1186 = fn (%p0390: Tensor[(320, 256), float16], %p1240: Tensor[(512, 256), float16], Primitive=1, hash="32c6ce19570a230f") -> Tensor[(320, 512), float16] {
    nn.dense(%p0390, %p1240, units=None, out_dtype="float16") /* ty=Tensor[(320, 512), float16] */
  };
  %1187 = %1186(%730, meta[relay.Constant][229] /* ty=Tensor[(512, 256), float16] */) /* ty=Tensor[(320, 512), float16] */;
  %1188 = fn (%p0389: Tensor[(320, 512), float16], %p1239: Tensor[(512), float16], Primitive=1, hash="0caaa1bd8ebac0a0") -> Tensor[(10, 32, 512), float16] {
    %1185 = reshape(%p0389, newshape=[10, 32, 512]) /* ty=Tensor[(10, 32, 512), float16] */;
    add(%1185, %p1239) /* ty=Tensor[(10, 32, 512), float16] */
  };
  %1189 = %1188(%1187, meta[relay.Constant][230] /* ty=Tensor[(512), float16] */) /* ty=Tensor[(10, 32, 512), float16] */;
  %1190 = fn (%p0388: Tensor[(10, 32, 512), float16], Primitive=1, hash="e248df606122c926") -> Tensor[(256, 10, 32), float16] {
    %1183 = strided_slice(%p0388, begin=[0, 0, 0], end=[10, 32, 256], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1184 = reshape(%1183, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1184, axes=[1, 0, 2]) /* ty=Tensor[(256, 10, 32), float16] */
  };
  %1191 = %1182(%1181, meta[relay.Constant][227] /* ty=Tensor[(256), float16] */, meta[relay.Constant][228] /* ty=float16 */) /* ty=Tensor[(256, 20, 32), float16] */;
  %1192 = %1190(%1189) /* ty=Tensor[(256, 10, 32), float16] */;
  %1193 = fn (%p014: Tensor[(256, 20, 32), float16], %p110: Tensor[(256, 10, 32), float16], Primitive=1, hash="cad30400f8f32773") -> Tensor[(256, 20, 10), float32] {
    %23 = nn.batch_matmul(%p014, %p110, meta[relay.attrs.BatchMatmulAttrs][1]) /* ty=Tensor[(256, 20, 10), float16] */;
    cast(%23, dtype="float32") /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1194 = %1193(%1191, %1192) /* ty=Tensor[(256, 20, 10), float32] */;
  %1195 = fn (%p013: Tensor[(256, 20, 10), float32], Primitive=1, hash="6cd2f803767df217") -> Tensor[(256, 20, 10), float32] {
    nn.softmax(%p013) /* ty=Tensor[(256, 20, 10), float32] */
  };
  %1196 = %1195(%1194) /* ty=Tensor[(256, 20, 10), float32] */;
  %1197 = fn (%p012: Tensor[(256, 20, 10), float32], Primitive=1, hash="59519f9c078d9afa") -> Tensor[(256, 20, 10), float16] {
    cast(%p012, dtype="float16") /* ty=Tensor[(256, 20, 10), float16] */
  };
  %1200 = fn (%p0391: Tensor[(10, 32, 512), float16], Primitive=1, hash="460344fa1261c360") -> Tensor[(256, 32, 10), float16] {
    %1198 = strided_slice(%p0391, begin=[0, 0, 256], end=[10, 32, 512], strides=[1, 1, 1], axes=None) /* ty=Tensor[(10, 32, 256), float16] */;
    %1199 = reshape(%1198, newshape=[-1, 256, 32]) /* ty=Tensor[(10, 256, 32), float16] */;
    transpose(%1199, axes=[1, 2, 0]) /* ty=Tensor[(256, 32, 10), float16] */
  };
  %1201 = %1197(%1196) /* ty=Tensor[(256, 20, 10), float16] */;
  %1202 = %1200(%1189) /* ty=Tensor[(256, 32, 10), float16] */;
  %1203 = fn (%p011: Tensor[(256, 20, 10), float16], %p19: Tensor[(256, 32, 10), float16], Primitive=1, hash="d39bb160f126fac3") -> Tensor[(256, 20, 32), float16] {
    nn.batch_matmul(%p011, %p19, meta[relay.attrs.BatchMatmulAttrs][0]) /* ty=Tensor[(256, 20, 32), float16] */
  };
  %1204 = %1203(%1201, %1202) /* ty=Tensor[(256, 20, 32), float16] */;
  %1205 = fn (%p010: Tensor[(256, 20, 32), float16], Primitive=1, hash="0ab6b98064fff523") -> Tensor[(640, 256), float16] {
    %22 = transpose(%p010, axes=[1, 0, 2]) /* ty=Tensor[(20, 256, 32), float16] */;
    reshape(%22, newshape=[640, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1206 = %1205(%1204) /* ty=Tensor[(640, 256), float16] */;
  %1207 = fn (%p09: Tensor[(640, 256), float16], %p18: Tensor[(256, 256), float16], Primitive=1, hash="e36b5f28f5145c73") -> Tensor[(640, 256), float16] {
    nn.dense(%p09, %p18, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1208 = %1207(%1206, meta[relay.Constant][231] /* ty=Tensor[(256, 256), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1209 = fn (%p08: Tensor[(640, 256), float16], %p17: Tensor[(256), float16], %p24: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %20 = reshape(%p08, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %21 = add(%20, %p17) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p24, %21) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1210 = %1209(%1208, meta[relay.Constant][232] /* ty=Tensor[(256), float16] */, %1177) /* ty=Tensor[(20, 32, 256), float16] */;
  %1211 = fn (%p0392: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0392, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1212 = %1211(%1210) /* ty=Tensor[(20, 32, 1), float16] */;
  %1213 = fn (%p0393: Tensor[(20, 32, 256), float16], %p1241: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0393, %p1241, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1214 = %1213(%1210, %1212) /* ty=Tensor[(20, 32, 1), float16] */;
  %1215 = fn (%p07: Tensor[(20, 32, 256), float16], %p16: Tensor[(20, 32, 1), float16], %p23: Tensor[(20, 32, 1), float16], %p32: float16, %p42: Tensor[(256), float16], %p52: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %15 = add(%p23, %p32) /* ty=Tensor[(20, 32, 1), float16] */;
    %16 = subtract(%p07, %p16) /* ty=Tensor[(20, 32, 256), float16] */;
    %17 = sqrt(%15) /* ty=Tensor[(20, 32, 1), float16] */;
    %18 = divide(%16, %17) /* ty=Tensor[(20, 32, 256), float16] */;
    %19 = multiply(%18, %p42) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%19, %p52) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1216 = %1215(%1210, %1212, %1214, meta[relay.Constant][233] /* ty=float16 */, meta[relay.Constant][234] /* ty=Tensor[(256), float16] */, meta[relay.Constant][235] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1217 = fn (%p06: Tensor[(20, 32, 256), float16], Primitive=1, relay.reshape_only=1, hash="2d0b987c58cb62b4") -> Tensor[(640, 256), float16] {
    reshape(%p06, newshape=[-1, 256]) /* ty=Tensor[(640, 256), float16] */
  };
  %1218 = %1217(%1216) /* ty=Tensor[(640, 256), float16] */;
  %1219 = fn (%p05: Tensor[(640, 256), float16], %p15: Tensor[(2048, 256), float16], Primitive=1, hash="1afcddf72dbb7ee1") -> Tensor[(640, 2048), float16] {
    nn.dense(%p05, %p15, units=None, out_dtype="float16") /* ty=Tensor[(640, 2048), float16] */
  };
  %1220 = %1219(%1218, meta[relay.Constant][236] /* ty=Tensor[(2048, 256), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1221 = fn (%p04: Tensor[(640, 2048), float16], %p14: Tensor[(2048), float16], Primitive=1, hash="701d9f1584db06e3") -> Tensor[(640, 2048), float16] {
    %12 = reshape(%p04, newshape=[20, 32, 2048]) /* ty=Tensor[(20, 32, 2048), float16] */;
    %13 = add(%12, %p14) /* ty=Tensor[(20, 32, 2048), float16] */;
    %14 = nn.relu(%13) /* ty=Tensor[(20, 32, 2048), float16] */;
    reshape(%14, newshape=[-1, 2048]) /* ty=Tensor[(640, 2048), float16] */
  };
  %1222 = %1221(%1220, meta[relay.Constant][237] /* ty=Tensor[(2048), float16] */) /* ty=Tensor[(640, 2048), float16] */;
  %1223 = fn (%p03: Tensor[(640, 2048), float16], %p13: Tensor[(256, 2048), float16], Primitive=1, hash="ab947611fff03c20") -> Tensor[(640, 256), float16] {
    nn.dense(%p03, %p13, units=None, out_dtype="float16") /* ty=Tensor[(640, 256), float16] */
  };
  %1224 = %1223(%1222, meta[relay.Constant][238] /* ty=Tensor[(256, 2048), float16] */) /* ty=Tensor[(640, 256), float16] */;
  %1225 = fn (%p02: Tensor[(640, 256), float16], %p12: Tensor[(256), float16], %p22: Tensor[(20, 32, 256), float16], Primitive=1, hash="51efcd5f50ae8e48") -> Tensor[(20, 32, 256), float16] {
    %10 = reshape(%p02, newshape=[20, 32, 256]) /* ty=Tensor[(20, 32, 256), float16] */;
    %11 = add(%10, %p12) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%p22, %11) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1226 = %1225(%1224, meta[relay.Constant][239] /* ty=Tensor[(256), float16] */, %1216) /* ty=Tensor[(20, 32, 256), float16] */;
  %1227 = fn (%p0394: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0394, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1228 = %1227(%1226) /* ty=Tensor[(20, 32, 1), float16] */;
  %1229 = fn (%p0395: Tensor[(20, 32, 256), float16], %p1242: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0395, %p1242, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1230 = %1229(%1226, %1228) /* ty=Tensor[(20, 32, 1), float16] */;
  %1231 = fn (%p01: Tensor[(20, 32, 256), float16], %p11: Tensor[(20, 32, 1), float16], %p21: Tensor[(20, 32, 1), float16], %p31: float16, %p41: Tensor[(256), float16], %p51: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %5 = add(%p21, %p31) /* ty=Tensor[(20, 32, 1), float16] */;
    %6 = subtract(%p01, %p11) /* ty=Tensor[(20, 32, 256), float16] */;
    %7 = sqrt(%5) /* ty=Tensor[(20, 32, 1), float16] */;
    %8 = divide(%6, %7) /* ty=Tensor[(20, 32, 256), float16] */;
    %9 = multiply(%8, %p41) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%9, %p51) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1232 = %1231(%1226, %1228, %1230, meta[relay.Constant][240] /* ty=float16 */, meta[relay.Constant][241] /* ty=Tensor[(256), float16] */, meta[relay.Constant][242] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */;
  %1233 = fn (%p0396: Tensor[(20, 32, 256), float16], Primitive=1, hash="1044e97c9e5588b3") -> Tensor[(20, 32, 1), float16] {
    mean(%p0396, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1234 = %1233(%1232) /* ty=Tensor[(20, 32, 1), float16] */;
  %1235 = fn (%p0397: Tensor[(20, 32, 256), float16], %p1243: Tensor[(20, 32, 1), float16], Primitive=1, hash="94a6b45dc800c6cc") -> Tensor[(20, 32, 1), float16] {
    variance(%p0397, %p1243, axis=[-1], keepdims=True) /* ty=Tensor[(20, 32, 1), float16] */
  };
  %1236 = %1235(%1232, %1234) /* ty=Tensor[(20, 32, 1), float16] */;
  %1237 = fn (%p0: Tensor[(20, 32, 256), float16], %p1: Tensor[(20, 32, 1), float16], %p2: Tensor[(20, 32, 1), float16], %p3: float16, %p4: Tensor[(256), float16], %p5: Tensor[(256), float16], Primitive=1, hash="aa35bd8ce9b0d4b2") -> Tensor[(20, 32, 256), float16] {
    %0 = add(%p2, %p3) /* ty=Tensor[(20, 32, 1), float16] */;
    %1 = subtract(%p0, %p1) /* ty=Tensor[(20, 32, 256), float16] */;
    %2 = sqrt(%0) /* ty=Tensor[(20, 32, 1), float16] */;
    %3 = divide(%1, %2) /* ty=Tensor[(20, 32, 256), float16] */;
    %4 = multiply(%3, %p4) /* ty=Tensor[(20, 32, 256), float16] */;
    add(%4, %p5) /* ty=Tensor[(20, 32, 256), float16] */
  };
  %1237(%1232, %1234, %1236, meta[relay.Constant][243] /* ty=float16 */, meta[relay.Constant][244] /* ty=Tensor[(256), float16] */, meta[relay.Constant][245] /* ty=Tensor[(256), float16] */) /* ty=Tensor[(20, 32, 256), float16] */
}